diff options
Diffstat (limited to 'drivers/gles3/rasterizer_storage_gles3.cpp')
| -rw-r--r-- | drivers/gles3/rasterizer_storage_gles3.cpp | 4914 |
1 files changed, 2258 insertions, 2656 deletions
diff --git a/drivers/gles3/rasterizer_storage_gles3.cpp b/drivers/gles3/rasterizer_storage_gles3.cpp index 4fea28ddb7..ed4be1cb3d 100644 --- a/drivers/gles3/rasterizer_storage_gles3.cpp +++ b/drivers/gles3/rasterizer_storage_gles3.cpp @@ -27,32 +27,30 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "rasterizer_storage_gles3.h" +#include "global_config.h" #include "rasterizer_canvas_gles3.h" #include "rasterizer_scene_gles3.h" -#include "global_config.h" /* TEXTURE API */ -#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_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_S3TC_DXT1_EXT 0x83F1 #define _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 #define _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 -#define _EXT_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70 -#define _EXT_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71 -#define _EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72 -#define _EXT_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73 - +#define _EXT_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70 +#define _EXT_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71 +#define _EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72 +#define _EXT_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73 #define _EXT_COMPRESSED_RED_RGTC1_EXT 0x8DBB #define _EXT_COMPRESSED_RED_RGTC1 0x8DBB @@ -62,33 +60,27 @@ #define _EXT_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC #define _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD #define _EXT_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE -#define _EXT_ETC1_RGB8_OES 0x8D64 - - - -#define _EXT_SLUMINANCE_NV 0x8C46 -#define _EXT_SLUMINANCE_ALPHA_NV 0x8C44 -#define _EXT_SRGB8_NV 0x8C41 -#define _EXT_SLUMINANCE8_NV 0x8C47 -#define _EXT_SLUMINANCE8_ALPHA8_NV 0x8C45 +#define _EXT_ETC1_RGB8_OES 0x8D64 +#define _EXT_SLUMINANCE_NV 0x8C46 +#define _EXT_SLUMINANCE_ALPHA_NV 0x8C44 +#define _EXT_SRGB8_NV 0x8C41 +#define _EXT_SLUMINANCE8_NV 0x8C47 +#define _EXT_SLUMINANCE8_ALPHA8_NV 0x8C45 -#define _EXT_COMPRESSED_SRGB_S3TC_DXT1_NV 0x8C4C -#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV 0x8C4D -#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV 0x8C4E -#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV 0x8C4F +#define _EXT_COMPRESSED_SRGB_S3TC_DXT1_NV 0x8C4C +#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV 0x8C4D +#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV 0x8C4E +#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV 0x8C4F +#define _EXT_ATC_RGB_AMD 0x8C92 +#define _EXT_ATC_RGBA_EXPLICIT_ALPHA_AMD 0x8C93 +#define _EXT_ATC_RGBA_INTERPOLATED_ALPHA_AMD 0x87EE +#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F -#define _EXT_ATC_RGB_AMD 0x8C92 -#define _EXT_ATC_RGBA_EXPLICIT_ALPHA_AMD 0x8C93 -#define _EXT_ATC_RGBA_INTERPOLATED_ALPHA_AMD 0x87EE - - -#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F - -#define _GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE -#define _GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF +#define _GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE +#define _GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF #define _EXT_COMPRESSED_R11_EAC 0x9270 #define _EXT_COMPRESSED_SIGNED_R11_EAC 0x9271 @@ -108,235 +100,221 @@ GLuint RasterizerStorageGLES3::system_fbo = 0; -Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Image::Format p_format, uint32_t p_flags,GLenum& r_gl_format,GLenum& r_gl_internal_format,GLenum &r_gl_type,bool &r_compressed,bool &srgb) { - +Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool &srgb) { - r_compressed=false; - r_gl_format=0; - Image image=p_image; - srgb=false; + r_compressed = false; + r_gl_format = 0; + Image image = p_image; + srgb = false; - bool need_decompress=false; + bool need_decompress = false; - switch(p_format) { + switch (p_format) { case Image::FORMAT_L8: { #ifdef GLES_OVER_GL - r_gl_internal_format=GL_R8; - r_gl_format=GL_RED; - r_gl_type=GL_UNSIGNED_BYTE; + r_gl_internal_format = GL_R8; + r_gl_format = GL_RED; + r_gl_type = GL_UNSIGNED_BYTE; #else - r_gl_internal_format=GL_LUMINANCE; - r_gl_format=GL_LUMINANCE; - r_gl_type=GL_UNSIGNED_BYTE; + r_gl_internal_format = GL_LUMINANCE; + r_gl_format = GL_LUMINANCE; + r_gl_type = GL_UNSIGNED_BYTE; #endif } break; case Image::FORMAT_LA8: { #ifdef GLES_OVER_GL - r_gl_internal_format=GL_RG8; - r_gl_format=GL_RG; - r_gl_type=GL_UNSIGNED_BYTE; + r_gl_internal_format = GL_RG8; + r_gl_format = GL_RG; + r_gl_type = GL_UNSIGNED_BYTE; #else - r_gl_internal_format=GL_LUMINANCE_ALPHA; - r_gl_format=GL_LUMINANCE_ALPHA; - r_gl_type=GL_UNSIGNED_BYTE; + r_gl_internal_format = GL_LUMINANCE_ALPHA; + r_gl_format = GL_LUMINANCE_ALPHA; + r_gl_type = GL_UNSIGNED_BYTE; #endif } break; case Image::FORMAT_R8: { - r_gl_internal_format=GL_R8; - r_gl_format=GL_RED; - r_gl_type=GL_UNSIGNED_BYTE; + r_gl_internal_format = GL_R8; + r_gl_format = GL_RED; + r_gl_type = GL_UNSIGNED_BYTE; } break; case Image::FORMAT_RG8: { - r_gl_internal_format=GL_RG8; - r_gl_format=GL_RG; - r_gl_type=GL_UNSIGNED_BYTE; + r_gl_internal_format = GL_RG8; + r_gl_format = GL_RG; + r_gl_type = GL_UNSIGNED_BYTE; } break; case Image::FORMAT_RGB8: { - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8:GL_RGB8; - r_gl_format=GL_RGB; - r_gl_type=GL_UNSIGNED_BYTE; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? GL_SRGB8 : GL_RGB8; + r_gl_format = GL_RGB; + r_gl_type = GL_UNSIGNED_BYTE; + srgb = true; } break; case Image::FORMAT_RGBA8: { - r_gl_format=GL_RGBA; - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8_ALPHA8:GL_RGBA8; - r_gl_type=GL_UNSIGNED_BYTE; - srgb=true; + r_gl_format = GL_RGBA; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? GL_SRGB8_ALPHA8 : GL_RGBA8; + r_gl_type = GL_UNSIGNED_BYTE; + srgb = true; } break; case Image::FORMAT_RGB565: { #ifndef GLES_OVER_GL - r_gl_internal_format=GL_RGB565; + r_gl_internal_format = GL_RGB565; #else -//#warning TODO: Convert tod 555 if 565 is not supported (GLES3.3-) - r_gl_internal_format=GL_RGB5; + //#warning TODO: Convert tod 555 if 565 is not supported (GLES3.3-) + r_gl_internal_format = GL_RGB5; #endif //r_gl_internal_format=GL_RGB565; - r_gl_format=GL_RGB; - r_gl_type=GL_UNSIGNED_SHORT_5_6_5; + r_gl_format = GL_RGB; + r_gl_type = GL_UNSIGNED_SHORT_5_6_5; } break; case Image::FORMAT_RGBA4444: { - r_gl_internal_format=GL_RGBA4; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_SHORT_4_4_4_4; + r_gl_internal_format = GL_RGBA4; + 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; - + 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: { - - r_gl_internal_format=GL_R32F; - r_gl_format=GL_RED; - r_gl_type=GL_FLOAT; + r_gl_internal_format = GL_R32F; + r_gl_format = GL_RED; + r_gl_type = GL_FLOAT; } break; case Image::FORMAT_RGF: { - r_gl_internal_format=GL_RG32F; - r_gl_format=GL_RG; - r_gl_type=GL_FLOAT; + r_gl_internal_format = GL_RG32F; + r_gl_format = GL_RG; + r_gl_type = GL_FLOAT; } break; case Image::FORMAT_RGBF: { - r_gl_internal_format=GL_RGB32F; - r_gl_format=GL_RGB; - r_gl_type=GL_FLOAT; + r_gl_internal_format = GL_RGB32F; + r_gl_format = GL_RGB; + r_gl_type = GL_FLOAT; } break; case Image::FORMAT_RGBAF: { - r_gl_internal_format=GL_RGBA32F; - r_gl_format=GL_RGBA; - r_gl_type=GL_FLOAT; + r_gl_internal_format = GL_RGBA32F; + r_gl_format = GL_RGBA; + r_gl_type = GL_FLOAT; } break; case Image::FORMAT_RH: { - r_gl_internal_format=GL_R32F; - r_gl_format=GL_RED; - r_gl_type=GL_HALF_FLOAT; + r_gl_internal_format = GL_R32F; + r_gl_format = GL_RED; + r_gl_type = GL_HALF_FLOAT; } break; case Image::FORMAT_RGH: { - r_gl_internal_format=GL_RG32F; - r_gl_format=GL_RG; - r_gl_type=GL_HALF_FLOAT; + r_gl_internal_format = GL_RG32F; + r_gl_format = GL_RG; + r_gl_type = GL_HALF_FLOAT; } break; case Image::FORMAT_RGBH: { - r_gl_internal_format=GL_RGB32F; - r_gl_format=GL_RGB; - r_gl_type=GL_HALF_FLOAT; + r_gl_internal_format = GL_RGB32F; + r_gl_format = GL_RGB; + r_gl_type = GL_HALF_FLOAT; } break; case Image::FORMAT_RGBAH: { - r_gl_internal_format=GL_RGBA32F; - r_gl_format=GL_RGBA; - r_gl_type=GL_HALF_FLOAT; + r_gl_internal_format = GL_RGBA32F; + r_gl_format = GL_RGBA; + r_gl_type = GL_HALF_FLOAT; } break; case Image::FORMAT_DXT1: { if (config.s3tc_supported) { - - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_S3TC_DXT1_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_S3TC_DXT1_NV : _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } - } break; case Image::FORMAT_DXT3: { - if (config.s3tc_supported) { - - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV : _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } - } break; case Image::FORMAT_DXT5: { if (config.s3tc_supported) { - - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV : _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } - } break; case Image::FORMAT_ATI1: { if (config.latc_supported) { - - r_gl_internal_format=_EXT_COMPRESSED_LUMINANCE_LATC1_EXT; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = _EXT_COMPRESSED_LUMINANCE_LATC1_EXT; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } - - } break; case Image::FORMAT_ATI2: { if (config.latc_supported) { - - r_gl_internal_format=_EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; + r_gl_internal_format = _EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; } else { - need_decompress=true; + need_decompress = true; } } break; @@ -344,93 +322,86 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Ima if (config.bptc_supported) { - - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:_EXT_COMPRESSED_RGBA_BPTC_UNORM; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM : _EXT_COMPRESSED_RGBA_BPTC_UNORM; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } } break; case Image::FORMAT_BPTC_RGBF: { 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; + 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; + need_decompress = true; } } break; case Image::FORMAT_BPTC_RGBFU: { if (config.bptc_supported) { - - r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT; - r_gl_format=GL_RGB; - r_gl_type=GL_FLOAT; - r_compressed=true; + 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; + need_decompress = true; } } break; case Image::FORMAT_PVRTC2: { if (config.pvrtc_supported) { - - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT:_EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT : _EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } } break; case Image::FORMAT_PVRTC2A: { if (config.pvrtc_supported) { - - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT:_EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT : _EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } - } break; case Image::FORMAT_PVRTC4: { if (config.pvrtc_supported) { - - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT:_EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT : _EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } } break; @@ -438,32 +409,30 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Ima if (config.pvrtc_supported) { - - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT:_EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT : _EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } - } break; case Image::FORMAT_ETC: { if (config.etc_supported) { - r_gl_internal_format=_EXT_ETC1_RGB8_OES; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; + 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; + need_decompress = true; } } break; @@ -471,102 +440,99 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Ima if (config.etc2_supported) { - r_gl_internal_format=_EXT_COMPRESSED_R11_EAC; - r_gl_format=GL_RED; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; + r_gl_internal_format = _EXT_COMPRESSED_R11_EAC; + r_gl_format = GL_RED; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; } else { - need_decompress=true; + need_decompress = true; } } break; case Image::FORMAT_ETC2_R11S: { if (config.etc2_supported) { - r_gl_internal_format=_EXT_COMPRESSED_SIGNED_R11_EAC; - r_gl_format=GL_RED; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; + r_gl_internal_format = _EXT_COMPRESSED_SIGNED_R11_EAC; + r_gl_format = GL_RED; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; } else { - need_decompress=true; + need_decompress = true; } } break; case Image::FORMAT_ETC2_RG11: { if (config.etc2_supported) { - r_gl_internal_format=_EXT_COMPRESSED_RG11_EAC; - r_gl_format=GL_RG; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; + r_gl_internal_format = _EXT_COMPRESSED_RG11_EAC; + r_gl_format = GL_RG; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; } else { - need_decompress=true; + need_decompress = true; } } break; case Image::FORMAT_ETC2_RG11S: { if (config.etc2_supported) { - r_gl_internal_format=_EXT_COMPRESSED_SIGNED_RG11_EAC; - r_gl_format=GL_RG; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; + r_gl_internal_format = _EXT_COMPRESSED_SIGNED_RG11_EAC; + r_gl_format = GL_RG; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; } else { - need_decompress=true; + need_decompress = true; } } break; case Image::FORMAT_ETC2_RGB8: { if (config.etc2_supported) { - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ETC2:_EXT_COMPRESSED_RGB8_ETC2; - r_gl_format=GL_RGB; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; - + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB8_ETC2 : _EXT_COMPRESSED_RGB8_ETC2; + r_gl_format = GL_RGB; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } } break; case Image::FORMAT_ETC2_RGBA8: { if (config.etc2_supported) { - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:_EXT_COMPRESSED_RGBA8_ETC2_EAC; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; - + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : _EXT_COMPRESSED_RGBA8_ETC2_EAC; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } } break; case Image::FORMAT_ETC2_RGB8A1: { if (config.etc2_supported) { - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:_EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; - r_gl_format=GL_RGBA; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=true; - srgb=true; - + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 : _EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; + r_gl_format = GL_RGBA; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = true; + srgb = true; } else { - need_decompress=true; + need_decompress = true; } } break; default: { @@ -579,26 +545,23 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Ima if (!image.empty()) { image.decompress(); - ERR_FAIL_COND_V(image.is_compressed(),image); + ERR_FAIL_COND_V(image.is_compressed(), image); image.convert(Image::FORMAT_RGBA8); } - - r_gl_format=GL_RGBA; - r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8_ALPHA8:GL_RGBA8; - r_gl_type=GL_UNSIGNED_BYTE; - r_compressed=false; - srgb=true; + r_gl_format = GL_RGBA; + r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? GL_SRGB8_ALPHA8 : GL_RGBA8; + r_gl_type = GL_UNSIGNED_BYTE; + r_compressed = false; + srgb = true; return image; - } - return image; } -static const GLenum _cube_side_enum[6]={ +static const GLenum _cube_side_enum[6] = { GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_X, @@ -612,16 +575,15 @@ static const GLenum _cube_side_enum[6]={ RID RasterizerStorageGLES3::texture_create() { Texture *texture = memnew(Texture); - ERR_FAIL_COND_V(!texture,RID()); + 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 ); + texture->active = false; + texture->total_data_size = 0; + return texture_owner.make_rid(texture); } -void RasterizerStorageGLES3::texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags) { +void RasterizerStorageGLES3::texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags) { int components; GLenum format; @@ -631,56 +593,52 @@ void RasterizerStorageGLES3::texture_allocate(RID p_texture,int p_width, int p_h bool compressed; bool srgb; - if (p_flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) { - p_flags&=~VS::TEXTURE_FLAG_MIPMAPS; // no mipies for video + if (p_flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING) { + p_flags &= ~VS::TEXTURE_FLAG_MIPMAPS; // no mipies for video } - - Texture *texture = texture_owner.get( p_texture ); + Texture *texture = texture_owner.get(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; + texture->width = p_width; + texture->height = p_height; + texture->format = p_format; + texture->flags = p_flags; + texture->stored_cube_sides = 0; texture->target = (p_flags & VS::TEXTURE_FLAG_CUBEMAP) ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D; - _get_gl_image_and_format(Image(),texture->format,texture->flags,format,internal_format,type,compressed,srgb); + _get_gl_image_and_format(Image(), texture->format, texture->flags, format, internal_format, type, compressed, srgb); texture->alloc_width = texture->width; texture->alloc_height = texture->height; - - texture->gl_format_cache=format; - texture->gl_type_cache=type; - texture->gl_internal_format_cache=internal_format; - texture->compressed=compressed; - texture->srgb=srgb; - texture->data_size=0; - texture->mipmaps=1; - + texture->gl_format_cache = format; + texture->gl_type_cache = type; + texture->gl_internal_format_cache = internal_format; + texture->compressed = compressed; + texture->srgb = srgb; + texture->data_size = 0; + texture->mipmaps = 1; glActiveTexture(GL_TEXTURE0); glBindTexture(texture->target, texture->tex_id); - - if (p_flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) { + if (p_flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING) { //prealloc if video - glTexImage2D(texture->target, 0, internal_format, p_width, p_height, 0, format, type,NULL); + glTexImage2D(texture->target, 0, internal_format, p_width, p_height, 0, format, type, NULL); } - texture->active=true; + texture->active = true; } -void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side) { +void RasterizerStorageGLES3::texture_set_data(RID p_texture, const Image &p_image, VS::CubeMapSide p_cube_side) { - Texture * texture = texture_owner.get(p_texture); + Texture *texture = texture_owner.get(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.empty() ); + ERR_FAIL_COND(texture->format != p_image.get_format()); + ERR_FAIL_COND(p_image.empty()); GLenum type; GLenum format; @@ -688,32 +646,29 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image bool compressed; bool srgb; - - if (config.keep_original_textures && !(texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING)) { - texture->images[p_cube_side]=p_image; + if (config.keep_original_textures && !(texture->flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING)) { + texture->images[p_cube_side] = p_image; } - Image img = _get_gl_image_and_format(p_image, p_image.get_format(),texture->flags,format,internal_format,type,compressed,srgb); + Image img = _get_gl_image_and_format(p_image, p_image.get_format(), texture->flags, format, internal_format, type, compressed, srgb); - if (config.shrink_textures_x2 && (p_image.has_mipmaps() || !p_image.is_compressed()) && !(texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING)) { + 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); + 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) { + 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_RGB565) { img.resize(texture->alloc_width, texture->alloc_height, Image::INTERPOLATE_BILINEAR); - } }; + GLenum blit_target = (texture->target == GL_TEXTURE_CUBE_MAP) ? _cube_side_enum[p_cube_side] : GL_TEXTURE_2D; - GLenum blit_target = (texture->target == GL_TEXTURE_CUBE_MAP)?_cube_side_enum[p_cube_side]:GL_TEXTURE_2D; - - texture->data_size=img.get_data().size(); + texture->data_size = img.get_data().size(); PoolVector<uint8_t>::Read read = img.get_data().read(); glActiveTexture(GL_TEXTURE0); @@ -721,87 +676,83 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image 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); + 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); + 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); - + glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } } - if (config.srgb_decode_supported && srgb) { - if (texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) { + if (texture->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) { - glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT); - texture->using_srgb=true; + glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT); + texture->using_srgb = true; } else { - glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT); - texture->using_srgb=false; + glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _SKIP_DECODE_EXT); + texture->using_srgb = false; } } - if (texture->flags&VS::TEXTURE_FLAG_FILTER) { + if (texture->flags & VS::TEXTURE_FLAG_FILTER) { - glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering + glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Filtering } else { - glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_NEAREST); // raw Filtering + 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_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 ); + 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 ); + glTexParameterf(texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameterf(texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } - //set swizle for older format compatibility +//set swizle for older format compatibility #ifdef GLES_OVER_GL - switch(texture->format) { + switch (texture->format) { case Image::FORMAT_L8: { - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_RED); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_RED); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_ONE); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_RED); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_RED); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_ONE); } break; case Image::FORMAT_LA8: { - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_RED); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_RED); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_GREEN); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_RED); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_RED); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_GREEN); } break; default: { - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_GREEN); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_BLUE); - glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_ALPHA); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_GREEN); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_BLUE); + glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); } break; - } #endif if (config.use_anisotropic_filter) { - if (texture->flags&VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) { + if (texture->flags & VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) { glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, config.anisotropic_level); } else { @@ -809,72 +760,66 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image } } - int mipmaps= (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && img.has_mipmaps()) ? img.get_mipmap_count() +1: 1; - + 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 w = img.get_width(); + int h = img.get_height(); - int tsize=0; - for(int i=0;i<mipmaps;i++) { + int tsize = 0; + for (int i = 0; i < mipmaps; i++) { - int size,ofs; - img.get_mipmap_offset_and_size(i,ofs,size); + int size, ofs; + img.get_mipmap_offset_and_size(i, ofs, size); //print_line("mipmap: "+itos(i)+" size: "+itos(size)+" w: "+itos(mm_w)+", h: "+itos(mm_h)); if (texture->compressed) { glPixelStorei(GL_UNPACK_ALIGNMENT, 4); - glCompressedTexImage2D( blit_target, i, internal_format,w,h,0,size,&read[ofs] ); + glCompressedTexImage2D(blit_target, i, internal_format, w, h, 0, size, &read[ofs]); } else { 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] ); + 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]); + glTexImage2D(blit_target, i, internal_format, w, h, 0, format, type, &read[ofs]); } - } - tsize+=size; - - w = MAX(1,w>>1); - h = MAX(1,h>>1); + 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; + 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,_rinfo.texture_mem); - texture->stored_cube_sides|=(1<<p_cube_side); + texture->stored_cube_sides |= (1 << p_cube_side); - if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && mipmaps==1 && !texture->ignore_mipmaps && (!(texture->flags&VS::TEXTURE_FLAG_CUBEMAP) || texture->stored_cube_sides==(1<<6)-1)) { + if (texture->flags & VS::TEXTURE_FLAG_MIPMAPS && mipmaps == 1 && !texture->ignore_mipmaps && (!(texture->flags & VS::TEXTURE_FLAG_CUBEMAP) || texture->stored_cube_sides == (1 << 6) - 1)) { //generate mipmaps if they were requested and the image does not contain them glGenerateMipmap(texture->target); - } else if (mipmaps>1) { + } else if (mipmaps > 1) { glTexParameteri(texture->target, GL_TEXTURE_BASE_LEVEL, 0); - glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, mipmaps-1); - + glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, mipmaps - 1); } - texture->mipmaps=mipmaps; + texture->mipmaps = mipmaps; //texture_set_flags(p_texture,texture->flags); - - } -Image RasterizerStorageGLES3::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side) const { +Image RasterizerStorageGLES3::texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side) const { - Texture * texture = texture_owner.get(p_texture); + Texture *texture = texture_owner.get(p_texture); - ERR_FAIL_COND_V(!texture,Image()); - ERR_FAIL_COND_V(!texture->active,Image()); - ERR_FAIL_COND_V(texture->data_size==0,Image()); - ERR_FAIL_COND_V(texture->render_target,Image()); + ERR_FAIL_COND_V(!texture, Image()); + ERR_FAIL_COND_V(!texture->active, Image()); + ERR_FAIL_COND_V(texture->data_size == 0, Image()); + ERR_FAIL_COND_V(texture->render_target, Image()); if (!texture->images[p_cube_side].empty()) return texture->images[p_cube_side]; @@ -883,46 +828,44 @@ Image RasterizerStorageGLES3::texture_get_data(RID p_texture,VS::CubeMapSide p_c PoolVector<uint8_t> data; - int data_size = Image::get_image_data_size(texture->alloc_width,texture->alloc_height,texture->format,texture->mipmaps>1?-1:0); + int data_size = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, texture->format, texture->mipmaps > 1 ? -1 : 0); - data.resize(data_size*2); //add some memory at the end, just in case for buggy drivers + 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); + glBindTexture(texture->target, texture->tex_id); glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); - print_line("GET FORMAT: "+Image::get_format_name(texture->format)+" mipmaps: "+itos(texture->mipmaps)); - + print_line("GET FORMAT: " + Image::get_format_name(texture->format) + " mipmaps: " + itos(texture->mipmaps)); - for(int i=0;i<texture->mipmaps;i++) { + for (int i = 0; i < texture->mipmaps; i++) { - int ofs=0; - if (i>0) { - ofs=Image::get_image_data_size(texture->alloc_width,texture->alloc_height,texture->format,i-1); + int ofs = 0; + if (i > 0) { + ofs = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, texture->format, i - 1); } if (texture->compressed) { glPixelStorei(GL_PACK_ALIGNMENT, 4); - glGetCompressedTexImage(texture->target,i,&wb[ofs]); + 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]); + glGetTexImage(texture->target, i, texture->gl_format_cache, texture->gl_type_cache, &wb[ofs]); } } - - wb=PoolVector<uint8_t>::Write(); + wb = PoolVector<uint8_t>::Write(); data.resize(data_size); - Image img(texture->alloc_width,texture->alloc_height,texture->mipmaps>1?true:false,texture->format,data); + Image img(texture->alloc_width, texture->alloc_height, texture->mipmaps > 1 ? true : false, texture->format, data); return img; #else @@ -932,44 +875,40 @@ Image RasterizerStorageGLES3::texture_get_data(RID p_texture,VS::CubeMapSide p_c #endif } -void RasterizerStorageGLES3::texture_set_flags(RID p_texture,uint32_t p_flags) { +void RasterizerStorageGLES3::texture_set_flags(RID p_texture, uint32_t p_flags) { - Texture *texture = texture_owner.get( p_texture ); + Texture *texture = texture_owner.get(p_texture); ERR_FAIL_COND(!texture); if (texture->render_target) { - p_flags&=VS::TEXTURE_FLAG_FILTER;//can change only filter + p_flags &= VS::TEXTURE_FLAG_FILTER; //can change only filter } - bool had_mipmaps = texture->flags&VS::TEXTURE_FLAG_MIPMAPS; + bool had_mipmaps = texture->flags & VS::TEXTURE_FLAG_MIPMAPS; glActiveTexture(GL_TEXTURE0); glBindTexture(texture->target, texture->tex_id); uint32_t cube = texture->flags & VS::TEXTURE_FLAG_CUBEMAP; - texture->flags=p_flags|cube; // can't remove a cube from being a cube + texture->flags = p_flags | cube; // can't remove a cube from being a cube + 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_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 ); + 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 ); - + glTexParameterf(texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameterf(texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } - if (config.use_anisotropic_filter) { - if (texture->flags&VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) { + if (texture->flags & VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) { glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, config.anisotropic_level); } else { @@ -977,278 +916,256 @@ void RasterizerStorageGLES3::texture_set_flags(RID p_texture,uint32_t p_flags) { } } - if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps) { - if (!had_mipmaps && texture->mipmaps==1) { + 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); + 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 { + 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); - + glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } } - if (config.srgb_decode_supported && texture->srgb) { - if (texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) { + if (texture->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) { - glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT); - texture->using_srgb=true; + glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT); + texture->using_srgb = true; } else { - glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT); - texture->using_srgb=false; + glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _SKIP_DECODE_EXT); + texture->using_srgb = false; } } - if (texture->flags&VS::TEXTURE_FLAG_FILTER) { + if (texture->flags & VS::TEXTURE_FLAG_FILTER) { - glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering + glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Filtering } else { - glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_NEAREST); // raw Filtering + glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // raw Filtering } - } uint32_t RasterizerStorageGLES3::texture_get_flags(RID p_texture) const { - Texture * texture = texture_owner.get(p_texture); + Texture *texture = texture_owner.get(p_texture); - ERR_FAIL_COND_V(!texture,0); + ERR_FAIL_COND_V(!texture, 0); return texture->flags; - } Image::Format RasterizerStorageGLES3::texture_get_format(RID p_texture) const { - Texture * texture = texture_owner.get(p_texture); + Texture *texture = texture_owner.get(p_texture); - ERR_FAIL_COND_V(!texture,Image::FORMAT_L8); + ERR_FAIL_COND_V(!texture, Image::FORMAT_L8); return texture->format; } uint32_t RasterizerStorageGLES3::texture_get_width(RID p_texture) const { - Texture * texture = texture_owner.get(p_texture); + Texture *texture = texture_owner.get(p_texture); - ERR_FAIL_COND_V(!texture,0); + ERR_FAIL_COND_V(!texture, 0); return texture->width; } uint32_t RasterizerStorageGLES3::texture_get_height(RID p_texture) const { - Texture * texture = texture_owner.get(p_texture); + Texture *texture = texture_owner.get(p_texture); - ERR_FAIL_COND_V(!texture,0); + ERR_FAIL_COND_V(!texture, 0); return texture->height; } +void RasterizerStorageGLES3::texture_set_size_override(RID p_texture, int p_width, int p_height) { -void RasterizerStorageGLES3::texture_set_size_override(RID p_texture,int p_width, int p_height) { - - Texture * texture = texture_owner.get(p_texture); + Texture *texture = texture_owner.get(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); + 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; - + texture->width = p_width; + texture->height = p_height; } -void RasterizerStorageGLES3::texture_set_path(RID p_texture,const String& p_path) { - Texture * texture = texture_owner.get(p_texture); +void RasterizerStorageGLES3::texture_set_path(RID p_texture, const String &p_path) { + Texture *texture = texture_owner.get(p_texture); ERR_FAIL_COND(!texture); - texture->path=p_path; - + texture->path = p_path; } -String RasterizerStorageGLES3::texture_get_path(RID p_texture) const{ +String RasterizerStorageGLES3::texture_get_path(RID p_texture) const { - Texture * texture = texture_owner.get(p_texture); - ERR_FAIL_COND_V(!texture,String()); + Texture *texture = texture_owner.get(p_texture); + ERR_FAIL_COND_V(!texture, String()); return texture->path; } -void RasterizerStorageGLES3::texture_debug_usage(List<VS::TextureInfo> *r_info){ +void RasterizerStorageGLES3::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()) { + for (List<RID>::Element *E = textures.front(); E; E = E->next()) { Texture *t = texture_owner.get(E->get()); if (!t) continue; VS::TextureInfo tinfo; - tinfo.path=t->path; - tinfo.format=t->format; - tinfo.size.x=t->alloc_width; - tinfo.size.y=t->alloc_height; - tinfo.bytes=t->total_data_size; + tinfo.path = t->path; + tinfo.format = t->format; + tinfo.size.x = t->alloc_width; + tinfo.size.y = t->alloc_height; + tinfo.bytes = t->total_data_size; r_info->push_back(tinfo); } - } void RasterizerStorageGLES3::texture_set_shrink_all_x2_on_set_data(bool p_enable) { - config.shrink_textures_x2=p_enable; + config.shrink_textures_x2 = p_enable; } void RasterizerStorageGLES3::textures_keep_original(bool p_enable) { - config.keep_original_textures=p_enable; + config.keep_original_textures = p_enable; } -void RasterizerStorageGLES3::texture_set_detect_3d_callback(RID p_texture,VisualServer::TextureDetectCallback p_callback,void* p_userdata) { +void RasterizerStorageGLES3::texture_set_detect_3d_callback(RID p_texture, VisualServer::TextureDetectCallback p_callback, void *p_userdata) { - Texture * texture = texture_owner.get(p_texture); + Texture *texture = texture_owner.get(p_texture); ERR_FAIL_COND(!texture); - texture->detect_3d=p_callback; - texture->detect_3d_ud=p_userdata; + texture->detect_3d = p_callback; + texture->detect_3d_ud = p_userdata; } -void RasterizerStorageGLES3::texture_set_detect_srgb_callback(RID p_texture,VisualServer::TextureDetectCallback p_callback,void* p_userdata){ - Texture * texture = texture_owner.get(p_texture); +void RasterizerStorageGLES3::texture_set_detect_srgb_callback(RID p_texture, VisualServer::TextureDetectCallback p_callback, void *p_userdata) { + Texture *texture = texture_owner.get(p_texture); ERR_FAIL_COND(!texture); - texture->detect_srgb=p_callback; - texture->detect_srgb_ud=p_userdata; - + texture->detect_srgb = p_callback; + texture->detect_srgb_ud = p_userdata; } +RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source, int p_resolution) const { + Texture *texture = texture_owner.get(p_source); + ERR_FAIL_COND_V(!texture, RID()); + ERR_FAIL_COND_V(!(texture->flags & VS::TEXTURE_FLAG_CUBEMAP), RID()); -RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source,int p_resolution) const { - - Texture * texture = texture_owner.get(p_source); - ERR_FAIL_COND_V(!texture,RID()); - ERR_FAIL_COND_V(!(texture->flags&VS::TEXTURE_FLAG_CUBEMAP),RID()); - - bool use_float=config.hdr_supported; + bool use_float = config.hdr_supported; - if (p_resolution<0) { - p_resolution=texture->width; + if (p_resolution < 0) { + p_resolution = texture->width; } - glBindVertexArray(0); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_SCISSOR_TEST); glDisable(GL_BLEND); - glActiveTexture(GL_TEXTURE0); glBindTexture(texture->target, texture->tex_id); if (config.srgb_decode_supported && texture->srgb && !texture->using_srgb) { - glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT); - texture->using_srgb=true; + glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT); + texture->using_srgb = true; #ifdef TOOLS_ENABLED - if (!(texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) { - texture->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR; + if (!(texture->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) { + texture->flags |= VS::TEXTURE_FLAG_CONVERT_TO_LINEAR; //notify that texture must be set to linear beforehand, so it works in other platforms when exported } #endif } - glActiveTexture(GL_TEXTURE1); GLuint new_cubemap; glGenTextures(1, &new_cubemap); glBindTexture(GL_TEXTURE_CUBE_MAP, new_cubemap); - GLuint tmp_fb; glGenFramebuffers(1, &tmp_fb); glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb); - int size = p_resolution; - int lod=0; + int lod = 0; shaders.cubemap_filter.bind(); - int mipmaps=6; + int mipmaps = 6; - int mm_level=mipmaps; + int mm_level = mipmaps; - GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2; + GLenum internal_format = use_float ? GL_RGBA16F : GL_RGB10_A2; GLenum format = GL_RGBA; - GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV; + GLenum type = use_float ? GL_HALF_FLOAT : GL_UNSIGNED_INT_2_10_10_10_REV; + while (mm_level) { - while(mm_level) { - - for(int i=0;i<6;i++) { - glTexImage2D(_cube_side_enum[i], lod, internal_format, size, size, 0, format, type, NULL); + for (int i = 0; i < 6; i++) { + glTexImage2D(_cube_side_enum[i], lod, internal_format, size, size, 0, format, type, NULL); } lod++; mm_level--; - if (size>1) - size>>=1; + if (size > 1) + size >>= 1; } glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0); - glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod - 1); - lod=0; - mm_level=mipmaps; + lod = 0; + mm_level = mipmaps; size = p_resolution; - shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,false); + shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID, false); - while(mm_level) { + while (mm_level) { - for(int i=0;i<6;i++) { + for (int i = 0; i < 6; i++) { glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _cube_side_enum[i], new_cubemap, lod); - glViewport(0,0,size,size); + glViewport(0, 0, size, size); glBindVertexArray(resources.quadie_array); - shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::FACE_ID,i); - shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,lod/float(mipmaps-1)); - + shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::FACE_ID, i); + shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS, lod / float(mipmaps - 1)); - glDrawArrays(GL_TRIANGLE_FAN,0,4); + glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glBindVertexArray(0); #ifdef DEBUG_ENABLED GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); - ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE); + ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE); #endif } - - - if (size>1) - size>>=1; + if (size > 1) + size >>= 1; lod++; mm_level--; - } - //restore ranges glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0); - glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod - 1); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); @@ -1259,59 +1176,58 @@ RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source,int p_r glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo); glDeleteFramebuffers(1, &tmp_fb); - Texture * ctex = memnew( Texture ); - - ctex->flags=VS::TEXTURE_FLAG_CUBEMAP|VS::TEXTURE_FLAG_MIPMAPS|VS::TEXTURE_FLAG_FILTER; - ctex->width=p_resolution; - ctex->height=p_resolution; - ctex->alloc_width=p_resolution; - ctex->alloc_height=p_resolution; - ctex->format=use_float?Image::FORMAT_RGBAH:Image::FORMAT_RGBA8; - ctex->target=GL_TEXTURE_CUBE_MAP; - ctex->gl_format_cache=format; - ctex->gl_internal_format_cache=internal_format; - ctex->gl_type_cache=type; - ctex->data_size=0; - ctex->compressed=false; - ctex->srgb=false; - ctex->total_data_size=0; - ctex->ignore_mipmaps=false; - ctex->mipmaps=mipmaps; - ctex->active=true; - ctex->tex_id=new_cubemap; - ctex->stored_cube_sides=(1<<6)-1; - ctex->render_target=NULL; + Texture *ctex = memnew(Texture); + + ctex->flags = VS::TEXTURE_FLAG_CUBEMAP | VS::TEXTURE_FLAG_MIPMAPS | VS::TEXTURE_FLAG_FILTER; + ctex->width = p_resolution; + ctex->height = p_resolution; + ctex->alloc_width = p_resolution; + ctex->alloc_height = p_resolution; + ctex->format = use_float ? Image::FORMAT_RGBAH : Image::FORMAT_RGBA8; + ctex->target = GL_TEXTURE_CUBE_MAP; + ctex->gl_format_cache = format; + ctex->gl_internal_format_cache = internal_format; + ctex->gl_type_cache = type; + ctex->data_size = 0; + ctex->compressed = false; + ctex->srgb = false; + ctex->total_data_size = 0; + ctex->ignore_mipmaps = false; + ctex->mipmaps = mipmaps; + ctex->active = true; + ctex->tex_id = new_cubemap; + ctex->stored_cube_sides = (1 << 6) - 1; + ctex->render_target = NULL; return texture_owner.make_rid(ctex); } - RID RasterizerStorageGLES3::skybox_create() { - SkyBox *skybox = memnew( SkyBox ); - skybox->radiance=0; + SkyBox *skybox = memnew(SkyBox); + skybox->radiance = 0; return skybox_owner.make_rid(skybox); } -void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, int p_radiance_size){ +void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, int p_radiance_size) { SkyBox *skybox = skybox_owner.getornull(p_skybox); ERR_FAIL_COND(!skybox); if (skybox->cubemap.is_valid()) { - skybox->cubemap=RID(); - glDeleteTextures(1,&skybox->radiance); - skybox->radiance=0; + skybox->cubemap = RID(); + glDeleteTextures(1, &skybox->radiance); + skybox->radiance = 0; } - skybox->cubemap=p_cube_map; + skybox->cubemap = p_cube_map; if (!skybox->cubemap.is_valid()) return; //cleared Texture *texture = texture_owner.getornull(skybox->cubemap); - if (!texture || !(texture->flags&VS::TEXTURE_FLAG_CUBEMAP)) { - skybox->cubemap=RID(); - ERR_FAIL_COND(!texture || !(texture->flags&VS::TEXTURE_FLAG_CUBEMAP)); + if (!texture || !(texture->flags & VS::TEXTURE_FLAG_CUBEMAP)) { + skybox->cubemap = RID(); + ERR_FAIL_COND(!texture || !(texture->flags & VS::TEXTURE_FLAG_CUBEMAP)); } glBindVertexArray(0); @@ -1320,23 +1236,21 @@ void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, in glDisable(GL_SCISSOR_TEST); glDisable(GL_BLEND); - glActiveTexture(GL_TEXTURE0); glBindTexture(texture->target, texture->tex_id); if (config.srgb_decode_supported && texture->srgb && !texture->using_srgb) { - glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT); - texture->using_srgb=true; + glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT); + texture->using_srgb = true; #ifdef TOOLS_ENABLED - if (!(texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) { - texture->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR; + if (!(texture->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) { + texture->flags |= VS::TEXTURE_FLAG_CONVERT_TO_LINEAR; //notify that texture must be set to linear beforehand, so it works in other platforms when exported } #endif } - glActiveTexture(GL_TEXTURE1); glGenTextures(1, &skybox->radiance); glBindTexture(GL_TEXTURE_2D, skybox->radiance); @@ -1346,75 +1260,70 @@ void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, in glGenFramebuffers(1, &tmp_fb); glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb); - int size = p_radiance_size; - int lod=0; - + int lod = 0; - int mipmaps=6; + int mipmaps = 6; - int mm_level=mipmaps; + int mm_level = mipmaps; - bool use_float=config.hdr_supported; + bool use_float = config.hdr_supported; - GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2; + GLenum internal_format = use_float ? GL_RGBA16F : GL_RGB10_A2; GLenum format = GL_RGBA; - GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV; + GLenum type = use_float ? GL_HALF_FLOAT : GL_UNSIGNED_INT_2_10_10_10_REV; - while(mm_level) { + while (mm_level) { - glTexImage2D(GL_TEXTURE_2D, lod, internal_format, size, size*2, 0, format, type, NULL); + glTexImage2D(GL_TEXTURE_2D, lod, internal_format, size, size * 2, 0, format, type, NULL); lod++; mm_level--; - if (size>1) - size>>=1; + if (size > 1) + size >>= 1; } glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod-1); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod - 1); - lod=0; - mm_level=mipmaps; + lod = 0; + mm_level = mipmaps; size = p_radiance_size; - shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,true); + shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID, true); shaders.cubemap_filter.bind(); - while(mm_level) { + while (mm_level) { - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, skybox->radiance, lod); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, skybox->radiance, lod); #ifdef DEBUG_ENABLED GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); - ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE); + ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE); #endif - for(int i=0;i<2;i++) { - glViewport(0,i*size,size,size); + for (int i = 0; i < 2; i++) { + glViewport(0, i * size, size, size); glBindVertexArray(resources.quadie_array); - shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::Z_FLIP,i>0); - shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,lod/float(mipmaps-1)); - + shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::Z_FLIP, i > 0); + shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS, lod / float(mipmaps - 1)); - glDrawArrays(GL_TRIANGLE_FAN,0,4); + glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glBindVertexArray(0); } - if (size>1) - size>>=1; + if (size > 1) + size >>= 1; lod++; mm_level--; - } - shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,false); - + shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID, false); //restore ranges glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod-1); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod - 1); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); @@ -1423,26 +1332,23 @@ void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, in glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo); glDeleteFramebuffers(1, &tmp_fb); - } - /* SHADER API */ +RID RasterizerStorageGLES3::shader_create(VS::ShaderMode p_mode) { -RID RasterizerStorageGLES3::shader_create(VS::ShaderMode p_mode){ - - Shader *shader = memnew( Shader ); - shader->mode=p_mode; + Shader *shader = memnew(Shader); + shader->mode = p_mode; RID rid = shader_owner.make_rid(shader); - shader_set_mode(rid,p_mode); + shader_set_mode(rid, p_mode); _shader_make_dirty(shader); - shader->self=rid; + shader->self = rid; return rid; } -void RasterizerStorageGLES3::_shader_make_dirty(Shader* p_shader) { +void RasterizerStorageGLES3::_shader_make_dirty(Shader *p_shader) { if (p_shader->dirty_list.in_list()) return; @@ -1450,217 +1356,212 @@ void RasterizerStorageGLES3::_shader_make_dirty(Shader* p_shader) { _shader_dirty_list.add(&p_shader->dirty_list); } -void RasterizerStorageGLES3::shader_set_mode(RID p_shader,VS::ShaderMode p_mode){ +void RasterizerStorageGLES3::shader_set_mode(RID p_shader, VS::ShaderMode p_mode) { - ERR_FAIL_INDEX(p_mode,VS::SHADER_MAX); - Shader *shader=shader_owner.get(p_shader); + ERR_FAIL_INDEX(p_mode, VS::SHADER_MAX); + Shader *shader = shader_owner.get(p_shader); ERR_FAIL_COND(!shader); - if (shader->custom_code_id && p_mode==shader->mode) + if (shader->custom_code_id && p_mode == shader->mode) return; - if (shader->custom_code_id) { shader->shader->free_custom_shader(shader->custom_code_id); - shader->custom_code_id=0; + shader->custom_code_id = 0; } - shader->mode=p_mode; + shader->mode = p_mode; - ShaderGLES3* shaders[VS::SHADER_MAX]={ + ShaderGLES3 *shaders[VS::SHADER_MAX] = { &scene->state.scene_shader, &canvas->state.canvas_shader, &this->shaders.particles, }; - shader->shader=shaders[p_mode]; + shader->shader = shaders[p_mode]; shader->custom_code_id = shader->shader->create_custom_shader(); _shader_make_dirty(shader); - } VS::ShaderMode RasterizerStorageGLES3::shader_get_mode(RID p_shader) const { - const Shader *shader=shader_owner.get(p_shader); - ERR_FAIL_COND_V(!shader,VS::SHADER_MAX); + const Shader *shader = shader_owner.get(p_shader); + ERR_FAIL_COND_V(!shader, VS::SHADER_MAX); return shader->mode; } -void RasterizerStorageGLES3::shader_set_code(RID p_shader, const String& p_code){ +void RasterizerStorageGLES3::shader_set_code(RID p_shader, const String &p_code) { - Shader *shader=shader_owner.get(p_shader); + Shader *shader = shader_owner.get(p_shader); ERR_FAIL_COND(!shader); - shader->code=p_code; + shader->code = p_code; _shader_make_dirty(shader); } -String RasterizerStorageGLES3::shader_get_code(RID p_shader) const{ - - const Shader *shader=shader_owner.get(p_shader); - ERR_FAIL_COND_V(!shader,String()); +String RasterizerStorageGLES3::shader_get_code(RID p_shader) const { + const Shader *shader = shader_owner.get(p_shader); + ERR_FAIL_COND_V(!shader, String()); return shader->code; } -void RasterizerStorageGLES3::_update_shader(Shader* p_shader) const { - +void RasterizerStorageGLES3::_update_shader(Shader *p_shader) const { - _shader_dirty_list.remove( &p_shader->dirty_list ); + _shader_dirty_list.remove(&p_shader->dirty_list); - p_shader->valid=false; + p_shader->valid = false; p_shader->uniforms.clear(); ShaderCompilerGLES3::GeneratedCode gen_code; - ShaderCompilerGLES3::IdentifierActions *actions=NULL; - + ShaderCompilerGLES3::IdentifierActions *actions = NULL; - - switch(p_shader->mode) { + switch (p_shader->mode) { case VS::SHADER_CANVAS_ITEM: { - p_shader->canvas_item.light_mode=Shader::CanvasItem::LIGHT_MODE_NORMAL; - p_shader->canvas_item.blend_mode=Shader::CanvasItem::BLEND_MODE_MIX; + p_shader->canvas_item.light_mode = Shader::CanvasItem::LIGHT_MODE_NORMAL; + p_shader->canvas_item.blend_mode = Shader::CanvasItem::BLEND_MODE_MIX; - 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); + 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); - 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); + 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); - actions=&shaders.actions_canvas; - actions->uniforms=&p_shader->uniforms; + actions = &shaders.actions_canvas; + actions->uniforms = &p_shader->uniforms; } break; 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_discard=false; - p_shader->spatial.unshaded=false; - p_shader->spatial.ontop=false; - p_shader->spatial.uses_sss=false; - p_shader->spatial.uses_vertex=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); + 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_discard = false; + p_shader->spatial.unshaded = false; + p_shader->spatial.ontop = false; + p_shader->spatial.uses_sss = false; + p_shader->spatial.uses_vertex = false; - 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["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["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_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_flags["unshaded"]=&p_shader->spatial.unshaded; - shaders.actions_scene.render_mode_flags["ontop"]=&p_shader->spatial.ontop; + 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.usage_flag_pointers["ALPHA"]=&p_shader->spatial.uses_alpha; - shaders.actions_scene.usage_flag_pointers["VERTEX"]=&p_shader->spatial.uses_vertex; + shaders.actions_scene.render_mode_flags["unshaded"] = &p_shader->spatial.unshaded; + shaders.actions_scene.render_mode_flags["ontop"] = &p_shader->spatial.ontop; - 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["ALPHA"] = &p_shader->spatial.uses_alpha; + shaders.actions_scene.usage_flag_pointers["VERTEX"] = &p_shader->spatial.uses_vertex; - actions=&shaders.actions_scene; - actions->uniforms=&p_shader->uniforms; + 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; + actions = &shaders.actions_scene; + actions->uniforms = &p_shader->uniforms; } break; case VS::SHADER_PARTICLES: { - actions=&shaders.actions_particles; - actions->uniforms=&p_shader->uniforms; + actions = &shaders.actions_particles; + actions->uniforms = &p_shader->uniforms; } break; - } + Error err = shaders.compiler.compile(p_shader->mode, p_shader->code, actions, p_shader->path, gen_code); - Error err = shaders.compiler.compile(p_shader->mode,p_shader->code,actions,p_shader->path,gen_code); + ERR_FAIL_COND(err != OK); + 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.defines); - ERR_FAIL_COND(err!=OK); + p_shader->ubo_size = gen_code.uniform_total_size; + p_shader->ubo_offsets = gen_code.uniform_offsets; + p_shader->texture_count = gen_code.texture_uniforms.size(); + p_shader->texture_hints = gen_code.texture_hints; - 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.defines); - - p_shader->ubo_size=gen_code.uniform_total_size; - p_shader->ubo_offsets=gen_code.uniform_offsets; - 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; + p_shader->uses_vertex_time = gen_code.uses_vertex_time; + p_shader->uses_fragment_time = gen_code.uses_fragment_time; //all materials using this shader will have to be invalidated, unfortunately - for (SelfList<Material>* E = p_shader->materials.first();E;E=E->next() ) { + for (SelfList<Material> *E = p_shader->materials.first(); E; E = E->next()) { _material_make_dirty(E->self()); } - p_shader->valid=true; + p_shader->valid = true; p_shader->version++; - - } void RasterizerStorageGLES3::update_dirty_shaders() { - while( _shader_dirty_list.first() ) { - _update_shader(_shader_dirty_list.first()->self() ); + while (_shader_dirty_list.first()) { + _update_shader(_shader_dirty_list.first()->self()); } } -void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const{ +void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const { - Shader *shader=shader_owner.get(p_shader); + Shader *shader = shader_owner.get(p_shader); ERR_FAIL_COND(!shader); - if (shader->dirty_list.in_list()) _update_shader(shader); // ok should be not anymore dirty + Map<int, StringName> order; - Map<int,StringName> order; - - - for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=shader->uniforms.front();E;E=E->next()) { + for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = shader->uniforms.front(); E; E = E->next()) { - - order[E->get().order]=E->key(); + order[E->get().order] = E->key(); } - - for(Map<int,StringName>::Element *E=order.front();E;E=E->next()) { + 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; - 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; + 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; + 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; 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; - pi.hint_string=rtos(u.hint_range[0])+","+rtos(u.hint_range[1]); + pi.type = Variant::INT; + 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]); } } break; @@ -1671,77 +1572,75 @@ void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyIn case ShaderLanguage::TYPE_UVEC3: case ShaderLanguage::TYPE_UVEC4: { - pi.type=Variant::POOL_INT_ARRAY; + pi.type = Variant::POOL_INT_ARRAY; } break; case ShaderLanguage::TYPE_FLOAT: { - pi.type=Variant::REAL; - 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]); + pi.type = Variant::REAL; + 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]); } } break; - case ShaderLanguage::TYPE_VEC2: pi.type=Variant::VECTOR2; break; - case ShaderLanguage::TYPE_VEC3: pi.type=Variant::VECTOR3; break; + 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; + if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) { + pi.type = Variant::COLOR; } else { - pi.type=Variant::PLANE; + 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_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"; + 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"; + pi.type = Variant::OBJECT; + pi.hint = PROPERTY_HINT_RESOURCE_TYPE; + pi.hint_string = "CubeMap"; } break; }; p_param_list->push_back(pi); - } } -void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture){ +void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) { - Shader *shader=shader_owner.get(p_shader); + 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; + shader->default_textures[p_name] = p_texture; else shader->default_textures.erase(p_name); _shader_make_dirty(shader); } -RID RasterizerStorageGLES3::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const{ +RID RasterizerStorageGLES3::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 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); + const Map<StringName, RID>::Element *E = shader->default_textures.find(p_name); if (!E) return RID(); return E->get(); } - /* COMMON MATERIAL API */ -void RasterizerStorageGLES3::_material_make_dirty(Material* p_material) const { +void RasterizerStorageGLES3::_material_make_dirty(Material *p_material) const { if (p_material->dirty_list.in_list()) return; @@ -1749,38 +1648,37 @@ void RasterizerStorageGLES3::_material_make_dirty(Material* p_material) const { _material_dirty_list.add(&p_material->dirty_list); } -RID RasterizerStorageGLES3::material_create(){ +RID RasterizerStorageGLES3::material_create() { - Material *material = memnew( Material ); + Material *material = memnew(Material); return material_owner.make_rid(material); } -void RasterizerStorageGLES3::material_set_shader(RID p_material, RID p_shader){ +void RasterizerStorageGLES3::material_set_shader(RID p_material, RID p_shader) { - Material *material = material_owner.get( p_material ); + Material *material = material_owner.get(p_material); ERR_FAIL_COND(!material); - Shader *shader=shader_owner.getornull(p_shader); + Shader *shader = shader_owner.getornull(p_shader); if (material->shader) { //if shader, remove from previous shader material list - material->shader->materials.remove( &material->list ); + material->shader->materials.remove(&material->list); } - material->shader=shader; + material->shader = shader; if (shader) { shader->materials.add(&material->list); } _material_make_dirty(material); - } -RID RasterizerStorageGLES3::material_get_shader(RID p_material) const{ +RID RasterizerStorageGLES3::material_get_shader(RID p_material) const { - const Material *material = material_owner.get( p_material ); - ERR_FAIL_COND_V(!material,RID()); + const Material *material = material_owner.get(p_material); + ERR_FAIL_COND_V(!material, RID()); if (material->shader) return material->shader->self; @@ -1788,23 +1686,22 @@ RID RasterizerStorageGLES3::material_get_shader(RID p_material) const{ return RID(); } -void RasterizerStorageGLES3::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value){ +void RasterizerStorageGLES3::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) { - Material *material = material_owner.get( p_material ); + Material *material = material_owner.get(p_material); ERR_FAIL_COND(!material); - if (p_value.get_type()==Variant::NIL) + if (p_value.get_type() == Variant::NIL) material->params.erase(p_param); else - material->params[p_param]=p_value; + material->params[p_param] = p_value; _material_make_dirty(material); - } -Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringName& p_param) const{ +Variant RasterizerStorageGLES3::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()); + 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]; @@ -1814,29 +1711,26 @@ Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringN void RasterizerStorageGLES3::material_set_line_width(RID p_material, float p_width) { - Material *material = material_owner.get( p_material ); + Material *material = material_owner.get(p_material); ERR_FAIL_COND(!material); - material->line_width=p_width; - - + material->line_width = p_width; } -bool RasterizerStorageGLES3::material_is_animated(RID p_material) { +bool RasterizerStorageGLES3::material_is_animated(RID p_material) { - Material *material = material_owner.get( p_material ); - ERR_FAIL_COND_V(!material,false); + Material *material = material_owner.get(p_material); + ERR_FAIL_COND_V(!material, false); if (material->dirty_list.in_list()) { _update_material(material); } return material->is_animated_cache; - } -bool RasterizerStorageGLES3::material_casts_shadows(RID p_material) { +bool RasterizerStorageGLES3::material_casts_shadows(RID p_material) { - Material *material = material_owner.get( p_material ); - ERR_FAIL_COND_V(!material,false); + Material *material = material_owner.get(p_material); + ERR_FAIL_COND_V(!material, false); if (material->dirty_list.in_list()) { _update_material(material); } @@ -1846,90 +1740,87 @@ bool RasterizerStorageGLES3::material_casts_shadows(RID p_material) { void RasterizerStorageGLES3::material_add_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance) { - Material *material = material_owner.get( p_material ); + Material *material = material_owner.get(p_material); ERR_FAIL_COND(!material); - Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.find(p_instance); + Map<RasterizerScene::InstanceBase *, int>::Element *E = material->instance_owners.find(p_instance); if (E) { E->get()++; } else { - material->instance_owners[p_instance]=1; + material->instance_owners[p_instance] = 1; } } void RasterizerStorageGLES3::material_remove_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance) { - Material *material = material_owner.get( p_material ); + Material *material = material_owner.get(p_material); ERR_FAIL_COND(!material); - Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.find(p_instance); + Map<RasterizerScene::InstanceBase *, int>::Element *E = material->instance_owners.find(p_instance); ERR_FAIL_COND(!E); E->get()--; - if (E->get()==0) { + if (E->get() == 0) { material->instance_owners.erase(E); } } - - -_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant& value, uint8_t *data,bool p_linear_color) { - switch(type) { +_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant &value, uint8_t *data, bool p_linear_color) { + switch (type) { case ShaderLanguage::TYPE_BOOL: { bool v = value; - GLuint *gui = (GLuint*)data; + GLuint *gui = (GLuint *)data; *gui = v ? GL_TRUE : GL_FALSE; } break; case ShaderLanguage::TYPE_BVEC2: { int v = value; - GLuint *gui = (GLuint*)data; - gui[0]=v&1 ? GL_TRUE : GL_FALSE; - gui[1]=v&2 ? GL_TRUE : GL_FALSE; + GLuint *gui = (GLuint *)data; + gui[0] = v & 1 ? GL_TRUE : GL_FALSE; + gui[1] = v & 2 ? GL_TRUE : GL_FALSE; } break; case ShaderLanguage::TYPE_BVEC3: { int v = value; - GLuint *gui = (GLuint*)data; - gui[0]=v&1 ? GL_TRUE : GL_FALSE; - gui[1]=v&2 ? GL_TRUE : GL_FALSE; - gui[2]=v&4 ? GL_TRUE : GL_FALSE; + GLuint *gui = (GLuint *)data; + gui[0] = v & 1 ? GL_TRUE : GL_FALSE; + gui[1] = v & 2 ? GL_TRUE : GL_FALSE; + gui[2] = v & 4 ? GL_TRUE : GL_FALSE; } break; case ShaderLanguage::TYPE_BVEC4: { int v = value; - GLuint *gui = (GLuint*)data; - gui[0]=v&1 ? GL_TRUE : GL_FALSE; - gui[1]=v&2 ? GL_TRUE : GL_FALSE; - gui[2]=v&4 ? GL_TRUE : GL_FALSE; - gui[3]=v&8 ? GL_TRUE : GL_FALSE; + GLuint *gui = (GLuint *)data; + gui[0] = v & 1 ? GL_TRUE : GL_FALSE; + gui[1] = v & 2 ? GL_TRUE : GL_FALSE; + gui[2] = v & 4 ? GL_TRUE : GL_FALSE; + gui[3] = v & 8 ? GL_TRUE : GL_FALSE; } break; case ShaderLanguage::TYPE_INT: { int v = value; - GLint *gui = (GLint*)data; - gui[0]=v; + GLint *gui = (GLint *)data; + gui[0] = v; } break; case ShaderLanguage::TYPE_IVEC2: { PoolVector<int> iv = value; int s = iv.size(); - GLint *gui = (GLint*)data; + GLint *gui = (GLint *)data; PoolVector<int>::Read r = iv.read(); - for(int i=0;i<2;i++) { - if (i<s) - gui[i]=r[i]; + for (int i = 0; i < 2; i++) { + if (i < s) + gui[i] = r[i]; else - gui[i]=0; - + gui[i] = 0; } } break; @@ -1937,387 +1828,372 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy PoolVector<int> iv = value; int s = iv.size(); - GLint *gui = (GLint*)data; + GLint *gui = (GLint *)data; PoolVector<int>::Read r = iv.read(); - for(int i=0;i<3;i++) { - if (i<s) - gui[i]=r[i]; + for (int i = 0; i < 3; i++) { + if (i < s) + gui[i] = r[i]; else - gui[i]=0; - + gui[i] = 0; } } break; case ShaderLanguage::TYPE_IVEC4: { - PoolVector<int> iv = value; int s = iv.size(); - GLint *gui = (GLint*)data; + GLint *gui = (GLint *)data; PoolVector<int>::Read r = iv.read(); - for(int i=0;i<4;i++) { - if (i<s) - gui[i]=r[i]; + for (int i = 0; i < 4; i++) { + if (i < s) + gui[i] = r[i]; else - gui[i]=0; - + gui[i] = 0; } } break; case ShaderLanguage::TYPE_UINT: { int v = value; - GLuint *gui = (GLuint*)data; - gui[0]=v; + GLuint *gui = (GLuint *)data; + gui[0] = v; } break; case ShaderLanguage::TYPE_UVEC2: { PoolVector<int> iv = value; int s = iv.size(); - GLuint *gui = (GLuint*)data; + GLuint *gui = (GLuint *)data; PoolVector<int>::Read r = iv.read(); - for(int i=0;i<2;i++) { - if (i<s) - gui[i]=r[i]; + for (int i = 0; i < 2; i++) { + if (i < s) + gui[i] = r[i]; else - gui[i]=0; - + gui[i] = 0; } } break; case ShaderLanguage::TYPE_UVEC3: { PoolVector<int> iv = value; int s = iv.size(); - GLuint *gui = (GLuint*)data; + GLuint *gui = (GLuint *)data; PoolVector<int>::Read r = iv.read(); - for(int i=0;i<3;i++) { - if (i<s) - gui[i]=r[i]; + for (int i = 0; i < 3; i++) { + if (i < s) + gui[i] = r[i]; else - gui[i]=0; + gui[i] = 0; } } break; case ShaderLanguage::TYPE_UVEC4: { PoolVector<int> iv = value; int s = iv.size(); - GLuint *gui = (GLuint*)data; + GLuint *gui = (GLuint *)data; PoolVector<int>::Read r = iv.read(); - for(int i=0;i<4;i++) { - if (i<s) - gui[i]=r[i]; + for (int i = 0; i < 4; i++) { + if (i < s) + gui[i] = r[i]; else - gui[i]=0; + gui[i] = 0; } } break; case ShaderLanguage::TYPE_FLOAT: { float v = value; - GLfloat *gui = (GLfloat*)data; - gui[0]=v; + GLfloat *gui = (GLfloat *)data; + gui[0] = v; } break; case ShaderLanguage::TYPE_VEC2: { Vector2 v = value; - GLfloat *gui = (GLfloat*)data; - gui[0]=v.x; - gui[1]=v.y; + GLfloat *gui = (GLfloat *)data; + gui[0] = v.x; + gui[1] = v.y; } break; case ShaderLanguage::TYPE_VEC3: { Vector3 v = value; - GLfloat *gui = (GLfloat*)data; - gui[0]=v.x; - gui[1]=v.y; - gui[2]=v.z; + GLfloat *gui = (GLfloat *)data; + gui[0] = v.x; + gui[1] = v.y; + gui[2] = v.z; } break; case ShaderLanguage::TYPE_VEC4: { - GLfloat *gui = (GLfloat*)data; + GLfloat *gui = (GLfloat *)data; - if (value.get_type()==Variant::COLOR) { - Color v=value; + if (value.get_type() == Variant::COLOR) { + Color v = value; if (p_linear_color) { - v=v.to_linear(); + v = v.to_linear(); } - gui[0]=v.r; - gui[1]=v.g; - gui[2]=v.b; - gui[3]=v.a; - } else if (value.get_type()==Variant::RECT2) { - Rect2 v=value; - - gui[0]=v.pos.x; - gui[1]=v.pos.y; - gui[2]=v.size.x; - gui[3]=v.size.y; - } else if (value.get_type()==Variant::QUAT) { - Quat v=value; - - gui[0]=v.x; - gui[1]=v.y; - gui[2]=v.z; - gui[3]=v.w; + gui[0] = v.r; + gui[1] = v.g; + gui[2] = v.b; + gui[3] = v.a; + } else if (value.get_type() == Variant::RECT2) { + Rect2 v = value; + + gui[0] = v.pos.x; + gui[1] = v.pos.y; + gui[2] = v.size.x; + gui[3] = v.size.y; + } else if (value.get_type() == Variant::QUAT) { + Quat v = value; + + gui[0] = v.x; + gui[1] = v.y; + gui[2] = v.z; + gui[3] = v.w; } else { - Plane v=value; - - gui[0]=v.normal.x; - gui[1]=v.normal.y; - gui[2]=v.normal.x; - gui[3]=v.d; + Plane v = value; + gui[0] = v.normal.x; + gui[1] = v.normal.y; + gui[2] = v.normal.x; + gui[3] = v.d; } } break; case ShaderLanguage::TYPE_MAT2: { Transform2D v = value; - GLfloat *gui = (GLfloat*)data; + GLfloat *gui = (GLfloat *)data; - gui[ 0]=v.elements[0][0]; - gui[ 1]=v.elements[0][1]; - gui[ 2]=v.elements[1][0]; - gui[ 3]=v.elements[1][1]; + gui[0] = v.elements[0][0]; + gui[1] = v.elements[0][1]; + gui[2] = v.elements[1][0]; + gui[3] = v.elements[1][1]; } break; case ShaderLanguage::TYPE_MAT3: { - Basis v = value; - GLfloat *gui = (GLfloat*)data; - - gui[ 0]=v.elements[0][0]; - gui[ 1]=v.elements[1][0]; - gui[ 2]=v.elements[2][0]; - gui[ 3]=0; - gui[ 4]=v.elements[0][1]; - gui[ 5]=v.elements[1][1]; - gui[ 6]=v.elements[2][1]; - gui[ 7]=0; - gui[ 8]=v.elements[0][2]; - gui[ 9]=v.elements[1][2]; - gui[10]=v.elements[2][2]; - gui[11]=0; + GLfloat *gui = (GLfloat *)data; + + gui[0] = v.elements[0][0]; + gui[1] = v.elements[1][0]; + gui[2] = v.elements[2][0]; + gui[3] = 0; + gui[4] = v.elements[0][1]; + gui[5] = v.elements[1][1]; + gui[6] = v.elements[2][1]; + gui[7] = 0; + gui[8] = v.elements[0][2]; + gui[9] = v.elements[1][2]; + gui[10] = v.elements[2][2]; + gui[11] = 0; } break; case ShaderLanguage::TYPE_MAT4: { Transform v = value; - GLfloat *gui = (GLfloat*)data; - - gui[ 0]=v.basis.elements[0][0]; - gui[ 1]=v.basis.elements[1][0]; - gui[ 2]=v.basis.elements[2][0]; - gui[ 3]=0; - gui[ 4]=v.basis.elements[0][1]; - gui[ 5]=v.basis.elements[1][1]; - gui[ 6]=v.basis.elements[2][1]; - gui[ 7]=0; - gui[ 8]=v.basis.elements[0][2]; - gui[ 9]=v.basis.elements[1][2]; - gui[10]=v.basis.elements[2][2]; - gui[11]=0; - gui[12]=v.origin.x; - gui[13]=v.origin.y; - gui[14]=v.origin.z; - gui[15]=1; + GLfloat *gui = (GLfloat *)data; + + gui[0] = v.basis.elements[0][0]; + gui[1] = v.basis.elements[1][0]; + gui[2] = v.basis.elements[2][0]; + gui[3] = 0; + gui[4] = v.basis.elements[0][1]; + gui[5] = v.basis.elements[1][1]; + gui[6] = v.basis.elements[2][1]; + gui[7] = 0; + gui[8] = v.basis.elements[0][2]; + gui[9] = v.basis.elements[1][2]; + gui[10] = v.basis.elements[2][2]; + gui[11] = 0; + gui[12] = v.origin.x; + gui[13] = v.origin.y; + gui[14] = v.origin.z; + gui[15] = 1; } break; default: {} } - } -_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value>& value, uint8_t *data) { +_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value> &value, uint8_t *data) { - switch(type) { + switch (type) { case ShaderLanguage::TYPE_BOOL: { - GLuint *gui = (GLuint*)data; + GLuint *gui = (GLuint *)data; *gui = value[0].boolean ? GL_TRUE : GL_FALSE; } break; case ShaderLanguage::TYPE_BVEC2: { - GLuint *gui = (GLuint*)data; - gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE; - gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE; + GLuint *gui = (GLuint *)data; + gui[0] = value[0].boolean ? GL_TRUE : GL_FALSE; + gui[1] = value[1].boolean ? GL_TRUE : GL_FALSE; } break; case ShaderLanguage::TYPE_BVEC3: { - GLuint *gui = (GLuint*)data; - gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE; - gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE; - gui[2]=value[2].boolean ? GL_TRUE : GL_FALSE; + GLuint *gui = (GLuint *)data; + gui[0] = value[0].boolean ? GL_TRUE : GL_FALSE; + gui[1] = value[1].boolean ? GL_TRUE : GL_FALSE; + gui[2] = value[2].boolean ? GL_TRUE : GL_FALSE; } break; case ShaderLanguage::TYPE_BVEC4: { - GLuint *gui = (GLuint*)data; - gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE; - gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE; - gui[2]=value[2].boolean ? GL_TRUE : GL_FALSE; - gui[3]=value[3].boolean ? GL_TRUE : GL_FALSE; + GLuint *gui = (GLuint *)data; + gui[0] = value[0].boolean ? GL_TRUE : GL_FALSE; + gui[1] = value[1].boolean ? GL_TRUE : GL_FALSE; + gui[2] = value[2].boolean ? GL_TRUE : GL_FALSE; + gui[3] = value[3].boolean ? GL_TRUE : GL_FALSE; } break; case ShaderLanguage::TYPE_INT: { - GLint *gui = (GLint*)data; - gui[0]=value[0].sint; + GLint *gui = (GLint *)data; + gui[0] = value[0].sint; } break; case ShaderLanguage::TYPE_IVEC2: { - GLint *gui = (GLint*)data; - - for(int i=0;i<2;i++) { - gui[i]=value[i].sint; + GLint *gui = (GLint *)data; + for (int i = 0; i < 2; i++) { + gui[i] = value[i].sint; } } break; case ShaderLanguage::TYPE_IVEC3: { - GLint *gui = (GLint*)data; - - for(int i=0;i<3;i++) { - gui[i]=value[i].sint; + GLint *gui = (GLint *)data; + for (int i = 0; i < 3; i++) { + gui[i] = value[i].sint; } } break; case ShaderLanguage::TYPE_IVEC4: { - GLint *gui = (GLint*)data; - - for(int i=0;i<4;i++) { - gui[i]=value[i].sint; + GLint *gui = (GLint *)data; + for (int i = 0; i < 4; i++) { + gui[i] = value[i].sint; } } break; case ShaderLanguage::TYPE_UINT: { - - GLuint *gui = (GLuint*)data; - gui[0]=value[0].uint; + GLuint *gui = (GLuint *)data; + gui[0] = value[0].uint; } break; case ShaderLanguage::TYPE_UVEC2: { - GLint *gui = (GLint*)data; + GLint *gui = (GLint *)data; - for(int i=0;i<2;i++) { - gui[i]=value[i].uint; + for (int i = 0; i < 2; i++) { + gui[i] = value[i].uint; } } break; case ShaderLanguage::TYPE_UVEC3: { - GLint *gui = (GLint*)data; + GLint *gui = (GLint *)data; - for(int i=0;i<3;i++) { - gui[i]=value[i].uint; + for (int i = 0; i < 3; i++) { + gui[i] = value[i].uint; } } break; case ShaderLanguage::TYPE_UVEC4: { - GLint *gui = (GLint*)data; + GLint *gui = (GLint *)data; - for(int i=0;i<4;i++) { - gui[i]=value[i].uint; + for (int i = 0; i < 4; i++) { + gui[i] = value[i].uint; } } break; case ShaderLanguage::TYPE_FLOAT: { - GLfloat *gui = (GLfloat*)data; - gui[0]=value[0].real; + GLfloat *gui = (GLfloat *)data; + gui[0] = value[0].real; } break; case ShaderLanguage::TYPE_VEC2: { - GLfloat *gui = (GLfloat*)data; + GLfloat *gui = (GLfloat *)data; - for(int i=0;i<2;i++) { - gui[i]=value[i].real; + for (int i = 0; i < 2; i++) { + gui[i] = value[i].real; } } break; case ShaderLanguage::TYPE_VEC3: { - GLfloat *gui = (GLfloat*)data; + GLfloat *gui = (GLfloat *)data; - for(int i=0;i<3;i++) { - gui[i]=value[i].real; + for (int i = 0; i < 3; i++) { + gui[i] = value[i].real; } } break; case ShaderLanguage::TYPE_VEC4: { - GLfloat *gui = (GLfloat*)data; + GLfloat *gui = (GLfloat *)data; - for(int i=0;i<4;i++) { - gui[i]=value[i].real; + for (int i = 0; i < 4; i++) { + gui[i] = value[i].real; } } break; case ShaderLanguage::TYPE_MAT2: { - GLfloat *gui = (GLfloat*)data; + GLfloat *gui = (GLfloat *)data; - for(int i=0;i<2;i++) { - gui[i]=value[i].real; + for (int i = 0; i < 2; i++) { + gui[i] = value[i].real; } } break; case ShaderLanguage::TYPE_MAT3: { - - - GLfloat *gui = (GLfloat*)data; - - gui[ 0]=value[0].real; - gui[ 1]=value[1].real; - gui[ 2]=value[2].real; - gui[ 3]=0; - gui[ 4]=value[3].real; - gui[ 5]=value[4].real; - gui[ 6]=value[5].real; - gui[ 7]=0; - gui[ 8]=value[6].real; - gui[ 9]=value[7].real; - gui[10]=value[8].real; - gui[11]=0; + GLfloat *gui = (GLfloat *)data; + + gui[0] = value[0].real; + gui[1] = value[1].real; + gui[2] = value[2].real; + gui[3] = 0; + gui[4] = value[3].real; + gui[5] = value[4].real; + gui[6] = value[5].real; + gui[7] = 0; + gui[8] = value[6].real; + gui[9] = value[7].real; + gui[10] = value[8].real; + gui[11] = 0; } break; case ShaderLanguage::TYPE_MAT4: { - GLfloat *gui = (GLfloat*)data; + GLfloat *gui = (GLfloat *)data; - for(int i=0;i<16;i++) { - gui[i]=value[i].real; + for (int i = 0; i < 16; i++) { + gui[i] = value[i].real; } } break; default: {} } - } - _FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type, uint8_t *data) { - switch(type) { + switch (type) { case ShaderLanguage::TYPE_BOOL: case ShaderLanguage::TYPE_INT: case ShaderLanguage::TYPE_UINT: case ShaderLanguage::TYPE_FLOAT: { - zeromem(data,4); + zeromem(data, 4); } break; case ShaderLanguage::TYPE_BVEC2: case ShaderLanguage::TYPE_IVEC2: case ShaderLanguage::TYPE_UVEC2: case ShaderLanguage::TYPE_VEC2: { - zeromem(data,8); + zeromem(data, 8); } break; case ShaderLanguage::TYPE_BVEC3: case ShaderLanguage::TYPE_IVEC3: @@ -2327,28 +2203,26 @@ _FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type, case ShaderLanguage::TYPE_IVEC4: case ShaderLanguage::TYPE_UVEC4: case ShaderLanguage::TYPE_VEC4: - case ShaderLanguage::TYPE_MAT2:{ + case ShaderLanguage::TYPE_MAT2: { - zeromem(data,16); + zeromem(data, 16); } break; - case ShaderLanguage::TYPE_MAT3:{ + case ShaderLanguage::TYPE_MAT3: { - zeromem(data,48); + zeromem(data, 48); } break; - case ShaderLanguage::TYPE_MAT4:{ - zeromem(data,64); + case ShaderLanguage::TYPE_MAT4: { + zeromem(data, 64); } break; default: {} } - } -void RasterizerStorageGLES3::_update_material(Material* material) { +void RasterizerStorageGLES3::_update_material(Material *material) { if (material->dirty_list.in_list()) - _material_dirty_list.remove( &material->dirty_list ); - + _material_dirty_list.remove(&material->dirty_list); if (material->shader && material->shader->dirty_list.in_list()) { _update_shader(material->shader); @@ -2359,90 +2233,85 @@ void RasterizerStorageGLES3::_update_material(Material* material) { bool can_cast_shadow = false; bool is_animated = false; - if (material->shader && material->shader->mode==VS::SHADER_SPATIAL) { + if (material->shader && material->shader->mode == VS::SHADER_SPATIAL) { - if (!material->shader->spatial.uses_alpha && material->shader->spatial.blend_mode==Shader::Spatial::BLEND_MODE_MIX) { - can_cast_shadow=true; + if (!material->shader->spatial.uses_alpha && material->shader->spatial.blend_mode == Shader::Spatial::BLEND_MODE_MIX) { + can_cast_shadow = true; } if (material->shader->spatial.uses_discard && material->shader->uses_fragment_time) { - is_animated=true; + is_animated = true; } if (material->shader->spatial.uses_vertex && material->shader->uses_vertex_time) { - is_animated=true; + is_animated = true; } - if (can_cast_shadow!=material->can_cast_shadow_cache || is_animated!=material->is_animated_cache) { - material->can_cast_shadow_cache=can_cast_shadow; - material->is_animated_cache=is_animated; + if (can_cast_shadow != material->can_cast_shadow_cache || is_animated != material->is_animated_cache) { + material->can_cast_shadow_cache = can_cast_shadow; + material->is_animated_cache = is_animated; - for(Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) { + for (Map<Geometry *, int>::Element *E = material->geometry_owners.front(); E; E = E->next()) { E->key()->material_changed_notify(); } - for(Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.front();E;E=E->next()) { + for (Map<RasterizerScene::InstanceBase *, int>::Element *E = material->instance_owners.front(); E; E = E->next()) { E->key()->base_material_changed(); } - } } - } - //clear ubo if it needs to be cleared if (material->ubo_size) { - if (!material->shader || material->shader->ubo_size!=material->ubo_size) { + if (!material->shader || material->shader->ubo_size != material->ubo_size) { //by by ubo - glDeleteBuffers(1,&material->ubo_id); - material->ubo_id=0; - material->ubo_size=0; + glDeleteBuffers(1, &material->ubo_id); + material->ubo_id = 0; + material->ubo_size = 0; } } //create ubo if it needs to be created - if (material->ubo_size==0 && material->shader && material->shader->ubo_size) { + if (material->ubo_size == 0 && material->shader && material->shader->ubo_size) { glGenBuffers(1, &material->ubo_id); glBindBuffer(GL_UNIFORM_BUFFER, material->ubo_id); glBufferData(GL_UNIFORM_BUFFER, material->shader->ubo_size, NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); - material->ubo_size=material->shader->ubo_size; + material->ubo_size = material->shader->ubo_size; } //fill up the UBO if it needs to be filled if (material->shader && material->ubo_size) { - uint8_t* local_ubo = (uint8_t*)alloca(material->ubo_size); + uint8_t *local_ubo = (uint8_t *)alloca(material->ubo_size); - for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) { + for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = material->shader->uniforms.front(); E; E = E->next()) { - if (E->get().order<0) + if (E->get().order < 0) continue; // texture, does not go here //regular uniform - uint8_t *data = &local_ubo[ material->shader->ubo_offsets[E->get().order] ]; + uint8_t *data = &local_ubo[material->shader->ubo_offsets[E->get().order]]; - Map<StringName,Variant>::Element *V = material->params.find(E->key()); + Map<StringName, Variant>::Element *V = material->params.find(E->key()); if (V) { - //user provided - _fill_std140_variant_ubo_value(E->get().type,V->get(),data,material->shader->mode==VS::SHADER_SPATIAL); + //user provided + _fill_std140_variant_ubo_value(E->get().type, V->get(), data, material->shader->mode == VS::SHADER_SPATIAL); - } else if (E->get().default_value.size()){ + } else if (E->get().default_value.size()) { //default value - _fill_std140_ubo_value(E->get().type,E->get().default_value,data); + _fill_std140_ubo_value(E->get().type, E->get().default_value, data); //value=E->get().default_value; } else { //zero because it was not provided - _fill_std140_ubo_empty(E->get().type,data); + _fill_std140_ubo_empty(E->get().type, data); } - - } - glBindBuffer(GL_UNIFORM_BUFFER,material->ubo_id); + glBindBuffer(GL_UNIFORM_BUFFER, material->ubo_id); glBufferSubData(GL_UNIFORM_BUFFER, 0, material->ubo_size, local_ubo); glBindBuffer(GL_UNIFORM_BUFFER, 0); } @@ -2452,70 +2321,64 @@ void RasterizerStorageGLES3::_update_material(Material* material) { material->textures.resize(material->shader->texture_count); - for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) { + for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = material->shader->uniforms.front(); E; E = E->next()) { - if (E->get().texture_order<0) + if (E->get().texture_order < 0) continue; // not a texture, does not go here RID texture; - Map<StringName,Variant>::Element *V = material->params.find(E->key()); + Map<StringName, Variant>::Element *V = material->params.find(E->key()); if (V) { - texture=V->get(); + texture = V->get(); } if (!texture.is_valid()) { - Map<StringName,RID>::Element *W = material->shader->default_textures.find(E->key()); + Map<StringName, RID>::Element *W = material->shader->default_textures.find(E->key()); if (W) { - texture=W->get(); + texture = W->get(); } } - material->textures[ E->get().texture_order ]=texture; - - + material->textures[E->get().texture_order] = texture; } - } else { material->textures.clear(); } - } -void RasterizerStorageGLES3::_material_add_geometry(RID p_material,Geometry *p_geometry) { +void RasterizerStorageGLES3::_material_add_geometry(RID p_material, Geometry *p_geometry) { - Material * material = material_owner.getornull(p_material); + Material *material = material_owner.getornull(p_material); ERR_FAIL_COND(!material); - Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry); + Map<Geometry *, int>::Element *I = material->geometry_owners.find(p_geometry); if (I) { I->get()++; } else { - material->geometry_owners[p_geometry]=1; + material->geometry_owners[p_geometry] = 1; } - } -void RasterizerStorageGLES3::_material_remove_geometry(RID p_material,Geometry *p_geometry) { +void RasterizerStorageGLES3::_material_remove_geometry(RID p_material, Geometry *p_geometry) { - Material * material = material_owner.getornull(p_material); + Material *material = material_owner.getornull(p_material); ERR_FAIL_COND(!material); - Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry); + Map<Geometry *, int>::Element *I = material->geometry_owners.find(p_geometry); ERR_FAIL_COND(!I); I->get()--; - if (I->get()==0) { + if (I->get() == 0) { material->geometry_owners.erase(I); } } - void RasterizerStorageGLES3::update_dirty_materials() { - while( _material_dirty_list.first() ) { + while (_material_dirty_list.first()) { Material *material = _material_dirty_list.first()->self(); @@ -2525,389 +2388,366 @@ void RasterizerStorageGLES3::update_dirty_materials() { /* MESH API */ -RID RasterizerStorageGLES3::mesh_create(){ +RID RasterizerStorageGLES3::mesh_create() { - Mesh * mesh = memnew( Mesh ); + Mesh *mesh = memnew(Mesh); return mesh_owner.make_rid(mesh); } - -void RasterizerStorageGLES3::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 Rect3& p_aabb,const Vector<PoolVector<uint8_t> >& p_blend_shapes,const Vector<Rect3>& p_bone_aabbs){ - +void RasterizerStorageGLES3::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 Rect3 &p_aabb, const Vector<PoolVector<uint8_t> > &p_blend_shapes, const Vector<Rect3> &p_bone_aabbs) { PoolVector<uint8_t> array = p_array; Mesh *mesh = mesh_owner.getornull(p_mesh); ERR_FAIL_COND(!mesh); - ERR_FAIL_COND(!(p_format&VS::ARRAY_FORMAT_VERTEX)); + 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; + uint32_t bones_weight = VS::ARRAY_FORMAT_BONES | VS::ARRAY_FORMAT_WEIGHTS; ERR_EXPLAIN("Array must have both bones and weights in format or none."); - ERR_FAIL_COND( (p_format&bones_weight) && (p_format&bones_weight)!=bones_weight ); + ERR_FAIL_COND((p_format & bones_weight) && (p_format & bones_weight) != bones_weight); } - //bool has_morph = p_blend_shapes.size(); Surface::Attrib attribs[VS::ARRAY_MAX]; - int stride=0; + int stride = 0; - for(int i=0;i<VS::ARRAY_MAX;i++) { + for (int i = 0; i < VS::ARRAY_MAX; i++) { - attribs[i].index=i; + attribs[i].index = i; - if (! (p_format&(1<<i) ) ) { - attribs[i].enabled=false; - attribs[i].integer=false; + 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; + attribs[i].enabled = true; + attribs[i].offset = stride; + attribs[i].integer = false; - switch(i) { + switch (i) { case VS::ARRAY_VERTEX: { - if (p_format&VS::ARRAY_FLAG_USE_2D_VERTICES) { - attribs[i].size=2; + 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; + attribs[i].size = (p_format & VS::ARRAY_COMPRESS_VERTEX) ? 4 : 3; } - if (p_format&VS::ARRAY_COMPRESS_VERTEX) { - attribs[i].type=GL_HALF_FLOAT; - stride+=attribs[i].size*2; + if (p_format & VS::ARRAY_COMPRESS_VERTEX) { + attribs[i].type = GL_HALF_FLOAT; + stride += attribs[i].size * 2; } else { - attribs[i].type=GL_FLOAT; - stride+=attribs[i].size*4; + attribs[i].type = GL_FLOAT; + stride += attribs[i].size * 4; } - attribs[i].normalized=GL_FALSE; + attribs[i].normalized = GL_FALSE; } break; case VS::ARRAY_NORMAL: { - attribs[i].size=3; + 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; + 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; + attribs[i].type = GL_FLOAT; + stride += 12; + attribs[i].normalized = GL_FALSE; } - - } break; case VS::ARRAY_TANGENT: { - attribs[i].size=4; + attribs[i].size = 4; - if (p_format&VS::ARRAY_COMPRESS_TANGENT) { - attribs[i].type=GL_BYTE; - stride+=4; - attribs[i].normalized=GL_TRUE; + 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; + attribs[i].type = GL_FLOAT; + stride += 16; + attribs[i].normalized = GL_FALSE; } - } break; case VS::ARRAY_COLOR: { - attribs[i].size=4; + attribs[i].size = 4; - if (p_format&VS::ARRAY_COMPRESS_COLOR) { - attribs[i].type=GL_UNSIGNED_BYTE; - stride+=4; - attribs[i].normalized=GL_TRUE; + 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; + attribs[i].type = GL_FLOAT; + stride += 16; + attribs[i].normalized = GL_FALSE; } - } break; case VS::ARRAY_TEX_UV: { - attribs[i].size=2; + attribs[i].size = 2; - if (p_format&VS::ARRAY_COMPRESS_TEX_UV) { - attribs[i].type=GL_HALF_FLOAT; - stride+=4; + if (p_format & VS::ARRAY_COMPRESS_TEX_UV) { + attribs[i].type = GL_HALF_FLOAT; + stride += 4; } else { - attribs[i].type=GL_FLOAT; - stride+=8; + attribs[i].type = GL_FLOAT; + stride += 8; } - attribs[i].normalized=GL_FALSE; - + attribs[i].normalized = GL_FALSE; } break; case VS::ARRAY_TEX_UV2: { - attribs[i].size=2; + attribs[i].size = 2; - if (p_format&VS::ARRAY_COMPRESS_TEX_UV2) { - attribs[i].type=GL_HALF_FLOAT; - stride+=4; + if (p_format & VS::ARRAY_COMPRESS_TEX_UV2) { + attribs[i].type = GL_HALF_FLOAT; + stride += 4; } else { - attribs[i].type=GL_FLOAT; - stride+=8; + attribs[i].type = GL_FLOAT; + stride += 8; } - attribs[i].normalized=GL_FALSE; - - + attribs[i].normalized = GL_FALSE; } break; case VS::ARRAY_BONES: { - attribs[i].size=4; + attribs[i].size = 4; - if (p_format&VS::ARRAY_FLAG_USE_16_BIT_BONES) { - attribs[i].type=GL_UNSIGNED_SHORT; - stride+=8; + 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].type = GL_UNSIGNED_BYTE; + stride += 4; } - attribs[i].normalized=GL_FALSE; - attribs[i].integer=true; - - + attribs[i].normalized = GL_FALSE; + attribs[i].integer = true; } break; case VS::ARRAY_WEIGHTS: { - attribs[i].size=4; + attribs[i].size = 4; - if (p_format&VS::ARRAY_COMPRESS_WEIGHTS) { + if (p_format & VS::ARRAY_COMPRESS_WEIGHTS) { - attribs[i].type=GL_UNSIGNED_SHORT; - stride+=8; - attribs[i].normalized=GL_TRUE; + 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; + attribs[i].type = GL_FLOAT; + stride += 16; + attribs[i].normalized = GL_FALSE; } } break; case VS::ARRAY_INDEX: { - attribs[i].size=1; + attribs[i].size = 1; - if (p_vertex_count>=(1<<16)) { - attribs[i].type=GL_UNSIGNED_INT; - attribs[i].stride=4; + 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].type = GL_UNSIGNED_SHORT; + attribs[i].stride = 2; } - attribs[i].normalized=GL_FALSE; + attribs[i].normalized = GL_FALSE; } break; - } } - for(int i=0;i<VS::ARRAY_MAX-1;i++) { - attribs[i].stride=stride; + for (int i = 0; i < VS::ARRAY_MAX - 1; i++) { + attribs[i].stride = stride; } //validate sizes 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) { + 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 ); + 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 *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++) { + 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++) { + for (int j = 0; j < (stride / 2) - 4; j++) { *w16++ = *r16++; } } - } - ERR_FAIL_COND(array.size()!=array_size); + ERR_FAIL_COND(array.size() != array_size); - if (p_format&VS::ARRAY_FORMAT_INDEX) { + if (p_format & VS::ARRAY_FORMAT_INDEX) { - index_array_size=attribs[VS::ARRAY_INDEX].stride*p_index_count; + 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_index_array.size()!=index_array_size); - - ERR_FAIL_COND(p_blend_shapes.size()!=mesh->blend_shape_count); + 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); + for (int i = 0; i < p_blend_shapes.size(); i++) { + ERR_FAIL_COND(p_blend_shapes[i].size() != array_size); } //ok 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 *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(); + surface->aabb = p_aabb; + surface->max_bone = p_bone_aabbs.size(); - for(int i=0;i<surface->skeleton_bone_used.size();i++) { - if (surface->skeleton_bone_aabb[i].size.x<0 || surface->skeleton_bone_aabb[i].size.y<0 || surface->skeleton_bone_aabb[i].size.z<0) { - surface->skeleton_bone_used[i]=false; + for (int i = 0; i < surface->skeleton_bone_used.size(); i++) { + if (surface->skeleton_bone_aabb[i].size.x < 0 || surface->skeleton_bone_aabb[i].size.y < 0 || surface->skeleton_bone_aabb[i].size.z < 0) { + surface->skeleton_bone_used[i] = false; } else { - surface->skeleton_bone_used[i]=true; + surface->skeleton_bone_used[i] = true; } } - for(int i=0;i<VS::ARRAY_MAX;i++) { - surface->attribs[i]=attribs[i]; + for (int i = 0; i < VS::ARRAY_MAX; i++) { + surface->attribs[i] = attribs[i]; } { 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(),GL_STATIC_DRAW); - glBindBuffer(GL_ARRAY_BUFFER,0); //unbind + glGenBuffers(1, &surface->vertex_id); + glBindBuffer(GL_ARRAY_BUFFER, surface->vertex_id); + glBufferData(GL_ARRAY_BUFFER, array_size, vr.ptr(), GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind - - if (p_format&VS::ARRAY_FORMAT_INDEX) { + 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); //unbind - - + 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); //unbind } //generate arrays for faster state switching - for(int ai=0;ai<2;ai++) { + for (int ai = 0; ai < 2; ai++) { - if (ai==0) { + if (ai == 0) { //for normal draw - glGenVertexArrays(1,&surface->array_id); + glGenVertexArrays(1, &surface->array_id); glBindVertexArray(surface->array_id); - glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id); - } else if (ai==1) { + glBindBuffer(GL_ARRAY_BUFFER, surface->vertex_id); + } else if (ai == 1) { //for instancing draw (can be changed and no one cares) - glGenVertexArrays(1,&surface->instancing_array_id); + glGenVertexArrays(1, &surface->instancing_array_id); glBindVertexArray(surface->instancing_array_id); - glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id); + glBindBuffer(GL_ARRAY_BUFFER, surface->vertex_id); } - - for(int i=0;i<VS::ARRAY_MAX-1;i++) { + for (int i = 0; i < VS::ARRAY_MAX - 1; i++) { if (!attribs[i].enabled) continue; if (attribs[i].integer) { - glVertexAttribIPointer(attribs[i].index,attribs[i].size,attribs[i].type,attribs[i].stride,((uint8_t*)0)+attribs[i].offset); + glVertexAttribIPointer(attribs[i].index, attribs[i].size, attribs[i].type, attribs[i].stride, ((uint8_t *)0) + attribs[i].offset); } else { - glVertexAttribPointer(attribs[i].index,attribs[i].size,attribs[i].type,attribs[i].normalized,attribs[i].stride,((uint8_t*)0)+attribs[i].offset); + glVertexAttribPointer(attribs[i].index, attribs[i].size, attribs[i].type, attribs[i].normalized, attribs[i].stride, ((uint8_t *)0) + attribs[i].offset); } glEnableVertexAttribArray(attribs[i].index); - } if (surface->index_id) { - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, surface->index_id); } glBindVertexArray(0); - glBindBuffer(GL_ARRAY_BUFFER,0); //unbind - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); + glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } - } { //blend shapes - for(int i=0;i<p_blend_shapes.size();i++) { + for (int i = 0; i < p_blend_shapes.size(); i++) { Surface::BlendShape mt; PoolVector<uint8_t>::Read vr = p_blend_shapes[i].read(); - 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); //unbind + 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); //unbind - glGenVertexArrays(1,&mt.array_id); + glGenVertexArrays(1, &mt.array_id); glBindVertexArray(mt.array_id); - glBindBuffer(GL_ARRAY_BUFFER,mt.vertex_id); + glBindBuffer(GL_ARRAY_BUFFER, mt.vertex_id); - for(int j=0;j<VS::ARRAY_MAX-1;j++) { + for (int j = 0; j < VS::ARRAY_MAX - 1; j++) { if (!attribs[j].enabled) continue; if (attribs[j].integer) { - glVertexAttribIPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].stride,((uint8_t*)0)+attribs[j].offset); + glVertexAttribIPointer(attribs[j].index, attribs[j].size, attribs[j].type, attribs[j].stride, ((uint8_t *)0) + attribs[j].offset); } else { - glVertexAttribPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].normalized,attribs[j].stride,((uint8_t*)0)+attribs[j].offset); + glVertexAttribPointer(attribs[j].index, attribs[j].size, attribs[j].type, attribs[j].normalized, attribs[j].stride, ((uint8_t *)0) + attribs[j].offset); } glEnableVertexAttribArray(attribs[j].index); - } glBindVertexArray(0); - glBindBuffer(GL_ARRAY_BUFFER,0); //unbind + glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind surface->blend_shapes.push_back(mt); - } } @@ -2915,105 +2755,98 @@ void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh,uint32_t p_format,VS::P mesh->instance_change_notify(); } -void RasterizerStorageGLES3::mesh_set_blend_shape_count(RID p_mesh,int p_amount){ +void RasterizerStorageGLES3::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); - ERR_FAIL_COND(mesh->surfaces.size()!=0); - ERR_FAIL_COND(p_amount<0); - - mesh->blend_shape_count=p_amount; - + mesh->blend_shape_count = p_amount; } -int RasterizerStorageGLES3::mesh_get_blend_shape_count(RID p_mesh) const{ +int RasterizerStorageGLES3::mesh_get_blend_shape_count(RID p_mesh) const { const Mesh *mesh = mesh_owner.getornull(p_mesh); - ERR_FAIL_COND_V(!mesh,0); + ERR_FAIL_COND_V(!mesh, 0); return mesh->blend_shape_count; } - -void RasterizerStorageGLES3::mesh_set_blend_shape_mode(RID p_mesh,VS::BlendShapeMode p_mode){ +void RasterizerStorageGLES3::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; - + mesh->blend_shape_mode = p_mode; } -VS::BlendShapeMode RasterizerStorageGLES3::mesh_get_blend_shape_mode(RID p_mesh) const{ +VS::BlendShapeMode RasterizerStorageGLES3::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); + ERR_FAIL_COND_V(!mesh, VS::BLEND_SHAPE_MODE_NORMALIZED); return mesh->blend_shape_mode; } -void RasterizerStorageGLES3::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material){ +void RasterizerStorageGLES3::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()); + ERR_FAIL_INDEX(p_surface, mesh->surfaces.size()); - if (mesh->surfaces[p_surface]->material==p_material) + 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]); + _material_remove_geometry(mesh->surfaces[p_surface]->material, mesh->surfaces[p_surface]); } - mesh->surfaces[p_surface]->material=p_material; + 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]); + _material_add_geometry(mesh->surfaces[p_surface]->material, mesh->surfaces[p_surface]); } mesh->instance_material_change_notify(); - - } -RID RasterizerStorageGLES3::mesh_surface_get_material(RID p_mesh, int p_surface) const{ +RID RasterizerStorageGLES3::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()); + ERR_FAIL_COND_V(!mesh, RID()); + ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), RID()); return mesh->surfaces[p_surface]->material; } -int RasterizerStorageGLES3::mesh_surface_get_array_len(RID p_mesh, int p_surface) const{ +int RasterizerStorageGLES3::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); + ERR_FAIL_COND_V(!mesh, 0); + ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), 0); return mesh->surfaces[p_surface]->array_len; - } -int RasterizerStorageGLES3::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const{ +int RasterizerStorageGLES3::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); + 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> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, int p_surface) const{ +PoolVector<uint8_t> RasterizerStorageGLES3::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>()); + 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]; - glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id); - void * data = glMapBufferRange(GL_ARRAY_BUFFER,0,surface->array_byte_size,GL_MAP_READ_BIT); + glBindBuffer(GL_ARRAY_BUFFER, surface->vertex_id); + void *data = glMapBufferRange(GL_ARRAY_BUFFER, 0, surface->array_byte_size, GL_MAP_READ_BIT); - ERR_FAIL_COND_V(!data,PoolVector<uint8_t>()); + ERR_FAIL_COND_V(!data, PoolVector<uint8_t>()); PoolVector<uint8_t> ret; ret.resize(surface->array_byte_size); @@ -3021,27 +2854,26 @@ PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, i { PoolVector<uint8_t>::Write w = ret.write(); - copymem(w.ptr(),data,surface->array_byte_size); + copymem(w.ptr(), data, surface->array_byte_size); } glUnmapBuffer(GL_ARRAY_BUFFER); - return ret; } PoolVector<uint8_t> RasterizerStorageGLES3::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>()); + 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]; - ERR_FAIL_COND_V(surface->index_array_len==0,PoolVector<uint8_t>()); + ERR_FAIL_COND_V(surface->index_array_len == 0, PoolVector<uint8_t>()); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id); - void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,surface->index_array_byte_size,GL_MAP_READ_BIT); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, surface->index_id); + void *data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, surface->index_array_byte_size, GL_MAP_READ_BIT); - ERR_FAIL_COND_V(!data,PoolVector<uint8_t>()); + ERR_FAIL_COND_V(!data, PoolVector<uint8_t>()); PoolVector<uint8_t> ret; ret.resize(surface->index_array_byte_size); @@ -3049,7 +2881,7 @@ PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_m { PoolVector<uint8_t>::Write w = ret.write(); - copymem(w.ptr(),data,surface->index_array_byte_size); + copymem(w.ptr(), data, surface->index_array_byte_size); } glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); @@ -3057,23 +2889,21 @@ PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_m return ret; } - -uint32_t RasterizerStorageGLES3::mesh_surface_get_format(RID p_mesh, int p_surface) const{ +uint32_t RasterizerStorageGLES3::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); + ERR_FAIL_COND_V(!mesh, 0); + ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), 0); return mesh->surfaces[p_surface]->format; - } -VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const{ +VS::PrimitiveType RasterizerStorageGLES3::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); + 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; } @@ -3081,27 +2911,25 @@ VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_ Rect3 RasterizerStorageGLES3::mesh_surface_get_aabb(RID p_mesh, int p_surface) const { const Mesh *mesh = mesh_owner.getornull(p_mesh); - ERR_FAIL_COND_V(!mesh,Rect3()); - ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Rect3()); + ERR_FAIL_COND_V(!mesh, Rect3()); + ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Rect3()); return mesh->surfaces[p_surface]->aabb; - - } -Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const{ +Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const { 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> >()); + ERR_FAIL_COND_V(!mesh, Vector<PoolVector<uint8_t> >()); + ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Vector<PoolVector<uint8_t> >()); Vector<PoolVector<uint8_t> > bsarr; - for(int i=0;i<mesh->surfaces[p_surface]->blend_shapes.size();i++) { + for (int i = 0; i < mesh->surfaces[p_surface]->blend_shapes.size(); i++) { - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh->surfaces[p_surface]->blend_shapes[i].vertex_id); - void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,mesh->surfaces[p_surface]->array_byte_size,GL_MAP_READ_BIT); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->surfaces[p_surface]->blend_shapes[i].vertex_id); + void *data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, mesh->surfaces[p_surface]->array_byte_size, GL_MAP_READ_BIT); - ERR_FAIL_COND_V(!data,Vector<PoolVector<uint8_t> >()); + ERR_FAIL_COND_V(!data, Vector<PoolVector<uint8_t> >()); PoolVector<uint8_t> ret; ret.resize(mesh->surfaces[p_surface]->array_byte_size); @@ -3109,7 +2937,7 @@ Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shap { PoolVector<uint8_t>::Write w = ret.write(); - copymem(w.ptr(),data,mesh->surfaces[p_surface]->array_byte_size); + copymem(w.ptr(), data, mesh->surfaces[p_surface]->array_byte_size); } bsarr.push_back(ret); @@ -3118,42 +2946,39 @@ Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shap } return bsarr; - } -Vector<Rect3> RasterizerStorageGLES3::mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const{ +Vector<Rect3> RasterizerStorageGLES3::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<Rect3 >()); - ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<Rect3 >()); + ERR_FAIL_COND_V(!mesh, Vector<Rect3>()); + ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Vector<Rect3>()); return mesh->surfaces[p_surface]->skeleton_bone_aabb; - } - -void RasterizerStorageGLES3::mesh_remove_surface(RID p_mesh, int p_surface){ +void RasterizerStorageGLES3::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()); + ERR_FAIL_INDEX(p_surface, mesh->surfaces.size()); Surface *surface = mesh->surfaces[p_surface]; if (surface->material.is_valid()) { - _material_remove_geometry(surface->material,mesh->surfaces[p_surface]); + _material_remove_geometry(surface->material, mesh->surfaces[p_surface]); } - glDeleteBuffers(1,&surface->vertex_id); + glDeleteBuffers(1, &surface->vertex_id); if (surface->index_id) { - glDeleteBuffers(1,&surface->index_id); + glDeleteBuffers(1, &surface->index_id); } - glDeleteVertexArrays(1,&surface->array_id); + glDeleteVertexArrays(1, &surface->array_id); - for(int i=0;i<surface->blend_shapes.size();i++) { + for (int i = 0; i < surface->blend_shapes.size(); i++) { - glDeleteBuffers(1,&surface->blend_shapes[i].vertex_id); - glDeleteVertexArrays(1,&surface->blend_shapes[i].array_id); + glDeleteBuffers(1, &surface->blend_shapes[i].vertex_id); + glDeleteVertexArrays(1, &surface->blend_shapes[i].array_id); } mesh->instance_material_change_notify(); @@ -3164,115 +2989,109 @@ void RasterizerStorageGLES3::mesh_remove_surface(RID p_mesh, int p_surface){ mesh->instance_change_notify(); } -int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const{ +int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const { const Mesh *mesh = mesh_owner.getornull(p_mesh); - ERR_FAIL_COND_V(!mesh,0); + ERR_FAIL_COND_V(!mesh, 0); return mesh->surfaces.size(); - } -void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh,const Rect3& p_aabb){ +void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh, const Rect3 &p_aabb) { Mesh *mesh = mesh_owner.getornull(p_mesh); ERR_FAIL_COND(!mesh); - mesh->custom_aabb=p_aabb; + mesh->custom_aabb = p_aabb; } -Rect3 RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const{ +Rect3 RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const { const Mesh *mesh = mesh_owner.getornull(p_mesh); - ERR_FAIL_COND_V(!mesh,Rect3()); + ERR_FAIL_COND_V(!mesh, Rect3()); return mesh->custom_aabb; - } -Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{ +Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh, RID p_skeleton) const { - Mesh *mesh = mesh_owner.get( p_mesh ); - ERR_FAIL_COND_V(!mesh,Rect3()); + Mesh *mesh = mesh_owner.get(p_mesh); + ERR_FAIL_COND_V(!mesh, Rect3()); - if (mesh->custom_aabb!=Rect3()) + if (mesh->custom_aabb != Rect3()) return mesh->custom_aabb; - Skeleton *sk=NULL; + Skeleton *sk = NULL; if (p_skeleton.is_valid()) - sk=skeleton_owner.get(p_skeleton); + sk = skeleton_owner.get(p_skeleton); Rect3 aabb; - if (sk && sk->size!=0) { + if (sk && sk->size != 0) { - - for (int i=0;i<mesh->surfaces.size();i++) { + for (int i = 0; i < mesh->surfaces.size(); i++) { Rect3 laabb; - if (mesh->surfaces[i]->format&VS::ARRAY_FORMAT_BONES && mesh->surfaces[i]->skeleton_bone_aabb.size()) { - + 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 Rect3 *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); + ERR_CONTINUE(bs > sbs); float *skb = sk->bones.ptr(); - - - bool first=true; + bool first = true; if (sk->use_2d) { - for(int j=0;j<bs;j++) { + for (int j = 0; j < bs; j++) { if (!skused[j]) continue; - float *dataptr = &skb[8*j]; + float *dataptr = &skb[8 * j]; Transform mtx; - mtx.basis.elements[0][0]=dataptr[ 0]; - mtx.basis.elements[0][1]=dataptr[ 1]; - mtx.origin[0]=dataptr[ 3]; - mtx.basis.elements[1][0]=dataptr[ 4]; - mtx.basis.elements[1][1]=dataptr[ 5]; - mtx.origin[1]=dataptr[ 7]; + mtx.basis.elements[0][0] = dataptr[0]; + mtx.basis.elements[0][1] = dataptr[1]; + mtx.origin[0] = dataptr[3]; + mtx.basis.elements[1][0] = dataptr[4]; + mtx.basis.elements[1][1] = dataptr[5]; + mtx.origin[1] = dataptr[7]; - Rect3 baabb = mtx.xform( skbones[j] ); + Rect3 baabb = mtx.xform(skbones[j]); if (first) { - laabb=baabb; - first=false; + laabb = baabb; + first = false; } else { laabb.merge_with(baabb); } } } else { - for(int j=0;j<bs;j++) { + for (int j = 0; j < bs; j++) { if (!skused[j]) continue; - float *dataptr = &skb[12*j]; + float *dataptr = &skb[12 * j]; Transform mtx; - mtx.basis.elements[0][0]=dataptr[ 0]; - mtx.basis.elements[0][1]=dataptr[ 1]; - mtx.basis.elements[0][2]=dataptr[ 2]; - mtx.origin.x=dataptr[ 3]; - mtx.basis.elements[1][0]=dataptr[ 4]; - mtx.basis.elements[1][1]=dataptr[ 5]; - mtx.basis.elements[1][2]=dataptr[ 6]; - mtx.origin.y=dataptr[ 7]; - mtx.basis.elements[2][0]=dataptr[ 8]; - mtx.basis.elements[2][1]=dataptr[ 9]; - mtx.basis.elements[2][2]=dataptr[10]; - mtx.origin.z=dataptr[11]; - - Rect3 baabb = mtx.xform ( skbones[j] ); + mtx.basis.elements[0][0] = dataptr[0]; + mtx.basis.elements[0][1] = dataptr[1]; + mtx.basis.elements[0][2] = dataptr[2]; + mtx.origin.x = dataptr[3]; + mtx.basis.elements[1][0] = dataptr[4]; + mtx.basis.elements[1][1] = dataptr[5]; + mtx.basis.elements[1][2] = dataptr[6]; + mtx.origin.y = dataptr[7]; + mtx.basis.elements[2][0] = dataptr[8]; + mtx.basis.elements[2][1] = dataptr[9]; + mtx.basis.elements[2][2] = dataptr[10]; + mtx.origin.z = dataptr[11]; + + Rect3 baabb = mtx.xform(skbones[j]); if (first) { - laabb=baabb; - first=false; + laabb = baabb; + first = false; } else { laabb.merge_with(baabb); } @@ -3281,36 +3100,34 @@ Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{ } else { - laabb=mesh->surfaces[i]->aabb; + laabb = mesh->surfaces[i]->aabb; } - if (i==0) - aabb=laabb; + if (i == 0) + aabb = laabb; else aabb.merge_with(laabb); } } else { - for (int i=0;i<mesh->surfaces.size();i++) { + for (int i = 0; i < mesh->surfaces.size(); i++) { - if (i==0) - aabb=mesh->surfaces[i]->aabb; + if (i == 0) + aabb = mesh->surfaces[i]->aabb; else aabb.merge_with(mesh->surfaces[i]->aabb); } - } return aabb; - } -void RasterizerStorageGLES3::mesh_clear(RID p_mesh){ +void RasterizerStorageGLES3::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); + while (mesh->surfaces.size()) { + mesh_remove_surface(p_mesh, 0); } } @@ -3318,7 +3135,7 @@ void RasterizerStorageGLES3::mesh_render_blend_shapes(Surface *s, float *p_weigh glBindVertexArray(s->array_id); - BlendShapeShaderGLES3::Conditionals cond[VS::ARRAY_MAX-1]={ + BlendShapeShaderGLES3::Conditionals cond[VS::ARRAY_MAX - 1] = { BlendShapeShaderGLES3::ENABLE_NORMAL, //will be ignored BlendShapeShaderGLES3::ENABLE_NORMAL, BlendShapeShaderGLES3::ENABLE_TANGENT, @@ -3329,197 +3146,190 @@ void RasterizerStorageGLES3::mesh_render_blend_shapes(Surface *s, float *p_weigh BlendShapeShaderGLES3::ENABLE_SKELETON, }; - int stride=0; + int stride = 0; - if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) { - stride=2*4; + if (s->format & VS::ARRAY_FLAG_USE_2D_VERTICES) { + stride = 2 * 4; } else { - stride=3*4; - } - - static const int sizes[VS::ARRAY_MAX-1]={ - 3*4, - 3*4, - 4*4, - 4*4, - 2*4, - 2*4, - 4*4, - 4*4 + stride = 3 * 4; + } + + static const int sizes[VS::ARRAY_MAX - 1] = { + 3 * 4, + 3 * 4, + 4 * 4, + 4 * 4, + 2 * 4, + 2 * 4, + 4 * 4, + 4 * 4 }; - for(int i=1;i<VS::ARRAY_MAX-1;i++) { - shaders.blend_shapes.set_conditional(cond[i],s->format&(1<<i)); //enable conditional for format - if (s->format&(1<<i)) { - stride+=sizes[i]; + for (int i = 1; i < VS::ARRAY_MAX - 1; i++) { + shaders.blend_shapes.set_conditional(cond[i], s->format & (1 << i)); //enable conditional for format + if (s->format & (1 << i)) { + stride += sizes[i]; } } - //copy all first - float base_weight=1.0; + float base_weight = 1.0; int mtc = s->blend_shapes.size(); - if (s->mesh->blend_shape_mode==VS::BLEND_SHAPE_MODE_NORMALIZED) { + if (s->mesh->blend_shape_mode == VS::BLEND_SHAPE_MODE_NORMALIZED) { - for(int i=0;i<mtc;i++) { - base_weight-=p_weights[i]; + for (int i = 0; i < mtc; i++) { + base_weight -= p_weights[i]; } } - - - shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND,false); //first pass does not blend - shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::USE_2D_VERTEX,s->format&VS::ARRAY_FLAG_USE_2D_VERTICES); //use 2D vertices if needed + shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND, false); //first pass does not blend + shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::USE_2D_VERTEX, s->format & VS::ARRAY_FLAG_USE_2D_VERTICES); //use 2D vertices if needed shaders.blend_shapes.bind(); - shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT,base_weight); + shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT, base_weight); glEnable(GL_RASTERIZER_DISCARD); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, resources.transform_feedback_buffers[0]); glBeginTransformFeedback(GL_POINTS); - glDrawArrays(GL_POINTS,0,s->array_len); + glDrawArrays(GL_POINTS, 0, s->array_len); glEndTransformFeedback(); - - shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND,true); //first pass does not blend + shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND, true); //first pass does not blend shaders.blend_shapes.bind(); - for(int ti=0;ti<mtc;ti++) { + for (int ti = 0; ti < mtc; ti++) { float weight = p_weights[ti]; - if (weight<0.001) //not bother with this one + if (weight < 0.001) //not bother with this one continue; glBindVertexArray(s->blend_shapes[ti].array_id); glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[0]); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, resources.transform_feedback_buffers[1]); - shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT,weight); + shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT, weight); - int ofs=0; - for(int i=0;i<VS::ARRAY_MAX-1;i++) { + int ofs = 0; + for (int i = 0; i < VS::ARRAY_MAX - 1; i++) { - if (s->format&(1<<i)) { - glEnableVertexAttribArray(i+8); - switch(i) { + if (s->format & (1 << i)) { + glEnableVertexAttribArray(i + 8); + switch (i) { case VS::ARRAY_VERTEX: { - if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) { - glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=2*4; + if (s->format & VS::ARRAY_FLAG_USE_2D_VERTICES) { + glVertexAttribPointer(i + 8, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 2 * 4; } else { - glVertexAttribPointer(i+8,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=3*4; + glVertexAttribPointer(i + 8, 3, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 3 * 4; } } break; case VS::ARRAY_NORMAL: { - glVertexAttribPointer(i+8,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=3*4; + glVertexAttribPointer(i + 8, 3, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 3 * 4; } break; case VS::ARRAY_TANGENT: { - glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=4*4; + glVertexAttribPointer(i + 8, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 4 * 4; } break; case VS::ARRAY_COLOR: { - glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=4*4; + glVertexAttribPointer(i + 8, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 4 * 4; } break; case VS::ARRAY_TEX_UV: { - glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=2*4; + glVertexAttribPointer(i + 8, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 2 * 4; } break; case VS::ARRAY_TEX_UV2: { - glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=2*4; + glVertexAttribPointer(i + 8, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 2 * 4; } break; case VS::ARRAY_BONES: { - glVertexAttribIPointer(i+8,4,GL_UNSIGNED_INT,stride,((uint8_t*)0)+ofs); - ofs+=4*4; + glVertexAttribIPointer(i + 8, 4, GL_UNSIGNED_INT, stride, ((uint8_t *)0) + ofs); + ofs += 4 * 4; } break; case VS::ARRAY_WEIGHTS: { - glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=4*4; + glVertexAttribPointer(i + 8, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 4 * 4; } break; } } else { - glDisableVertexAttribArray(i+8); + glDisableVertexAttribArray(i + 8); } } glBeginTransformFeedback(GL_POINTS); - glDrawArrays(GL_POINTS,0,s->array_len); + glDrawArrays(GL_POINTS, 0, s->array_len); glEndTransformFeedback(); - - SWAP(resources.transform_feedback_buffers[0],resources.transform_feedback_buffers[1]); - + SWAP(resources.transform_feedback_buffers[0], resources.transform_feedback_buffers[1]); } glDisable(GL_RASTERIZER_DISCARD); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0); - glBindVertexArray(resources.transform_feedback_array); glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[0]); - int ofs=0; - for(int i=0;i<VS::ARRAY_MAX-1;i++) { + int ofs = 0; + for (int i = 0; i < VS::ARRAY_MAX - 1; i++) { - if (s->format&(1<<i)) { + if (s->format & (1 << i)) { glEnableVertexAttribArray(i); - switch(i) { + switch (i) { case VS::ARRAY_VERTEX: { - if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) { - glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=2*4; + if (s->format & VS::ARRAY_FLAG_USE_2D_VERTICES) { + glVertexAttribPointer(i, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 2 * 4; } else { - glVertexAttribPointer(i,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=3*4; + glVertexAttribPointer(i, 3, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 3 * 4; } } break; case VS::ARRAY_NORMAL: { - glVertexAttribPointer(i,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=3*4; + glVertexAttribPointer(i, 3, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 3 * 4; } break; case VS::ARRAY_TANGENT: { - glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=4*4; + glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 4 * 4; } break; case VS::ARRAY_COLOR: { - glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=4*4; + glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 4 * 4; } break; case VS::ARRAY_TEX_UV: { - glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=2*4; + glVertexAttribPointer(i, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 2 * 4; } break; case VS::ARRAY_TEX_UV2: { - glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=2*4; + glVertexAttribPointer(i, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 2 * 4; } break; case VS::ARRAY_BONES: { - glVertexAttribIPointer(i,4,GL_UNSIGNED_INT,stride,((uint8_t*)0)+ofs); - ofs+=4*4; + glVertexAttribIPointer(i, 4, GL_UNSIGNED_INT, stride, ((uint8_t *)0) + ofs); + ofs += 4 * 4; } break; case VS::ARRAY_WEIGHTS: { - glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs); - ofs+=4*4; + glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs); + ofs += 4 * 4; } break; } @@ -3530,131 +3340,126 @@ void RasterizerStorageGLES3::mesh_render_blend_shapes(Surface *s, float *p_weigh } if (s->index_array_len) { - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,s->index_id); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->index_id); } - } /* MULTIMESH API */ +RID RasterizerStorageGLES3::multimesh_create() { -RID RasterizerStorageGLES3::multimesh_create(){ - - MultiMesh *multimesh = memnew( MultiMesh ); + MultiMesh *multimesh = memnew(MultiMesh); return multimesh_owner.make_rid(multimesh); } -void RasterizerStorageGLES3::multimesh_allocate(RID p_multimesh, int p_instances, VS::MultimeshTransformFormat p_transform_format, VS::MultimeshColorFormat p_color_format){ +void RasterizerStorageGLES3::multimesh_allocate(RID p_multimesh, int p_instances, VS::MultimeshTransformFormat p_transform_format, VS::MultimeshColorFormat p_color_format) { 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) + if (multimesh->size == p_instances && multimesh->transform_format == p_transform_format && multimesh->color_format == p_color_format) return; if (multimesh->buffer) { - glDeleteBuffers(1,&multimesh->buffer); + glDeleteBuffers(1, &multimesh->buffer); multimesh->data.resize(0); } - multimesh->size=p_instances; - multimesh->transform_format=p_transform_format; - multimesh->color_format=p_color_format; + multimesh->size = p_instances; + multimesh->transform_format = p_transform_format; + multimesh->color_format = p_color_format; if (multimesh->size) { - if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) { - multimesh->xform_floats=8; + if (multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D) { + multimesh->xform_floats = 8; } else { - multimesh->xform_floats=12; - + multimesh->xform_floats = 12; } - if (multimesh->color_format==VS::MULTIMESH_COLOR_NONE) { - multimesh->color_floats=0; - } else if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) { - multimesh->color_floats=1; - } else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) { - multimesh->color_floats=4; + if (multimesh->color_format == VS::MULTIMESH_COLOR_NONE) { + multimesh->color_floats = 0; + } else if (multimesh->color_format == VS::MULTIMESH_COLOR_8BIT) { + multimesh->color_floats = 1; + } else if (multimesh->color_format == VS::MULTIMESH_COLOR_FLOAT) { + multimesh->color_floats = 4; } - int format_floats = multimesh->color_floats+multimesh->xform_floats; - multimesh->data.resize(format_floats*p_instances); - for(int i=0;i<p_instances;i+=format_floats) { - - int color_from=0; - - if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) { - multimesh->data[i+0]=1.0; - multimesh->data[i+1]=0.0; - multimesh->data[i+2]=0.0; - multimesh->data[i+3]=0.0; - multimesh->data[i+4]=0.0; - multimesh->data[i+5]=1.0; - multimesh->data[i+6]=0.0; - multimesh->data[i+7]=0.0; - color_from=8; + int format_floats = multimesh->color_floats + multimesh->xform_floats; + multimesh->data.resize(format_floats * p_instances); + for (int i = 0; i < p_instances; i += format_floats) { + + int color_from = 0; + + if (multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D) { + multimesh->data[i + 0] = 1.0; + multimesh->data[i + 1] = 0.0; + multimesh->data[i + 2] = 0.0; + multimesh->data[i + 3] = 0.0; + multimesh->data[i + 4] = 0.0; + multimesh->data[i + 5] = 1.0; + multimesh->data[i + 6] = 0.0; + multimesh->data[i + 7] = 0.0; + color_from = 8; } else { - multimesh->data[i+0]=1.0; - multimesh->data[i+1]=0.0; - multimesh->data[i+2]=0.0; - multimesh->data[i+3]=0.0; - multimesh->data[i+4]=0.0; - multimesh->data[i+5]=1.0; - multimesh->data[i+6]=0.0; - multimesh->data[i+7]=0.0; - multimesh->data[i+8]=0.0; - multimesh->data[i+9]=0.0; - multimesh->data[i+10]=1.0; - multimesh->data[i+11]=0.0; - color_from=12; + multimesh->data[i + 0] = 1.0; + multimesh->data[i + 1] = 0.0; + multimesh->data[i + 2] = 0.0; + multimesh->data[i + 3] = 0.0; + multimesh->data[i + 4] = 0.0; + multimesh->data[i + 5] = 1.0; + multimesh->data[i + 6] = 0.0; + multimesh->data[i + 7] = 0.0; + multimesh->data[i + 8] = 0.0; + multimesh->data[i + 9] = 0.0; + multimesh->data[i + 10] = 1.0; + multimesh->data[i + 11] = 0.0; + color_from = 12; } - if (multimesh->color_format==VS::MULTIMESH_COLOR_NONE) { + if (multimesh->color_format == VS::MULTIMESH_COLOR_NONE) { //none - } else if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) { + } else if (multimesh->color_format == VS::MULTIMESH_COLOR_8BIT) { union { uint32_t colu; float colf; } cu; - cu.colu=0xFFFFFFFF; - multimesh->data[i+color_from+0]=cu.colf; + cu.colu = 0xFFFFFFFF; + multimesh->data[i + color_from + 0] = cu.colf; - } else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) { - multimesh->data[i+color_from+0]=1.0; - multimesh->data[i+color_from+1]=1.0; - multimesh->data[i+color_from+2]=1.0; - multimesh->data[i+color_from+3]=1.0; + } else if (multimesh->color_format == VS::MULTIMESH_COLOR_FLOAT) { + multimesh->data[i + color_from + 0] = 1.0; + multimesh->data[i + color_from + 1] = 1.0; + multimesh->data[i + color_from + 2] = 1.0; + multimesh->data[i + color_from + 3] = 1.0; } } - glGenBuffers(1,&multimesh->buffer); - glBindBuffer(GL_ARRAY_BUFFER,multimesh->buffer); - glBufferData(GL_ARRAY_BUFFER,multimesh->data.size()*sizeof(float),NULL,GL_DYNAMIC_DRAW); - glBindBuffer(GL_ARRAY_BUFFER,0); - + glGenBuffers(1, &multimesh->buffer); + glBindBuffer(GL_ARRAY_BUFFER, multimesh->buffer); + glBufferData(GL_ARRAY_BUFFER, multimesh->data.size() * sizeof(float), NULL, GL_DYNAMIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); } - multimesh->dirty_data=true; - multimesh->dirty_aabb=true; + multimesh->dirty_data = true; + multimesh->dirty_aabb = true; if (!multimesh->update_list.in_list()) { multimesh_update_list.add(&multimesh->update_list); } - } -int RasterizerStorageGLES3::multimesh_get_instance_count(RID p_multimesh) const{ +int RasterizerStorageGLES3::multimesh_get_instance_count(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh); - ERR_FAIL_COND_V(!multimesh,0); + ERR_FAIL_COND_V(!multimesh, 0); return multimesh->size; } -void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){ +void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh, RID p_mesh) { MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh); ERR_FAIL_COND(!multimesh); @@ -3666,8 +3471,7 @@ void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){ } } - multimesh->mesh=p_mesh; - + multimesh->mesh = p_mesh; if (multimesh->mesh.is_valid()) { Mesh *mesh = mesh_owner.getornull(multimesh->mesh); @@ -3676,173 +3480,171 @@ void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){ } } - multimesh->dirty_aabb=true; + multimesh->dirty_aabb = true; if (!multimesh->update_list.in_list()) { multimesh_update_list.add(&multimesh->update_list); } } -void RasterizerStorageGLES3::multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform){ +void RasterizerStorageGLES3::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->xform_floats; - float *dataptr=&multimesh->data[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; + ERR_FAIL_INDEX(p_index, multimesh->size); + ERR_FAIL_COND(multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D); + + int stride = multimesh->color_floats + multimesh->xform_floats; + float *dataptr = &multimesh->data[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 RasterizerStorageGLES3::multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Transform2D& p_transform){ +void RasterizerStorageGLES3::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); + 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; - float *dataptr=&multimesh->data[stride*p_index]; + int stride = multimesh->color_floats + multimesh->xform_floats; + float *dataptr = &multimesh->data[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]; + 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; + multimesh->dirty_data = true; + multimesh->dirty_aabb = true; if (!multimesh->update_list.in_list()) { multimesh_update_list.add(&multimesh->update_list); } } -void RasterizerStorageGLES3::multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color){ +void RasterizerStorageGLES3::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); + ERR_FAIL_INDEX(p_index, multimesh->size); + ERR_FAIL_COND(multimesh->color_format == VS::MULTIMESH_COLOR_NONE); - int stride = multimesh->color_floats+multimesh->xform_floats; - float *dataptr=&multimesh->data[stride*p_index+multimesh->xform_floats]; + int stride = multimesh->color_floats + multimesh->xform_floats; + float *dataptr = &multimesh->data[stride * p_index + multimesh->xform_floats]; - if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) { + 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); + 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; + } 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; + multimesh->dirty_data = true; + multimesh->dirty_aabb = true; if (!multimesh->update_list.in_list()) { multimesh_update_list.add(&multimesh->update_list); } } -RID RasterizerStorageGLES3::multimesh_get_mesh(RID p_multimesh) const{ +RID RasterizerStorageGLES3::multimesh_get_mesh(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh); - ERR_FAIL_COND_V(!multimesh,RID()); + ERR_FAIL_COND_V(!multimesh, RID()); return multimesh->mesh; } - -Transform RasterizerStorageGLES3::multimesh_instance_get_transform(RID p_multimesh,int p_index) const{ +Transform RasterizerStorageGLES3::multimesh_instance_get_transform(RID p_multimesh, int p_index) const { 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()); + 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; - float *dataptr=&multimesh->data[stride*p_index]; + int stride = multimesh->color_floats + multimesh->xform_floats; + float *dataptr = &multimesh->data[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]; + 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; } -Transform2D RasterizerStorageGLES3::multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const{ +Transform2D RasterizerStorageGLES3::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()); + 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; - float *dataptr=&multimesh->data[stride*p_index]; + int stride = multimesh->color_floats + multimesh->xform_floats; + float *dataptr = &multimesh->data[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]; + 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 RasterizerStorageGLES3::multimesh_instance_get_color(RID p_multimesh,int p_index) const{ +Color RasterizerStorageGLES3::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()); + 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()); - int stride = multimesh->color_floats+multimesh->xform_floats; - float *dataptr=&multimesh->data[stride*p_index+multimesh->color_floats]; + int stride = multimesh->color_floats + multimesh->xform_floats; + float *dataptr = &multimesh->data[stride * p_index + multimesh->color_floats]; - if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) { + if (multimesh->color_format == VS::MULTIMESH_COLOR_8BIT) { union { uint32_t colu; float colf; @@ -3850,130 +3652,124 @@ Color RasterizerStorageGLES3::multimesh_instance_get_color(RID p_multimesh,int p return Color::hex(BSWAP32(cu.colu)); - } else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) { + } 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]; + c.r = dataptr[0]; + c.g = dataptr[1]; + c.b = dataptr[2]; + c.a = dataptr[3]; return c; } return Color(); - } -void RasterizerStorageGLES3::multimesh_set_visible_instances(RID p_multimesh,int p_visible){ +void RasterizerStorageGLES3::multimesh_set_visible_instances(RID p_multimesh, int p_visible) { MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh); ERR_FAIL_COND(!multimesh); - multimesh->visible_instances=p_visible; + multimesh->visible_instances = p_visible; } -int RasterizerStorageGLES3::multimesh_get_visible_instances(RID p_multimesh) const{ +int RasterizerStorageGLES3::multimesh_get_visible_instances(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh); - ERR_FAIL_COND_V(!multimesh,-1); + ERR_FAIL_COND_V(!multimesh, -1); return multimesh->visible_instances; } -Rect3 RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const{ +Rect3 RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh); - ERR_FAIL_COND_V(!multimesh,Rect3()); + ERR_FAIL_COND_V(!multimesh, Rect3()); - const_cast<RasterizerStorageGLES3*>(this)->update_dirty_multimeshes(); //update pending AABBs + const_cast<RasterizerStorageGLES3 *>(this)->update_dirty_multimeshes(); //update pending AABBs return multimesh->aabb; } void RasterizerStorageGLES3::update_dirty_multimeshes() { - while(multimesh_update_list.first()) { + while (multimesh_update_list.first()) { MultiMesh *multimesh = multimesh_update_list.first()->self(); if (multimesh->size && multimesh->dirty_data) { - - glBindBuffer(GL_ARRAY_BUFFER,multimesh->buffer); - glBufferSubData(GL_ARRAY_BUFFER,0,multimesh->data.size()*sizeof(float),multimesh->data.ptr()); - glBindBuffer(GL_ARRAY_BUFFER,0); - - + glBindBuffer(GL_ARRAY_BUFFER, multimesh->buffer); + glBufferSubData(GL_ARRAY_BUFFER, 0, multimesh->data.size() * sizeof(float), multimesh->data.ptr()); + glBindBuffer(GL_ARRAY_BUFFER, 0); } - - if (multimesh->size && multimesh->dirty_aabb) { Rect3 mesh_aabb; if (multimesh->mesh.is_valid()) { - mesh_aabb=mesh_get_aabb(multimesh->mesh,RID()); + mesh_aabb = mesh_get_aabb(multimesh->mesh, RID()); } else { - mesh_aabb.size+=Vector3(0.001,0.001,0.001); + mesh_aabb.size += Vector3(0.001, 0.001, 0.001); } - int stride=multimesh->color_floats+multimesh->xform_floats; + int stride = multimesh->color_floats + multimesh->xform_floats; int count = multimesh->data.size(); - float *data=multimesh->data.ptr(); + float *data = multimesh->data.ptr(); Rect3 aabb; - if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) { + if (multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D) { - for(int i=0;i<count;i+=stride) { + for (int i = 0; i < count; i += stride) { - float *dataptr=&data[i]; + 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]; + 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]; Rect3 laabb = xform.xform(mesh_aabb); - if (i==0) - aabb=laabb; + if (i == 0) + aabb = laabb; else aabb.merge_with(laabb); } } else { - for(int i=0;i<count;i+=stride) { + for (int i = 0; i < count; i += stride) { - float *dataptr=&data[i]; + 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]; + 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]; Rect3 laabb = xform.xform(mesh_aabb); - if (i==0) - aabb=laabb; + if (i == 0) + aabb = laabb; else aabb.merge_with(laabb); } } - multimesh->aabb=aabb; + multimesh->aabb = aabb; } - multimesh->dirty_aabb=false; - multimesh->dirty_data=false; + multimesh->dirty_aabb = false; + multimesh->dirty_data = false; multimesh->instance_change_notify(); @@ -3983,30 +3779,26 @@ void RasterizerStorageGLES3::update_dirty_multimeshes() { /* IMMEDIATE API */ - RID RasterizerStorageGLES3::immediate_create() { - Immediate *im = memnew( Immediate ); + Immediate *im = memnew(Immediate); return immediate_owner.make_rid(im); - } -void RasterizerStorageGLES3::immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, RID p_texture){ +void RasterizerStorageGLES3::immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, 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_rimitive; + ic.texture = p_texture; + ic.primitive = p_rimitive; im->chunks.push_back(ic); - im->mask=0; - im->building=true; - - + im->mask = 0; + im->building = true; } -void RasterizerStorageGLES3::immediate_vertex(RID p_immediate,const Vector3& p_vertex){ +void RasterizerStorageGLES3::immediate_vertex(RID p_immediate, const Vector3 &p_vertex) { Immediate *im = immediate_owner.get(p_immediate); ERR_FAIL_COND(!im); @@ -4014,92 +3806,83 @@ void RasterizerStorageGLES3::immediate_vertex(RID p_immediate,const Vector3& p_v Immediate::Chunk *c = &im->chunks.back()->get(); + if (c->vertices.empty() && im->chunks.size() == 1) { - if (c->vertices.empty() && im->chunks.size()==1) { - - im->aabb.pos=p_vertex; - im->aabb.size=Vector3(); + im->aabb.pos = p_vertex; + im->aabb.size = Vector3(); } else { im->aabb.expand_to(p_vertex); } - if (im->mask&VS::ARRAY_FORMAT_NORMAL) + if (im->mask & VS::ARRAY_FORMAT_NORMAL) c->normals.push_back(chunk_normal); - if (im->mask&VS::ARRAY_FORMAT_TANGENT) + if (im->mask & VS::ARRAY_FORMAT_TANGENT) c->tangents.push_back(chunk_tangent); - if (im->mask&VS::ARRAY_FORMAT_COLOR) + if (im->mask & VS::ARRAY_FORMAT_COLOR) c->colors.push_back(chunk_color); - if (im->mask&VS::ARRAY_FORMAT_TEX_UV) + if (im->mask & VS::ARRAY_FORMAT_TEX_UV) c->uvs.push_back(chunk_uv); - if (im->mask&VS::ARRAY_FORMAT_TEX_UV2) + if (im->mask & VS::ARRAY_FORMAT_TEX_UV2) c->uvs2.push_back(chunk_uv2); - im->mask|=VS::ARRAY_FORMAT_VERTEX; + im->mask |= VS::ARRAY_FORMAT_VERTEX; c->vertices.push_back(p_vertex); - } - -void RasterizerStorageGLES3::immediate_normal(RID p_immediate,const Vector3& p_normal){ +void RasterizerStorageGLES3::immediate_normal(RID p_immediate, const Vector3 &p_normal) { 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; - + im->mask |= VS::ARRAY_FORMAT_NORMAL; + chunk_normal = p_normal; } -void RasterizerStorageGLES3::immediate_tangent(RID p_immediate,const Plane& p_tangent){ +void RasterizerStorageGLES3::immediate_tangent(RID p_immediate, const Plane &p_tangent) { 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; - + im->mask |= VS::ARRAY_FORMAT_TANGENT; + chunk_tangent = p_tangent; } -void RasterizerStorageGLES3::immediate_color(RID p_immediate,const Color& p_color){ +void RasterizerStorageGLES3::immediate_color(RID p_immediate, const Color &p_color) { 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; - + im->mask |= VS::ARRAY_FORMAT_COLOR; + chunk_color = p_color; } -void RasterizerStorageGLES3::immediate_uv(RID p_immediate,const Vector2& tex_uv){ +void RasterizerStorageGLES3::immediate_uv(RID p_immediate, const Vector2 &tex_uv) { 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; - + im->mask |= VS::ARRAY_FORMAT_TEX_UV; + chunk_uv = tex_uv; } -void RasterizerStorageGLES3::immediate_uv2(RID p_immediate,const Vector2& tex_uv){ +void RasterizerStorageGLES3::immediate_uv2(RID p_immediate, const Vector2 &tex_uv) { 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; - + im->mask |= VS::ARRAY_FORMAT_TEX_UV2; + chunk_uv2 = tex_uv; } -void RasterizerStorageGLES3::immediate_end(RID p_immediate){ +void RasterizerStorageGLES3::immediate_end(RID p_immediate) { Immediate *im = immediate_owner.get(p_immediate); ERR_FAIL_COND(!im); ERR_FAIL_COND(!im->building); - im->building=false; + im->building = false; im->instance_change_notify(); - } void RasterizerStorageGLES3::immediate_clear(RID p_immediate) { @@ -4109,279 +3892,264 @@ void RasterizerStorageGLES3::immediate_clear(RID p_immediate) { im->chunks.clear(); im->instance_change_notify(); - } Rect3 RasterizerStorageGLES3::immediate_get_aabb(RID p_immediate) const { Immediate *im = immediate_owner.get(p_immediate); - ERR_FAIL_COND_V(!im,Rect3()); + ERR_FAIL_COND_V(!im, Rect3()); return im->aabb; } -void RasterizerStorageGLES3::immediate_set_material(RID p_immediate,RID p_material) { +void RasterizerStorageGLES3::immediate_set_material(RID p_immediate, RID p_material) { Immediate *im = immediate_owner.get(p_immediate); ERR_FAIL_COND(!im); - im->material=p_material; + im->material = p_material; im->instance_material_change_notify(); - } RID RasterizerStorageGLES3::immediate_get_material(RID p_immediate) const { const Immediate *im = immediate_owner.get(p_immediate); - ERR_FAIL_COND_V(!im,RID()); + ERR_FAIL_COND_V(!im, RID()); return im->material; - } /* SKELETON API */ -RID RasterizerStorageGLES3::skeleton_create(){ +RID RasterizerStorageGLES3::skeleton_create() { - Skeleton *skeleton = memnew( Skeleton ); + Skeleton *skeleton = memnew(Skeleton); return skeleton_owner.make_rid(skeleton); } -void RasterizerStorageGLES3::skeleton_allocate(RID p_skeleton,int p_bones,bool p_2d_skeleton){ +void RasterizerStorageGLES3::skeleton_allocate(RID p_skeleton, int p_bones, bool p_2d_skeleton) { Skeleton *skeleton = skeleton_owner.getornull(p_skeleton); ERR_FAIL_COND(!skeleton); - ERR_FAIL_COND(p_bones<0); + ERR_FAIL_COND(p_bones < 0); - if (skeleton->size==p_bones && skeleton->use_2d==p_2d_skeleton) + if (skeleton->size == p_bones && skeleton->use_2d == p_2d_skeleton) return; if (skeleton->ubo) { - glDeleteBuffers(1,&skeleton->ubo); - skeleton->ubo=0; + glDeleteBuffers(1, &skeleton->ubo); + skeleton->ubo = 0; } - skeleton->size=p_bones; + skeleton->size = p_bones; if (p_2d_skeleton) { - skeleton->bones.resize(p_bones*8); - for(int i=0;i<skeleton->bones.size();i+=8) { - skeleton->bones[i+0]=1; - skeleton->bones[i+1]=0; - skeleton->bones[i+2]=0; - skeleton->bones[i+3]=0; - skeleton->bones[i+4]=0; - skeleton->bones[i+5]=1; - skeleton->bones[i+6]=0; - skeleton->bones[i+7]=0; + skeleton->bones.resize(p_bones * 8); + for (int i = 0; i < skeleton->bones.size(); i += 8) { + skeleton->bones[i + 0] = 1; + skeleton->bones[i + 1] = 0; + skeleton->bones[i + 2] = 0; + skeleton->bones[i + 3] = 0; + skeleton->bones[i + 4] = 0; + skeleton->bones[i + 5] = 1; + skeleton->bones[i + 6] = 0; + skeleton->bones[i + 7] = 0; } } else { - skeleton->bones.resize(p_bones*12); - for(int i=0;i<skeleton->bones.size();i+=12) { - skeleton->bones[i+0]=1; - skeleton->bones[i+1]=0; - skeleton->bones[i+2]=0; - skeleton->bones[i+3]=0; - skeleton->bones[i+4]=0; - skeleton->bones[i+5]=1; - skeleton->bones[i+6]=0; - skeleton->bones[i+7]=0; - skeleton->bones[i+8]=0; - skeleton->bones[i+9]=0; - skeleton->bones[i+10]=1; - skeleton->bones[i+11]=0; + skeleton->bones.resize(p_bones * 12); + for (int i = 0; i < skeleton->bones.size(); i += 12) { + skeleton->bones[i + 0] = 1; + skeleton->bones[i + 1] = 0; + skeleton->bones[i + 2] = 0; + skeleton->bones[i + 3] = 0; + skeleton->bones[i + 4] = 0; + skeleton->bones[i + 5] = 1; + skeleton->bones[i + 6] = 0; + skeleton->bones[i + 7] = 0; + skeleton->bones[i + 8] = 0; + skeleton->bones[i + 9] = 0; + skeleton->bones[i + 10] = 1; + skeleton->bones[i + 11] = 0; } - } - - if (p_bones) { glGenBuffers(1, &skeleton->ubo); glBindBuffer(GL_UNIFORM_BUFFER, skeleton->ubo); - glBufferData(GL_UNIFORM_BUFFER, skeleton->bones.size()*sizeof(float), NULL, GL_DYNAMIC_DRAW); + glBufferData(GL_UNIFORM_BUFFER, skeleton->bones.size() * sizeof(float), NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); } if (!skeleton->update_list.in_list()) { skeleton_update_list.add(&skeleton->update_list); } - - - } -int RasterizerStorageGLES3::skeleton_get_bone_count(RID p_skeleton) const{ +int RasterizerStorageGLES3::skeleton_get_bone_count(RID p_skeleton) const { Skeleton *skeleton = skeleton_owner.getornull(p_skeleton); - ERR_FAIL_COND_V(!skeleton,0); + ERR_FAIL_COND_V(!skeleton, 0); return skeleton->size; } -void RasterizerStorageGLES3::skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform){ +void RasterizerStorageGLES3::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) { Skeleton *skeleton = skeleton_owner.getornull(p_skeleton); ERR_FAIL_COND(!skeleton); - ERR_FAIL_INDEX(p_bone,skeleton->size); + ERR_FAIL_INDEX(p_bone, skeleton->size); ERR_FAIL_COND(skeleton->use_2d); - float * bones = skeleton->bones.ptr(); - bones[p_bone*12+ 0]=p_transform.basis.elements[0][0]; - bones[p_bone*12+ 1]=p_transform.basis.elements[0][1]; - bones[p_bone*12+ 2]=p_transform.basis.elements[0][2]; - bones[p_bone*12+ 3]=p_transform.origin.x; - bones[p_bone*12+ 4]=p_transform.basis.elements[1][0]; - bones[p_bone*12+ 5]=p_transform.basis.elements[1][1]; - bones[p_bone*12+ 6]=p_transform.basis.elements[1][2]; - bones[p_bone*12+ 7]=p_transform.origin.y; - bones[p_bone*12+ 8]=p_transform.basis.elements[2][0]; - bones[p_bone*12+ 9]=p_transform.basis.elements[2][1]; - bones[p_bone*12+10]=p_transform.basis.elements[2][2]; - bones[p_bone*12+11]=p_transform.origin.z; + float *bones = skeleton->bones.ptr(); + bones[p_bone * 12 + 0] = p_transform.basis.elements[0][0]; + bones[p_bone * 12 + 1] = p_transform.basis.elements[0][1]; + bones[p_bone * 12 + 2] = p_transform.basis.elements[0][2]; + bones[p_bone * 12 + 3] = p_transform.origin.x; + bones[p_bone * 12 + 4] = p_transform.basis.elements[1][0]; + bones[p_bone * 12 + 5] = p_transform.basis.elements[1][1]; + bones[p_bone * 12 + 6] = p_transform.basis.elements[1][2]; + bones[p_bone * 12 + 7] = p_transform.origin.y; + bones[p_bone * 12 + 8] = p_transform.basis.elements[2][0]; + bones[p_bone * 12 + 9] = p_transform.basis.elements[2][1]; + bones[p_bone * 12 + 10] = p_transform.basis.elements[2][2]; + bones[p_bone * 12 + 11] = p_transform.origin.z; if (!skeleton->update_list.in_list()) { skeleton_update_list.add(&skeleton->update_list); } - } - -Transform RasterizerStorageGLES3::skeleton_bone_get_transform(RID p_skeleton,int p_bone) const{ +Transform RasterizerStorageGLES3::skeleton_bone_get_transform(RID p_skeleton, int p_bone) const { 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()); + ERR_FAIL_COND_V(!skeleton, Transform()); + ERR_FAIL_INDEX_V(p_bone, skeleton->size, Transform()); + ERR_FAIL_COND_V(skeleton->use_2d, Transform()); - float * bones = skeleton->bones.ptr(); + float *bones = skeleton->bones.ptr(); Transform mtx; - mtx.basis.elements[0][0]=bones[p_bone*12+ 0]; - mtx.basis.elements[0][1]=bones[p_bone*12+ 1]; - mtx.basis.elements[0][2]=bones[p_bone*12+ 2]; - mtx.origin.x=bones[p_bone*12+ 3]; - mtx.basis.elements[1][0]=bones[p_bone*12+ 4]; - mtx.basis.elements[1][1]=bones[p_bone*12+ 5]; - mtx.basis.elements[1][2]=bones[p_bone*12+ 6]; - mtx.origin.y=bones[p_bone*12+ 7]; - mtx.basis.elements[2][0]=bones[p_bone*12+ 8]; - mtx.basis.elements[2][1]=bones[p_bone*12+ 9]; - mtx.basis.elements[2][2]=bones[p_bone*12+10]; - mtx.origin.z=bones[p_bone*12+11]; + mtx.basis.elements[0][0] = bones[p_bone * 12 + 0]; + mtx.basis.elements[0][1] = bones[p_bone * 12 + 1]; + mtx.basis.elements[0][2] = bones[p_bone * 12 + 2]; + mtx.origin.x = bones[p_bone * 12 + 3]; + mtx.basis.elements[1][0] = bones[p_bone * 12 + 4]; + mtx.basis.elements[1][1] = bones[p_bone * 12 + 5]; + mtx.basis.elements[1][2] = bones[p_bone * 12 + 6]; + mtx.origin.y = bones[p_bone * 12 + 7]; + mtx.basis.elements[2][0] = bones[p_bone * 12 + 8]; + mtx.basis.elements[2][1] = bones[p_bone * 12 + 9]; + mtx.basis.elements[2][2] = bones[p_bone * 12 + 10]; + mtx.origin.z = bones[p_bone * 12 + 11]; return mtx; } -void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Transform2D& p_transform){ +void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) { Skeleton *skeleton = skeleton_owner.getornull(p_skeleton); ERR_FAIL_COND(!skeleton); - ERR_FAIL_INDEX(p_bone,skeleton->size); + ERR_FAIL_INDEX(p_bone, skeleton->size); ERR_FAIL_COND(!skeleton->use_2d); - float * bones = skeleton->bones.ptr(); - bones[p_bone*12+ 0]=p_transform.elements[0][0]; - bones[p_bone*12+ 1]=p_transform.elements[1][0]; - bones[p_bone*12+ 2]=0; - bones[p_bone*12+ 3]=p_transform.elements[2][0]; - bones[p_bone*12+ 4]=p_transform.elements[0][1]; - bones[p_bone*12+ 5]=p_transform.elements[1][1]; - bones[p_bone*12+ 6]=0; - bones[p_bone*12+ 7]=p_transform.elements[2][1]; + float *bones = skeleton->bones.ptr(); + bones[p_bone * 12 + 0] = p_transform.elements[0][0]; + bones[p_bone * 12 + 1] = p_transform.elements[1][0]; + bones[p_bone * 12 + 2] = 0; + bones[p_bone * 12 + 3] = p_transform.elements[2][0]; + bones[p_bone * 12 + 4] = p_transform.elements[0][1]; + bones[p_bone * 12 + 5] = p_transform.elements[1][1]; + bones[p_bone * 12 + 6] = 0; + bones[p_bone * 12 + 7] = p_transform.elements[2][1]; if (!skeleton->update_list.in_list()) { skeleton_update_list.add(&skeleton->update_list); } - } -Transform2D RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const{ +Transform2D RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const { 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()); + ERR_FAIL_COND_V(!skeleton, Transform2D()); + ERR_FAIL_INDEX_V(p_bone, skeleton->size, Transform2D()); + ERR_FAIL_COND_V(!skeleton->use_2d, Transform2D()); Transform2D mtx; - float * bones = skeleton->bones.ptr(); - mtx.elements[0][0]=bones[p_bone*12+ 0]; - mtx.elements[1][0]=bones[p_bone*12+ 1]; - mtx.elements[2][0]=bones[p_bone*12+ 3]; - mtx.elements[0][1]=bones[p_bone*12+ 4]; - mtx.elements[1][1]=bones[p_bone*12+ 5]; - mtx.elements[2][1]=bones[p_bone*12+ 7]; + float *bones = skeleton->bones.ptr(); + mtx.elements[0][0] = bones[p_bone * 12 + 0]; + mtx.elements[1][0] = bones[p_bone * 12 + 1]; + mtx.elements[2][0] = bones[p_bone * 12 + 3]; + mtx.elements[0][1] = bones[p_bone * 12 + 4]; + mtx.elements[1][1] = bones[p_bone * 12 + 5]; + mtx.elements[2][1] = bones[p_bone * 12 + 7]; return mtx; } void RasterizerStorageGLES3::update_dirty_skeletons() { - while(skeleton_update_list.first()) { + while (skeleton_update_list.first()) { Skeleton *skeleton = skeleton_update_list.first()->self(); if (skeleton->size) { glBindBuffer(GL_UNIFORM_BUFFER, skeleton->ubo); - glBufferSubData(GL_UNIFORM_BUFFER,0,skeleton->bones.size()*sizeof(float),skeleton->bones.ptr()); + glBufferSubData(GL_UNIFORM_BUFFER, 0, skeleton->bones.size() * sizeof(float), skeleton->bones.ptr()); glBindBuffer(GL_UNIFORM_BUFFER, 0); } - for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) { + for (Set<RasterizerScene::InstanceBase *>::Element *E = skeleton->instances.front(); E; E = E->next()) { E->get()->base_changed(); } skeleton_update_list.remove(skeleton_update_list.first()); } - } /* Light API */ -RID RasterizerStorageGLES3::light_create(VS::LightType p_type){ - - Light *light = memnew( Light ); - light->type=p_type; - - light->param[VS::LIGHT_PARAM_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->version=0; +RID RasterizerStorageGLES3::light_create(VS::LightType p_type) { + + Light *light = memnew(Light); + light->type = p_type; + + light->param[VS::LIGHT_PARAM_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->version = 0; return light_owner.make_rid(light); } -void RasterizerStorageGLES3::light_set_color(RID p_light,const Color& p_color){ +void RasterizerStorageGLES3::light_set_color(RID p_light, const Color &p_color) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->color=p_color; + light->color = p_color; } -void RasterizerStorageGLES3::light_set_param(RID p_light,VS::LightParam p_param,float p_value){ +void RasterizerStorageGLES3::light_set_param(RID p_light, VS::LightParam p_param, float p_value) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - ERR_FAIL_INDEX(p_param,VS::LIGHT_PARAM_MAX); + ERR_FAIL_INDEX(p_param, VS::LIGHT_PARAM_MAX); - switch(p_param) { + switch (p_param) { case VS::LIGHT_PARAM_RANGE: case VS::LIGHT_PARAM_SPOT_ANGLE: case VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE: @@ -4397,185 +4165,173 @@ void RasterizerStorageGLES3::light_set_param(RID p_light,VS::LightParam p_param, } break; } - light->param[p_param]=p_value; + light->param[p_param] = p_value; } -void RasterizerStorageGLES3::light_set_shadow(RID p_light,bool p_enabled){ +void RasterizerStorageGLES3::light_set_shadow(RID p_light, bool p_enabled) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->shadow=p_enabled; + light->shadow = p_enabled; light->version++; light->instance_change_notify(); } -void RasterizerStorageGLES3::light_set_shadow_color(RID p_light,const Color& p_color) { +void RasterizerStorageGLES3::light_set_shadow_color(RID p_light, const Color &p_color) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->shadow_color=p_color; - + light->shadow_color = p_color; } -void RasterizerStorageGLES3::light_set_projector(RID p_light,RID p_texture){ +void RasterizerStorageGLES3::light_set_projector(RID p_light, RID p_texture) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->projector=p_texture; + light->projector = p_texture; } -void RasterizerStorageGLES3::light_set_negative(RID p_light,bool p_enable){ +void RasterizerStorageGLES3::light_set_negative(RID p_light, bool p_enable) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->negative=p_enable; + light->negative = p_enable; } -void RasterizerStorageGLES3::light_set_cull_mask(RID p_light,uint32_t p_mask){ +void RasterizerStorageGLES3::light_set_cull_mask(RID p_light, uint32_t p_mask) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->cull_mask=p_mask; + light->cull_mask = p_mask; light->version++; light->instance_change_notify(); - } -void RasterizerStorageGLES3::light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode) { +void RasterizerStorageGLES3::light_omni_set_shadow_mode(RID p_light, VS::LightOmniShadowMode p_mode) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->omni_shadow_mode=p_mode; + light->omni_shadow_mode = p_mode; light->version++; light->instance_change_notify(); - - } VS::LightOmniShadowMode RasterizerStorageGLES3::light_omni_get_shadow_mode(RID p_light) { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,VS::LIGHT_OMNI_SHADOW_CUBE); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, VS::LIGHT_OMNI_SHADOW_CUBE); return light->omni_shadow_mode; } +void RasterizerStorageGLES3::light_omni_set_shadow_detail(RID p_light, VS::LightOmniShadowDetail p_detail) { -void RasterizerStorageGLES3::light_omni_set_shadow_detail(RID p_light,VS::LightOmniShadowDetail p_detail) { - - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->omni_shadow_detail=p_detail; + light->omni_shadow_detail = p_detail; light->version++; light->instance_change_notify(); } +void RasterizerStorageGLES3::light_directional_set_shadow_mode(RID p_light, VS::LightDirectionalShadowMode p_mode) { -void RasterizerStorageGLES3::light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode){ - - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->directional_shadow_mode=p_mode; + light->directional_shadow_mode = p_mode; light->version++; light->instance_change_notify(); - } -void RasterizerStorageGLES3::light_directional_set_blend_splits(RID p_light,bool p_enable) { +void RasterizerStorageGLES3::light_directional_set_blend_splits(RID p_light, bool p_enable) { - Light * light = light_owner.getornull(p_light); + Light *light = light_owner.getornull(p_light); ERR_FAIL_COND(!light); - light->directional_blend_splits=p_enable; + light->directional_blend_splits = p_enable; light->version++; light->instance_change_notify(); - } - bool RasterizerStorageGLES3::light_directional_get_blend_splits(RID p_light) const { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,false); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, false); return light->directional_blend_splits; } VS::LightDirectionalShadowMode RasterizerStorageGLES3::light_directional_get_shadow_mode(RID p_light) { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL); return light->directional_shadow_mode; } - VS::LightType RasterizerStorageGLES3::light_get_type(RID p_light) const { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, VS::LIGHT_DIRECTIONAL); return light->type; } -float RasterizerStorageGLES3::light_get_param(RID p_light,VS::LightParam p_param) { +float RasterizerStorageGLES3::light_get_param(RID p_light, VS::LightParam p_param) { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, VS::LIGHT_DIRECTIONAL); return light->param[p_param]; } Color RasterizerStorageGLES3::light_get_color(RID p_light) { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,Color()); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, Color()); return light->color; - } bool RasterizerStorageGLES3::light_has_shadow(RID p_light) const { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, VS::LIGHT_DIRECTIONAL); return light->shadow; } uint64_t RasterizerStorageGLES3::light_get_version(RID p_light) const { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,0); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, 0); return light->version; } - Rect3 RasterizerStorageGLES3::light_get_aabb(RID p_light) const { - const Light * light = light_owner.getornull(p_light); - ERR_FAIL_COND_V(!light,Rect3()); + const Light *light = light_owner.getornull(p_light); + ERR_FAIL_COND_V(!light, Rect3()); - switch( light->type ) { + 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 Rect3( Vector3( -size,-size,-len ), Vector3( size*2, size*2, len ) ); + float len = light->param[VS::LIGHT_PARAM_RANGE]; + float size = Math::tan(Math::deg2rad(light->param[VS::LIGHT_PARAM_SPOT_ANGLE])) * len; + return Rect3(Vector3(-size, -size, -len), Vector3(size * 2, size * 2, len)); } break; case VS::LIGHT_OMNI: { float r = light->param[VS::LIGHT_PARAM_RANGE]; - return Rect3( -Vector3(r,r,r), Vector3(r,r,r)*2 ); + return Rect3(-Vector3(r, r, r), Vector3(r, r, r) * 2); } break; case VS::LIGHT_DIRECTIONAL: { @@ -4584,27 +4340,27 @@ Rect3 RasterizerStorageGLES3::light_get_aabb(RID p_light) const { default: {} } - ERR_FAIL_V( Rect3() ); + ERR_FAIL_V(Rect3()); return Rect3(); } /* PROBE API */ -RID RasterizerStorageGLES3::reflection_probe_create(){ +RID RasterizerStorageGLES3::reflection_probe_create() { - ReflectionProbe *reflection_probe = memnew( ReflectionProbe ); + ReflectionProbe *reflection_probe = memnew(ReflectionProbe); - reflection_probe->intensity=1.0; - reflection_probe->interior_ambient=Color(); - reflection_probe->interior_ambient_energy=1.0; - 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->intensity = 1.0; + reflection_probe->interior_ambient = Color(); + reflection_probe->interior_ambient_energy = 1.0; + 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; return reflection_probe_owner.make_rid(reflection_probe); } @@ -4614,9 +4370,8 @@ void RasterizerStorageGLES3::reflection_probe_set_update_mode(RID p_probe, VS::R ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->update_mode=p_mode; + reflection_probe->update_mode = p_mode; reflection_probe->instance_change_notify(); - } void RasterizerStorageGLES3::reflection_probe_set_intensity(RID p_probe, float p_intensity) { @@ -4624,17 +4379,15 @@ void RasterizerStorageGLES3::reflection_probe_set_intensity(RID p_probe, float p ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->intensity=p_intensity; - + reflection_probe->intensity = p_intensity; } -void RasterizerStorageGLES3::reflection_probe_set_interior_ambient(RID p_probe, const Color& p_ambient) { +void RasterizerStorageGLES3::reflection_probe_set_interior_ambient(RID p_probe, const Color &p_ambient) { ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->interior_ambient=p_ambient; - + reflection_probe->interior_ambient = p_ambient; } void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_energy(RID p_probe, float p_energy) { @@ -4642,8 +4395,7 @@ void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_energy(RID p_ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->interior_ambient_energy=p_energy; - + reflection_probe->interior_ambient_energy = p_energy; } void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_probe_contribution(RID p_probe, float p_contrib) { @@ -4651,91 +4403,80 @@ void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_probe_contrib ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->interior_ambient_probe_contrib=p_contrib; - + reflection_probe->interior_ambient_probe_contrib = p_contrib; } - -void RasterizerStorageGLES3::reflection_probe_set_max_distance(RID p_probe, float p_distance){ +void RasterizerStorageGLES3::reflection_probe_set_max_distance(RID p_probe, float p_distance) { ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->max_distance=p_distance; + reflection_probe->max_distance = p_distance; reflection_probe->instance_change_notify(); - } -void RasterizerStorageGLES3::reflection_probe_set_extents(RID p_probe, const Vector3& p_extents){ +void RasterizerStorageGLES3::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); - reflection_probe->extents=p_extents; + reflection_probe->extents = p_extents; reflection_probe->instance_change_notify(); - } -void RasterizerStorageGLES3::reflection_probe_set_origin_offset(RID p_probe, const Vector3& p_offset){ +void RasterizerStorageGLES3::reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) { ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->origin_offset=p_offset; + reflection_probe->origin_offset = p_offset; reflection_probe->instance_change_notify(); - } -void RasterizerStorageGLES3::reflection_probe_set_as_interior(RID p_probe, bool p_enable){ +void RasterizerStorageGLES3::reflection_probe_set_as_interior(RID p_probe, bool p_enable) { ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->interior=p_enable; - + reflection_probe->interior = p_enable; } -void RasterizerStorageGLES3::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable){ +void RasterizerStorageGLES3::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) { ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->box_projection=p_enable; - + reflection_probe->box_projection = p_enable; } -void RasterizerStorageGLES3::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable){ +void RasterizerStorageGLES3::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) { ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->enable_shadows=p_enable; + reflection_probe->enable_shadows = p_enable; reflection_probe->instance_change_notify(); - } -void RasterizerStorageGLES3::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers){ +void RasterizerStorageGLES3::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) { ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); ERR_FAIL_COND(!reflection_probe); - reflection_probe->cull_mask=p_layers; + reflection_probe->cull_mask = p_layers; reflection_probe->instance_change_notify(); - } Rect3 RasterizerStorageGLES3::reflection_probe_get_aabb(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!reflection_probe,Rect3()); + ERR_FAIL_COND_V(!reflection_probe, Rect3()); Rect3 aabb; - aabb.pos=-reflection_probe->extents; - aabb.size=reflection_probe->extents*2.0; + aabb.pos = -reflection_probe->extents; + aabb.size = reflection_probe->extents * 2.0; return aabb; - - } -VS::ReflectionProbeUpdateMode RasterizerStorageGLES3::reflection_probe_get_update_mode(RID p_probe) const{ +VS::ReflectionProbeUpdateMode RasterizerStorageGLES3::reflection_probe_get_update_mode(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!reflection_probe,VS::REFLECTION_PROBE_UPDATE_ALWAYS); + ERR_FAIL_COND_V(!reflection_probe, VS::REFLECTION_PROBE_UPDATE_ALWAYS); return reflection_probe->update_mode; } @@ -4743,60 +4484,51 @@ VS::ReflectionProbeUpdateMode RasterizerStorageGLES3::reflection_probe_get_updat uint32_t RasterizerStorageGLES3::reflection_probe_get_cull_mask(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!reflection_probe,0); + ERR_FAIL_COND_V(!reflection_probe, 0); return reflection_probe->cull_mask; - } Vector3 RasterizerStorageGLES3::reflection_probe_get_extents(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!reflection_probe,Vector3()); + ERR_FAIL_COND_V(!reflection_probe, Vector3()); return reflection_probe->extents; - } -Vector3 RasterizerStorageGLES3::reflection_probe_get_origin_offset(RID p_probe) const{ +Vector3 RasterizerStorageGLES3::reflection_probe_get_origin_offset(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!reflection_probe,Vector3()); + ERR_FAIL_COND_V(!reflection_probe, Vector3()); return reflection_probe->origin_offset; - } bool RasterizerStorageGLES3::reflection_probe_renders_shadows(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!reflection_probe,false); + ERR_FAIL_COND_V(!reflection_probe, false); return reflection_probe->enable_shadows; - } -float RasterizerStorageGLES3::reflection_probe_get_origin_max_distance(RID p_probe) const{ +float RasterizerStorageGLES3::reflection_probe_get_origin_max_distance(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!reflection_probe,0); + ERR_FAIL_COND_V(!reflection_probe, 0); return reflection_probe->max_distance; - } /* ROOM API */ -RID RasterizerStorageGLES3::room_create(){ +RID RasterizerStorageGLES3::room_create() { return RID(); } -void RasterizerStorageGLES3::room_add_bounds(RID p_room, const PoolVector<Vector2>& p_convex_polygon,float p_height,const Transform& p_transform){ - - +void RasterizerStorageGLES3::room_add_bounds(RID p_room, const PoolVector<Vector2> &p_convex_polygon, float p_height, const Transform &p_transform) { } -void RasterizerStorageGLES3::room_clear_bounds(RID p_room){ - - +void RasterizerStorageGLES3::room_clear_bounds(RID p_room) { } /* PORTAL API */ @@ -4804,67 +4536,59 @@ void RasterizerStorageGLES3::room_clear_bounds(RID p_room){ // portals are only (x/y) points, forming a convex shape, which its clockwise // order points outside. (z is 0); -RID RasterizerStorageGLES3::portal_create(){ +RID RasterizerStorageGLES3::portal_create() { return RID(); } -void RasterizerStorageGLES3::portal_set_shape(RID p_portal, const Vector<Point2>& p_shape){ - - +void RasterizerStorageGLES3::portal_set_shape(RID p_portal, const Vector<Point2> &p_shape) { } -void RasterizerStorageGLES3::portal_set_enabled(RID p_portal, bool p_enabled){ - - +void RasterizerStorageGLES3::portal_set_enabled(RID p_portal, bool p_enabled) { } -void RasterizerStorageGLES3::portal_set_disable_distance(RID p_portal, float p_distance){ - - +void RasterizerStorageGLES3::portal_set_disable_distance(RID p_portal, float p_distance) { } -void RasterizerStorageGLES3::portal_set_disabled_color(RID p_portal, const Color& p_color){ - - +void RasterizerStorageGLES3::portal_set_disabled_color(RID p_portal, const Color &p_color) { } RID RasterizerStorageGLES3::gi_probe_create() { - GIProbe *gip = memnew( GIProbe ); + GIProbe *gip = memnew(GIProbe); - gip->bounds=Rect3(Vector3(),Vector3(1,1,1)); - gip->dynamic_range=1.0; - gip->energy=1.0; - gip->propagation=1.0; - gip->bias=0.4; - gip->interior=false; - gip->compress=false; - gip->version=1; - gip->cell_size=1.0; + gip->bounds = Rect3(Vector3(), Vector3(1, 1, 1)); + gip->dynamic_range = 1.0; + gip->energy = 1.0; + gip->propagation = 1.0; + gip->bias = 0.4; + gip->interior = false; + gip->compress = false; + gip->version = 1; + gip->cell_size = 1.0; return gi_probe_owner.make_rid(gip); } -void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe,const Rect3& p_bounds){ +void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe, const Rect3 &p_bounds) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->bounds=p_bounds; + gip->bounds = p_bounds; gip->version++; gip->instance_change_notify(); } -Rect3 RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const{ +Rect3 RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,Rect3()); + ERR_FAIL_COND_V(!gip, Rect3()); return gip->bounds; } -void RasterizerStorageGLES3::gi_probe_set_cell_size(RID p_probe,float p_size) { +void RasterizerStorageGLES3::gi_probe_set_cell_size(RID p_probe, float p_size) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->cell_size=p_size; + gip->cell_size = p_size; gip->version++; gip->instance_change_notify(); } @@ -4872,161 +4596,141 @@ void RasterizerStorageGLES3::gi_probe_set_cell_size(RID p_probe,float p_size) { float RasterizerStorageGLES3::gi_probe_get_cell_size(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,0); + ERR_FAIL_COND_V(!gip, 0); return gip->cell_size; - } -void RasterizerStorageGLES3::gi_probe_set_to_cell_xform(RID p_probe,const Transform& p_xform) { +void RasterizerStorageGLES3::gi_probe_set_to_cell_xform(RID p_probe, const Transform &p_xform) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->to_cell=p_xform; + gip->to_cell = p_xform; } Transform RasterizerStorageGLES3::gi_probe_get_to_cell_xform(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,Transform()); + ERR_FAIL_COND_V(!gip, Transform()); return gip->to_cell; - } - - -void RasterizerStorageGLES3::gi_probe_set_dynamic_data(RID p_probe,const PoolVector<int>& p_data){ +void RasterizerStorageGLES3::gi_probe_set_dynamic_data(RID p_probe, const PoolVector<int> &p_data) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->dynamic_data=p_data; + gip->dynamic_data = p_data; gip->version++; gip->instance_change_notify(); - } -PoolVector<int> RasterizerStorageGLES3::gi_probe_get_dynamic_data(RID p_probe) const{ +PoolVector<int> RasterizerStorageGLES3::gi_probe_get_dynamic_data(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,PoolVector<int>()); + ERR_FAIL_COND_V(!gip, PoolVector<int>()); return gip->dynamic_data; } -void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe,int p_range){ +void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe, int p_range) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->dynamic_range=p_range; - + gip->dynamic_range = p_range; } -int RasterizerStorageGLES3::gi_probe_get_dynamic_range(RID p_probe) const{ +int RasterizerStorageGLES3::gi_probe_get_dynamic_range(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,0); + ERR_FAIL_COND_V(!gip, 0); return gip->dynamic_range; } -void RasterizerStorageGLES3::gi_probe_set_energy(RID p_probe,float p_range){ +void RasterizerStorageGLES3::gi_probe_set_energy(RID p_probe, float p_range) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->energy=p_range; - + gip->energy = p_range; } - -void RasterizerStorageGLES3::gi_probe_set_bias(RID p_probe,float p_range){ +void RasterizerStorageGLES3::gi_probe_set_bias(RID p_probe, float p_range) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->bias=p_range; - + gip->bias = p_range; } -void RasterizerStorageGLES3::gi_probe_set_propagation(RID p_probe,float p_range){ +void RasterizerStorageGLES3::gi_probe_set_propagation(RID p_probe, float p_range) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->propagation=p_range; - + gip->propagation = p_range; } -void RasterizerStorageGLES3::gi_probe_set_interior(RID p_probe,bool p_enable) { +void RasterizerStorageGLES3::gi_probe_set_interior(RID p_probe, bool p_enable) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->interior=p_enable; - + gip->interior = p_enable; } -bool RasterizerStorageGLES3::gi_probe_is_interior(RID p_probe) const{ +bool RasterizerStorageGLES3::gi_probe_is_interior(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,false); + ERR_FAIL_COND_V(!gip, false); return gip->interior; - } - -void RasterizerStorageGLES3::gi_probe_set_compress(RID p_probe,bool p_enable) { +void RasterizerStorageGLES3::gi_probe_set_compress(RID p_probe, bool p_enable) { GIProbe *gip = gi_probe_owner.getornull(p_probe); ERR_FAIL_COND(!gip); - gip->compress=p_enable; - + gip->compress = p_enable; } -bool RasterizerStorageGLES3::gi_probe_is_compressed(RID p_probe) const{ +bool RasterizerStorageGLES3::gi_probe_is_compressed(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,false); + ERR_FAIL_COND_V(!gip, false); return gip->compress; - } -float RasterizerStorageGLES3::gi_probe_get_energy(RID p_probe) const{ +float RasterizerStorageGLES3::gi_probe_get_energy(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,0); + ERR_FAIL_COND_V(!gip, 0); return gip->energy; } -float RasterizerStorageGLES3::gi_probe_get_bias(RID p_probe) const{ +float RasterizerStorageGLES3::gi_probe_get_bias(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,0); + ERR_FAIL_COND_V(!gip, 0); return gip->bias; } - -float RasterizerStorageGLES3::gi_probe_get_propagation(RID p_probe) const{ +float RasterizerStorageGLES3::gi_probe_get_propagation(RID p_probe) const { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,0); + ERR_FAIL_COND_V(!gip, 0); return gip->propagation; } - - - - uint32_t RasterizerStorageGLES3::gi_probe_get_version(RID p_probe) { const GIProbe *gip = gi_probe_owner.getornull(p_probe); - ERR_FAIL_COND_V(!gip,0); + ERR_FAIL_COND_V(!gip, 0); return gip->version; } @@ -5041,39 +4745,39 @@ RasterizerStorage::GIProbeCompression RasterizerStorageGLES3::gi_probe_get_dynam RID RasterizerStorageGLES3::gi_probe_dynamic_data_create(int p_width, int p_height, int p_depth, GIProbeCompression p_compression) { - GIProbeData *gipd = memnew( GIProbeData ); + GIProbeData *gipd = memnew(GIProbeData); - gipd->width=p_width; - gipd->height=p_height; - gipd->depth=p_depth; - gipd->compression=p_compression; + gipd->width = p_width; + gipd->height = p_height; + gipd->depth = p_depth; + gipd->compression = p_compression; glActiveTexture(GL_TEXTURE0); - glGenTextures(1,&gipd->tex_id); - glBindTexture(GL_TEXTURE_3D,gipd->tex_id); + glGenTextures(1, &gipd->tex_id); + glBindTexture(GL_TEXTURE_3D, gipd->tex_id); - int level=0; - int min_size=1; + int level = 0; + int min_size = 1; - if (gipd->compression==GI_PROBE_S3TC) { - min_size=4; + if (gipd->compression == GI_PROBE_S3TC) { + min_size = 4; } print_line("dyndata create"); - while(true) { + while (true) { - if (gipd->compression==GI_PROBE_S3TC) { + if (gipd->compression == GI_PROBE_S3TC) { int size = p_width * p_height * p_depth; - glCompressedTexImage3D(GL_TEXTURE_3D,level,_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT,p_width,p_height,p_depth,0, size,NULL); + glCompressedTexImage3D(GL_TEXTURE_3D, level, _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT, p_width, p_height, p_depth, 0, size, NULL); } else { - glTexImage3D(GL_TEXTURE_3D,level,GL_RGBA8,p_width,p_height,p_depth,0,GL_RGBA,GL_UNSIGNED_BYTE,NULL); + glTexImage3D(GL_TEXTURE_3D, level, GL_RGBA8, p_width, p_height, p_depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); } - if (p_width<=min_size || p_height<=min_size || p_depth<=min_size) + if (p_width <= min_size || p_height <= min_size || p_depth <= min_size) break; - p_width>>=1; - p_height>>=1; - p_depth>>=1; + p_width >>= 1; + p_height >>= 1; + p_depth >>= 1; level++; } @@ -5085,7 +4789,7 @@ RID RasterizerStorageGLES3::gi_probe_dynamic_data_create(int p_width, int p_heig glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, level); - gipd->levels=level+1; + gipd->levels = level + 1; return gi_probe_data_owner.make_rid(gipd); } @@ -5094,7 +4798,7 @@ void RasterizerStorageGLES3::gi_probe_dynamic_data_update(RID p_gi_probe_data, i GIProbeData *gipd = gi_probe_data_owner.getornull(p_gi_probe_data); ERR_FAIL_COND(!gipd); -/* + /* Vector<uint8_t> data; data.resize((gipd->width>>p_mipmap)*(gipd->height>>p_mipmap)*(gipd->depth>>p_mipmap)*4); @@ -5113,120 +4817,109 @@ void RasterizerStorageGLES3::gi_probe_dynamic_data_update(RID p_gi_probe_data, i } */ glActiveTexture(GL_TEXTURE0); - glBindTexture(GL_TEXTURE_3D,gipd->tex_id); - if (gipd->compression==GI_PROBE_S3TC) { - int size = (gipd->width>>p_mipmap) * (gipd->height>>p_mipmap) * p_slice_count; - glCompressedTexSubImage3D(GL_TEXTURE_3D,p_mipmap,0,0,p_depth_slice,gipd->width>>p_mipmap,gipd->height>>p_mipmap,p_slice_count,_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT,size, p_data); + glBindTexture(GL_TEXTURE_3D, gipd->tex_id); + if (gipd->compression == GI_PROBE_S3TC) { + int size = (gipd->width >> p_mipmap) * (gipd->height >> p_mipmap) * p_slice_count; + glCompressedTexSubImage3D(GL_TEXTURE_3D, p_mipmap, 0, 0, p_depth_slice, gipd->width >> p_mipmap, gipd->height >> p_mipmap, p_slice_count, _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT, size, p_data); } else { - glTexSubImage3D(GL_TEXTURE_3D,p_mipmap,0,0,p_depth_slice,gipd->width>>p_mipmap,gipd->height>>p_mipmap,p_slice_count,GL_RGBA,GL_UNSIGNED_BYTE,p_data); + glTexSubImage3D(GL_TEXTURE_3D, p_mipmap, 0, 0, p_depth_slice, gipd->width >> p_mipmap, gipd->height >> p_mipmap, p_slice_count, GL_RGBA, GL_UNSIGNED_BYTE, p_data); } //glTexImage3D(GL_TEXTURE_3D,p_mipmap,GL_RGBA8,gipd->width>>p_mipmap,gipd->height>>p_mipmap,gipd->depth>>p_mipmap,0,GL_RGBA,GL_UNSIGNED_BYTE,p_data); //glTexImage3D(GL_TEXTURE_3D,p_mipmap,GL_RGBA8,gipd->width>>p_mipmap,gipd->height>>p_mipmap,gipd->depth>>p_mipmap,0,GL_RGBA,GL_UNSIGNED_BYTE,data.ptr()); - } /////// - - RID RasterizerStorageGLES3::particles_create() { - Particles *particles = memnew( Particles ); - + Particles *particles = memnew(Particles); return particles_owner.make_rid(particles); } -void RasterizerStorageGLES3::particles_set_emitting(RID p_particles,bool p_emitting) { +void RasterizerStorageGLES3::particles_set_emitting(RID p_particles, bool p_emitting) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->emitting=p_emitting; - + particles->emitting = p_emitting; } -void RasterizerStorageGLES3::particles_set_amount(RID p_particles,int p_amount) { +void RasterizerStorageGLES3::particles_set_amount(RID p_particles, int p_amount) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - int floats = p_amount*24; - float * data = memnew_arr(float,floats); + int floats = p_amount * 24; + float *data = memnew_arr(float, floats); - for(int i=0;i<floats;i++) { - data[i]=0; + for (int i = 0; i < floats; i++) { + data[i] = 0; } + glBindBuffer(GL_ARRAY_BUFFER, particles->particle_buffers[0]); + glBufferData(GL_ARRAY_BUFFER, floats * sizeof(float), data, GL_DYNAMIC_DRAW); - glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[0]); - glBufferData(GL_ARRAY_BUFFER,floats*sizeof(float),data,GL_DYNAMIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, particles->particle_buffers[1]); + glBufferData(GL_ARRAY_BUFFER, floats * sizeof(float), data, GL_DYNAMIC_DRAW); - glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[1]); - glBufferData(GL_ARRAY_BUFFER,floats*sizeof(float),data,GL_DYNAMIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); - glBindBuffer(GL_ARRAY_BUFFER,0); - - particles->prev_ticks=0; - particles->phase=0; - particles->prev_phase=0; + particles->prev_ticks = 0; + particles->phase = 0; + particles->prev_phase = 0; memdelete_arr(data); - } -void RasterizerStorageGLES3::particles_set_lifetime(RID p_particles,float p_lifetime){ +void RasterizerStorageGLES3::particles_set_lifetime(RID p_particles, float p_lifetime) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->lifetime=p_lifetime; + particles->lifetime = p_lifetime; } -void RasterizerStorageGLES3::particles_set_pre_process_time(RID p_particles,float p_time) { +void RasterizerStorageGLES3::particles_set_pre_process_time(RID p_particles, float p_time) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->pre_process_time=p_time; - + particles->pre_process_time = p_time; } -void RasterizerStorageGLES3::particles_set_explosiveness_ratio(RID p_particles,float p_ratio) { +void RasterizerStorageGLES3::particles_set_explosiveness_ratio(RID p_particles, float p_ratio) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->explosiveness=p_ratio; + particles->explosiveness = p_ratio; } -void RasterizerStorageGLES3::particles_set_randomness_ratio(RID p_particles,float p_ratio) { +void RasterizerStorageGLES3::particles_set_randomness_ratio(RID p_particles, float p_ratio) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->randomness=p_ratio; - + particles->randomness = p_ratio; } -void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles,const Rect3& p_aabb) { +void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles, const Rect3 &p_aabb) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->custom_aabb=p_aabb; - + particles->custom_aabb = p_aabb; } -void RasterizerStorageGLES3::particles_set_gravity(RID p_particles,const Vector3& p_gravity) { +void RasterizerStorageGLES3::particles_set_gravity(RID p_particles, const Vector3 &p_gravity) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->gravity=p_gravity; - + particles->gravity = p_gravity; } -void RasterizerStorageGLES3::particles_set_use_local_coordinates(RID p_particles,bool p_enable) { +void RasterizerStorageGLES3::particles_set_use_local_coordinates(RID p_particles, bool p_enable) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->use_local_coords=p_enable; + particles->use_local_coords = p_enable; } -void RasterizerStorageGLES3::particles_set_process_material(RID p_particles,RID p_material) { +void RasterizerStorageGLES3::particles_set_process_material(RID p_particles, RID p_material) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->process_material=p_material; + particles->process_material = p_material; } void RasterizerStorageGLES3::particles_set_emission_shape(RID p_particles, VS::ParticlesEmissionShape p_shape) { @@ -5234,67 +4927,64 @@ void RasterizerStorageGLES3::particles_set_emission_shape(RID p_particles, VS::P Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->emission_shape=p_shape; + particles->emission_shape = p_shape; } -void RasterizerStorageGLES3::particles_set_emission_sphere_radius(RID p_particles,float p_radius) { +void RasterizerStorageGLES3::particles_set_emission_sphere_radius(RID p_particles, float p_radius) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->emission_sphere_radius=p_radius; + particles->emission_sphere_radius = p_radius; } -void RasterizerStorageGLES3::particles_set_emission_box_extents(RID p_particles,const Vector3& p_extents) { +void RasterizerStorageGLES3::particles_set_emission_box_extents(RID p_particles, const Vector3 &p_extents) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->emission_box_extents=p_extents; + particles->emission_box_extents = p_extents; } -void RasterizerStorageGLES3::particles_set_emission_points(RID p_particles,const PoolVector<Vector3>& p_points) { +void RasterizerStorageGLES3::particles_set_emission_points(RID p_particles, const PoolVector<Vector3> &p_points) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->emission_points=p_points; + particles->emission_points = p_points; } - -void RasterizerStorageGLES3::particles_set_draw_order(RID p_particles,VS::ParticlesDrawOrder p_order) { +void RasterizerStorageGLES3::particles_set_draw_order(RID p_particles, VS::ParticlesDrawOrder p_order) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - particles->draw_order=p_order; + particles->draw_order = p_order; } -void RasterizerStorageGLES3::particles_set_draw_passes(RID p_particles,int p_count) { +void RasterizerStorageGLES3::particles_set_draw_passes(RID p_particles, int p_count) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); particles->draw_passes.resize(p_count); } -void RasterizerStorageGLES3::particles_set_draw_pass_material(RID p_particles,int p_pass, RID p_material) { +void RasterizerStorageGLES3::particles_set_draw_pass_material(RID p_particles, int p_pass, RID p_material) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - ERR_FAIL_INDEX(p_pass,particles->draw_passes.size()); - particles->draw_passes[p_pass].material=p_material; - + ERR_FAIL_INDEX(p_pass, particles->draw_passes.size()); + particles->draw_passes[p_pass].material = p_material; } -void RasterizerStorageGLES3::particles_set_draw_pass_mesh(RID p_particles,int p_pass, RID p_mesh) { +void RasterizerStorageGLES3::particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) { Particles *particles = particles_owner.getornull(p_particles); ERR_FAIL_COND(!particles); - ERR_FAIL_INDEX(p_pass,particles->draw_passes.size()); - particles->draw_passes[p_pass].mesh=p_mesh; - + ERR_FAIL_INDEX(p_pass, particles->draw_passes.size()); + particles->draw_passes[p_pass].mesh = p_mesh; } Rect3 RasterizerStorageGLES3::particles_get_current_aabb(RID p_particles) { const Particles *particles = particles_owner.getornull(p_particles); - ERR_FAIL_COND_V(!particles,Rect3()); + ERR_FAIL_COND_V(!particles, Rect3()); return particles->computed_aabb; } @@ -5304,122 +4994,111 @@ void RasterizerStorageGLES3::update_particles() { glEnable(GL_RASTERIZER_DISCARD); glBindVertexArray(0); - while (particle_update_list.first()) { //use transform feedback to process particles Particles *particles = particle_update_list.first()->self(); - Material *material = material_owner.getornull(particles->process_material); - if (!material || !material->shader || material->shader->mode!=VS::SHADER_PARTICLES) { + if (!material || !material->shader || material->shader->mode != VS::SHADER_PARTICLES) { shaders.particles.set_custom_shader(0); } else { - shaders.particles.set_custom_shader( material->shader->custom_code_id ); + shaders.particles.set_custom_shader(material->shader->custom_code_id); if (material->ubo_id) { - glBindBufferBase(GL_UNIFORM_BUFFER,0,material->ubo_id); + glBindBufferBase(GL_UNIFORM_BUFFER, 0, material->ubo_id); } int tc = material->textures.size(); - RID* textures = material->textures.ptr(); - ShaderLanguage::ShaderNode::Uniform::Hint* texture_hints = material->shader->texture_hints.ptr(); + RID *textures = material->textures.ptr(); + ShaderLanguage::ShaderNode::Uniform::Hint *texture_hints = material->shader->texture_hints.ptr(); + for (int i = 0; i < tc; i++) { - for(int i=0;i<tc;i++) { - - glActiveTexture(GL_TEXTURE0+i); + glActiveTexture(GL_TEXTURE0 + i); GLenum target; GLuint tex; - RasterizerStorageGLES3::Texture *t = texture_owner.getornull( textures[i] ); + RasterizerStorageGLES3::Texture *t = texture_owner.getornull(textures[i]); if (!t) { //check hints - target=GL_TEXTURE_2D; + target = GL_TEXTURE_2D; - switch(texture_hints[i]) { + switch (texture_hints[i]) { case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO: case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK: { - tex=resources.black_tex; + tex = resources.black_tex; } break; case ShaderLanguage::ShaderNode::Uniform::HINT_ANISO: { - tex=resources.aniso_tex; + tex = resources.aniso_tex; } break; case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: { - tex=resources.normal_tex; + tex = resources.normal_tex; } break; default: { - tex=resources.white_tex; + tex = resources.white_tex; } break; } - } else { - target=t->target; + target = t->target; tex = t->tex_id; - } - glBindTexture(target,tex); + glBindTexture(target, tex); } - } shaders.particles.bind(); - shaders.particles.set_uniform(ParticlesShaderGLES3::ORIGIN,particles->origin); + shaders.particles.set_uniform(ParticlesShaderGLES3::ORIGIN, particles->origin); - float new_phase = Math::fmod((float)particles->phase+(frame.delta/particles->lifetime),(float)1.0); + float new_phase = Math::fmod((float)particles->phase + (frame.delta / particles->lifetime), (float)1.0); - shaders.particles.set_uniform(ParticlesShaderGLES3::SYSTEM_PHASE,new_phase); - shaders.particles.set_uniform(ParticlesShaderGLES3::PREV_SYSTEM_PHASE,particles->phase); + shaders.particles.set_uniform(ParticlesShaderGLES3::SYSTEM_PHASE, new_phase); + shaders.particles.set_uniform(ParticlesShaderGLES3::PREV_SYSTEM_PHASE, particles->phase); particles->phase = new_phase; - shaders.particles.set_uniform(ParticlesShaderGLES3::TOTAL_PARTICLES,particles->amount); - shaders.particles.set_uniform(ParticlesShaderGLES3::TIME,0.0); - shaders.particles.set_uniform(ParticlesShaderGLES3::EXPLOSIVENESS,particles->explosiveness); - shaders.particles.set_uniform(ParticlesShaderGLES3::DELTA,frame.delta); - shaders.particles.set_uniform(ParticlesShaderGLES3::GRAVITY,particles->gravity); - shaders.particles.set_uniform(ParticlesShaderGLES3::ATTRACTOR_COUNT,0); - - + shaders.particles.set_uniform(ParticlesShaderGLES3::TOTAL_PARTICLES, particles->amount); + shaders.particles.set_uniform(ParticlesShaderGLES3::TIME, 0.0); + shaders.particles.set_uniform(ParticlesShaderGLES3::EXPLOSIVENESS, particles->explosiveness); + shaders.particles.set_uniform(ParticlesShaderGLES3::DELTA, frame.delta); + shaders.particles.set_uniform(ParticlesShaderGLES3::GRAVITY, particles->gravity); + shaders.particles.set_uniform(ParticlesShaderGLES3::ATTRACTOR_COUNT, 0); - - glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[0]); + glBindBuffer(GL_ARRAY_BUFFER, particles->particle_buffers[0]); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, particles->particle_buffers[1]); - for(int i=0;i<6;i++) { + for (int i = 0; i < 6; i++) { glEnableVertexAttribArray(i); - glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,sizeof(float)*4*6,((uint8_t*)0)+(i*16)); + glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 4 * 6, ((uint8_t *)0) + (i * 16)); } - glBeginTransformFeedback(GL_POINTS); - glDrawArrays(GL_POINTS,0,particles->amount); + glDrawArrays(GL_POINTS, 0, particles->amount); glEndTransformFeedback(); particle_update_list.remove(particle_update_list.first()); - SWAP(particles->particle_buffers[0],particles->particle_buffers[1]); + SWAP(particles->particle_buffers[0], particles->particle_buffers[1]); } glDisable(GL_RASTERIZER_DISCARD); - for(int i=0;i<6;i++) { + for (int i = 0; i < 6; i++) { glDisableVertexAttribArray(i); } - } //////// -void RasterizerStorageGLES3::instance_add_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance) { +void RasterizerStorageGLES3::instance_add_skeleton(RID p_skeleton, RasterizerScene::InstanceBase *p_instance) { Skeleton *skeleton = skeleton_owner.getornull(p_skeleton); ERR_FAIL_COND(!skeleton); @@ -5427,7 +5106,7 @@ void RasterizerStorageGLES3::instance_add_skeleton(RID p_skeleton,RasterizerScen skeleton->instances.insert(p_instance); } -void RasterizerStorageGLES3::instance_remove_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance) { +void RasterizerStorageGLES3::instance_remove_skeleton(RID p_skeleton, RasterizerScene::InstanceBase *p_instance) { Skeleton *skeleton = skeleton_owner.getornull(p_skeleton); ERR_FAIL_COND(!skeleton); @@ -5435,11 +5114,10 @@ void RasterizerStorageGLES3::instance_remove_skeleton(RID p_skeleton,RasterizerS skeleton->instances.erase(p_instance); } +void RasterizerStorageGLES3::instance_add_dependency(RID p_base, RasterizerScene::InstanceBase *p_instance) { -void RasterizerStorageGLES3::instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance) { - - Instantiable *inst=NULL; - switch(p_instance->base_type) { + Instantiable *inst = NULL; + switch (p_instance->base_type) { case VS::INSTANCE_MESH: { inst = mesh_owner.getornull(p_base); ERR_FAIL_COND(!inst); @@ -5471,14 +5149,14 @@ void RasterizerStorageGLES3::instance_add_dependency(RID p_base,RasterizerScene: } } - inst->instance_list.add( &p_instance->dependency_item ); + inst->instance_list.add(&p_instance->dependency_item); } -void RasterizerStorageGLES3::instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance){ +void RasterizerStorageGLES3::instance_remove_dependency(RID p_base, RasterizerScene::InstanceBase *p_instance) { - Instantiable *inst=NULL; + Instantiable *inst = NULL; - switch(p_instance->base_type) { + switch (p_instance->base_type) { case VS::INSTANCE_MESH: { inst = mesh_owner.getornull(p_base); ERR_FAIL_COND(!inst); @@ -5513,85 +5191,76 @@ void RasterizerStorageGLES3::instance_remove_dependency(RID p_base,RasterizerSce ERR_FAIL_COND(!inst); - inst->instance_list.remove( &p_instance->dependency_item ); + inst->instance_list.remove(&p_instance->dependency_item); } - /* RENDER TARGET */ - void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) { - if (rt->fbo) { - glDeleteFramebuffers(1,&rt->fbo); - glDeleteTextures(1,&rt->color); - rt->fbo=0; + glDeleteFramebuffers(1, &rt->fbo); + glDeleteTextures(1, &rt->color); + rt->fbo = 0; } - if (rt->buffers.fbo) { - glDeleteFramebuffers(1,&rt->buffers.fbo); - glDeleteRenderbuffers(1,&rt->buffers.depth); - glDeleteRenderbuffers(1,&rt->buffers.diffuse); - glDeleteRenderbuffers(1,&rt->buffers.specular); - glDeleteRenderbuffers(1,&rt->buffers.normal_rough); - glDeleteRenderbuffers(1,&rt->buffers.motion_sss); - glDeleteFramebuffers(1,&rt->buffers.effect_fbo); - glDeleteTextures(1,&rt->buffers.effect); + glDeleteFramebuffers(1, &rt->buffers.fbo); + glDeleteRenderbuffers(1, &rt->buffers.depth); + glDeleteRenderbuffers(1, &rt->buffers.diffuse); + glDeleteRenderbuffers(1, &rt->buffers.specular); + glDeleteRenderbuffers(1, &rt->buffers.normal_rough); + glDeleteRenderbuffers(1, &rt->buffers.motion_sss); + glDeleteFramebuffers(1, &rt->buffers.effect_fbo); + glDeleteTextures(1, &rt->buffers.effect); - rt->buffers.fbo=0; + rt->buffers.fbo = 0; } - if (rt->depth) { - glDeleteTextures(1,&rt->depth); - rt->depth=0; + glDeleteTextures(1, &rt->depth); + rt->depth = 0; } - if (rt->effects.ssao.blur_fbo[0]) { - glDeleteFramebuffers(1,&rt->effects.ssao.blur_fbo[0]); - glDeleteTextures(1,&rt->effects.ssao.blur_red[0]); - glDeleteFramebuffers(1,&rt->effects.ssao.blur_fbo[1]); - glDeleteTextures(1,&rt->effects.ssao.blur_red[1]); - for(int i=0;i<rt->effects.ssao.depth_mipmap_fbos.size();i++) { - glDeleteFramebuffers(1,&rt->effects.ssao.depth_mipmap_fbos[i]); + glDeleteFramebuffers(1, &rt->effects.ssao.blur_fbo[0]); + glDeleteTextures(1, &rt->effects.ssao.blur_red[0]); + glDeleteFramebuffers(1, &rt->effects.ssao.blur_fbo[1]); + glDeleteTextures(1, &rt->effects.ssao.blur_red[1]); + for (int i = 0; i < rt->effects.ssao.depth_mipmap_fbos.size(); i++) { + glDeleteFramebuffers(1, &rt->effects.ssao.depth_mipmap_fbos[i]); } rt->effects.ssao.depth_mipmap_fbos.clear(); - glDeleteTextures(1,&rt->effects.ssao.linear_depth); + glDeleteTextures(1, &rt->effects.ssao.linear_depth); - rt->effects.ssao.blur_fbo[0]=0; - rt->effects.ssao.blur_fbo[1]=0; + rt->effects.ssao.blur_fbo[0] = 0; + rt->effects.ssao.blur_fbo[1] = 0; } - if (rt->exposure.fbo) { - glDeleteFramebuffers(1,&rt->exposure.fbo); - glDeleteTextures(1,&rt->exposure.color); - rt->exposure.fbo=0; + glDeleteFramebuffers(1, &rt->exposure.fbo); + glDeleteTextures(1, &rt->exposure.color); + rt->exposure.fbo = 0; } Texture *tex = texture_owner.get(rt->texture); - tex->alloc_height=0; - tex->alloc_width=0; - tex->width=0; - tex->height=0; - - - for(int i=0;i<2;i++) { - for(int j=0;j<rt->effects.mip_maps[i].sizes.size();j++) { - glDeleteFramebuffers(1,&rt->effects.mip_maps[i].sizes[j].fbo); + tex->alloc_height = 0; + tex->alloc_width = 0; + tex->width = 0; + tex->height = 0; + + for (int i = 0; i < 2; i++) { + for (int j = 0; j < rt->effects.mip_maps[i].sizes.size(); j++) { + glDeleteFramebuffers(1, &rt->effects.mip_maps[i].sizes[j].fbo); } - glDeleteTextures(1,&rt->effects.mip_maps[i].color); + glDeleteTextures(1, &rt->effects.mip_maps[i].color); rt->effects.mip_maps[i].sizes.clear(); - rt->effects.mip_maps[i].levels=0; + rt->effects.mip_maps[i].levels = 0; } - -/* + /* if (rt->effects.screen_space_depth) { glDeleteTextures(1,&rt->effects.screen_space_depth); rt->effects.screen_space_depth=0; @@ -5600,9 +5269,9 @@ void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) { */ } -void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ +void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) { - if (rt->width<=0 || rt->height<=0) + if (rt->width <= 0 || rt->height <= 0) return; GLuint color_internal_format; @@ -5611,22 +5280,21 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ Image::Format image_format; bool hdr = rt->flags[RENDER_TARGET_HDR] && config.hdr_supported; - hdr=false; + hdr = false; if (!hdr || rt->flags[RENDER_TARGET_NO_3D]) { - color_internal_format=GL_RGBA8; - color_format=GL_RGBA; - color_type=GL_UNSIGNED_BYTE; - image_format=Image::FORMAT_RGBA8; + color_internal_format = GL_RGBA8; + color_format = GL_RGBA; + color_type = GL_UNSIGNED_BYTE; + image_format = Image::FORMAT_RGBA8; } else { - color_internal_format=GL_RGBA16F; - color_format=GL_RGBA; - color_type=GL_HALF_FLOAT; - image_format=Image::FORMAT_RGBAH; + color_internal_format = GL_RGBA16F; + color_format = GL_RGBA; + color_type = GL_HALF_FLOAT; + image_format = Image::FORMAT_RGBAH; } - { /* FRONT FBO */ @@ -5635,23 +5303,22 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ glGenFramebuffers(1, &rt->fbo); glBindFramebuffer(GL_FRAMEBUFFER, rt->fbo); - glGenTextures(1, &rt->depth); glBindTexture(GL_TEXTURE_2D, rt->depth); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, rt->width, rt->height, 0, - GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); + GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); 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_DEPTH_ATTACHMENT, - GL_TEXTURE_2D, rt->depth, 0); + GL_TEXTURE_2D, rt->depth, 0); glGenTextures(1, &rt->color); glBindTexture(GL_TEXTURE_2D, rt->color); - glTexImage2D(GL_TEXTURE_2D, 0, color_internal_format, rt->width, rt->height, 0, color_format, color_type, NULL); + glTexImage2D(GL_TEXTURE_2D, 0, color_internal_format, rt->width, rt->height, 0, color_format, color_type, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); @@ -5663,36 +5330,31 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo); if (status != GL_FRAMEBUFFER_COMPLETE) { - printf("framebuffer fail, status: %x\n",status); + printf("framebuffer fail, status: %x\n", status); } - ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE ); + ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE); Texture *tex = texture_owner.get(rt->texture); - tex->format=image_format; - tex->gl_format_cache=color_format; - tex->gl_type_cache=color_type; - tex->gl_internal_format_cache=color_internal_format; - tex->tex_id=rt->color; - tex->width=rt->width; - tex->alloc_width=rt->width; - tex->height=rt->height; - tex->alloc_height=rt->height; - - - texture_set_flags(rt->texture,tex->flags); + tex->format = image_format; + tex->gl_format_cache = color_format; + tex->gl_type_cache = color_type; + tex->gl_internal_format_cache = color_internal_format; + tex->tex_id = rt->color; + tex->width = rt->width; + tex->alloc_width = rt->width; + tex->height = rt->height; + tex->alloc_height = rt->height; + texture_set_flags(rt->texture, tex->flags); } - /* BACK FBO */ - if (config.render_arch==RENDER_ARCH_DESKTOP && !rt->flags[RENDER_TARGET_NO_3D]) { - - + if (config.render_arch == RENDER_ARCH_DESKTOP && !rt->flags[RENDER_TARGET_NO_3D]) { - static const int msaa_value[]={0,2,4,8,16}; - int msaa=msaa_value[rt->msaa]; + static const int msaa_value[] = { 0, 2, 4, 8, 16 }; + int msaa = msaa_value[rt->msaa]; //regular fbo glGenFramebuffers(1, &rt->buffers.fbo); @@ -5700,66 +5362,63 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ glGenRenderbuffers(1, &rt->buffers.depth); glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.depth); - if (msaa==0) - glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH24_STENCIL8,rt->width,rt->height); + if (msaa == 0) + glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, rt->width, rt->height); else - glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_DEPTH24_STENCIL8,rt->width,rt->height); + glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, GL_DEPTH24_STENCIL8, rt->width, rt->height); + + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rt->buffers.depth); - glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,rt->buffers.depth); - glGenRenderbuffers(1, &rt->buffers.diffuse); glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.diffuse); - if (msaa==0) - glRenderbufferStorage(GL_RENDERBUFFER,color_internal_format,rt->width,rt->height); + if (msaa == 0) + glRenderbufferStorage(GL_RENDERBUFFER, color_internal_format, rt->width, rt->height); else - glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,color_internal_format,rt->width,rt->height); + glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, color_internal_format, rt->width, rt->height); - glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_RENDERBUFFER,rt->buffers.diffuse); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rt->buffers.diffuse); glGenRenderbuffers(1, &rt->buffers.specular); glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.specular); - if (msaa==0) - glRenderbufferStorage(GL_RENDERBUFFER,color_internal_format,rt->width,rt->height); + if (msaa == 0) + glRenderbufferStorage(GL_RENDERBUFFER, color_internal_format, rt->width, rt->height); else - glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,color_internal_format,rt->width,rt->height); + glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, color_internal_format, rt->width, rt->height); - glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT1,GL_RENDERBUFFER,rt->buffers.specular); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, rt->buffers.specular); glGenRenderbuffers(1, &rt->buffers.normal_rough); glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.normal_rough); - if (msaa==0) - glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA8,rt->width,rt->height); + if (msaa == 0) + glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, rt->width, rt->height); else - glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA8,rt->width,rt->height); - - glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT2,GL_RENDERBUFFER,rt->buffers.normal_rough); + glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, GL_RGBA8, rt->width, rt->height); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_RENDERBUFFER, rt->buffers.normal_rough); glGenRenderbuffers(1, &rt->buffers.motion_sss); glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.motion_sss); - if (msaa==0) - glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA8,rt->width,rt->height); + if (msaa == 0) + glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, rt->width, rt->height); else - glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA8,rt->width,rt->height); - - glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT3,GL_RENDERBUFFER,rt->buffers.motion_sss); - + glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, GL_RGBA8, rt->width, rt->height); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_RENDERBUFFER, rt->buffers.motion_sss); GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo); if (status != GL_FRAMEBUFFER_COMPLETE) { - printf("err status: %x\n",status); + printf("err status: %x\n", status); _render_target_clear(rt); - ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE ); - } + ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE); + } - glBindRenderbuffer(GL_RENDERBUFFER,0); + glBindRenderbuffer(GL_RENDERBUFFER, 0); // effect resolver @@ -5769,92 +5428,84 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ glGenTextures(1, &rt->buffers.effect); glBindTexture(GL_TEXTURE_2D, rt->buffers.effect); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, rt->width, rt->height, 0, - GL_RGBA, GL_UNSIGNED_BYTE, NULL); + GL_RGBA, GL_UNSIGNED_BYTE, NULL); 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, rt->buffers.effect, 0); - + GL_TEXTURE_2D, rt->buffers.effect, 0); if (status != GL_FRAMEBUFFER_COMPLETE) { - printf("err status: %x\n",status); + printf("err status: %x\n", status); _render_target_clear(rt); - ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE ); + ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE); } glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo); if (status != GL_FRAMEBUFFER_COMPLETE) { _render_target_clear(rt); - ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE ); + ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE); } - for(int i=0;i<2;i++) { + for (int i = 0; i < 2; i++) { - ERR_FAIL_COND( rt->effects.mip_maps[i].sizes.size() ); - int w=rt->width; - int h=rt->height; + ERR_FAIL_COND(rt->effects.mip_maps[i].sizes.size()); + int w = rt->width; + int h = rt->height; - - if (i>0) { - w>>=1; - h>>=1; + if (i > 0) { + w >>= 1; + h >>= 1; } - glGenTextures(1, &rt->effects.mip_maps[i].color); glBindTexture(GL_TEXTURE_2D, rt->effects.mip_maps[i].color); - int level=0; + int level = 0; - while(true) { + while (true) { RenderTarget::Effects::MipMaps::Size mm; - glTexImage2D(GL_TEXTURE_2D, level, color_internal_format, w, h, 0, color_format, color_type, NULL); - mm.width=w; - mm.height=h; + glTexImage2D(GL_TEXTURE_2D, level, color_internal_format, w, h, 0, color_format, color_type, NULL); + mm.width = w; + mm.height = h; rt->effects.mip_maps[i].sizes.push_back(mm); - w>>=1; - h>>=1; + w >>= 1; + h >>= 1; - if (w<2 || h<2) + if (w < 2 || h < 2) break; level++; - } glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level); + for (int j = 0; j < rt->effects.mip_maps[i].sizes.size(); j++) { - for(int j=0;j<rt->effects.mip_maps[i].sizes.size();j++) { - - RenderTarget::Effects::MipMaps::Size &mm=rt->effects.mip_maps[i].sizes[j]; + RenderTarget::Effects::MipMaps::Size &mm = rt->effects.mip_maps[i].sizes[j]; glGenFramebuffers(1, &mm.fbo); glBindFramebuffer(GL_FRAMEBUFFER, mm.fbo); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,rt->effects.mip_maps[i].color ,j); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->effects.mip_maps[i].color, j); status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (status != GL_FRAMEBUFFER_COMPLETE) { _render_target_clear(rt); - ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE ); + ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE); } - - float zero[4]={1,0,1,0}; - glClearBufferfv(GL_COLOR,0,zero); - - + float zero[4] = { 1, 0, 1, 0 }; + glClearBufferfv(GL_COLOR, 0, zero); } glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo); - rt->effects.mip_maps[i].levels=level; + rt->effects.mip_maps[i].levels = level; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); @@ -5862,23 +5513,21 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ //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); - - } ///////////////// ssao //AO strength textures - for(int i=0;i<2;i++) { + for (int i = 0; i < 2; i++) { glGenFramebuffers(1, &rt->effects.ssao.blur_fbo[i]); glBindFramebuffer(GL_FRAMEBUFFER, rt->effects.ssao.blur_fbo[i]); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, - GL_TEXTURE_2D, rt->depth, 0); + GL_TEXTURE_2D, rt->depth, 0); glGenTextures(1, &rt->effects.ssao.blur_red[i]); glBindTexture(GL_TEXTURE_2D, rt->effects.ssao.blur_red[i]); - glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, rt->width, rt->height, 0, GL_RED, GL_UNSIGNED_BYTE, NULL); + glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, rt->width, rt->height, 0, GL_RED, GL_UNSIGNED_BYTE, NULL); 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); @@ -5889,24 +5538,22 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (status != GL_FRAMEBUFFER_COMPLETE) { _render_target_clear(rt); - ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE ); + ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE); } - } //5 mip levels for depth texture, but base is read separately glGenTextures(1, &rt->effects.ssao.linear_depth); glBindTexture(GL_TEXTURE_2D, rt->effects.ssao.linear_depth); - int ssao_w=rt->width/2; - int ssao_h=rt->height/2; + int ssao_w = rt->width / 2; + int ssao_h = rt->height / 2; + for (int i = 0; i < 4; i++) { //5, but 4 mips, base is read directly to save bw - for(int i=0;i<4;i++) { //5, but 4 mips, base is read directly to save bw - - glTexImage2D(GL_TEXTURE_2D, i, GL_R16UI, ssao_w, ssao_h, 0, GL_RED_INTEGER, GL_UNSIGNED_SHORT, NULL); - ssao_w>>=1; - ssao_h>>=1; + glTexImage2D(GL_TEXTURE_2D, i, GL_R16UI, ssao_w, ssao_h, 0, GL_RED_INTEGER, GL_UNSIGNED_SHORT, NULL); + ssao_w >>= 1; + ssao_h >>= 1; } glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); @@ -5916,7 +5563,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 3); - for(int i=0;i<4;i++) { //5, but 4 mips, base is read directly to save bw + for (int i = 0; i < 4; i++) { //5, but 4 mips, base is read directly to save bw GLuint fbo; glGenFramebuffers(1, &fbo); @@ -5925,7 +5572,6 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ rt->effects.ssao.depth_mipmap_fbos.push_back(fbo); } - //////Exposure glGenFramebuffers(1, &rt->exposure.fbo); @@ -5933,82 +5579,77 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){ glGenTextures(1, &rt->exposure.color); glBindTexture(GL_TEXTURE_2D, rt->exposure.color); - glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 1, 1, 0, GL_RED, GL_FLOAT, NULL); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->exposure.color, 0); + glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 1, 1, 0, GL_RED, GL_FLOAT, NULL); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->exposure.color, 0); status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (status != GL_FRAMEBUFFER_COMPLETE) { _render_target_clear(rt); - ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE ); + ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE); } - } } +RID RasterizerStorageGLES3::render_target_create() { -RID RasterizerStorageGLES3::render_target_create(){ - - RenderTarget *rt = memnew( RenderTarget ); + RenderTarget *rt = memnew(RenderTarget); - Texture * t = memnew( Texture ); + Texture *t = memnew(Texture); - t->flags=0; - t->width=0; - t->height=0; - t->alloc_height=0; - t->alloc_width=0; - 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->compressed=false; - t->srgb=false; - t->total_data_size=0; - t->ignore_mipmaps=false; - t->mipmaps=0; - t->active=true; - t->tex_id=0; + t->flags = 0; + t->width = 0; + t->height = 0; + t->alloc_height = 0; + t->alloc_width = 0; + 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->compressed = false; + t->srgb = false; + t->total_data_size = 0; + t->ignore_mipmaps = false; + t->mipmaps = 0; + t->active = true; + t->tex_id = 0; - - rt->texture=texture_owner.make_rid(t); + rt->texture = texture_owner.make_rid(t); return render_target_owner.make_rid(rt); } -void RasterizerStorageGLES3::render_target_set_size(RID p_render_target,int p_width, int p_height){ +void RasterizerStorageGLES3::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 (rt->width==p_width && rt->height==p_height) + if (rt->width == p_width && rt->height == p_height) return; _render_target_clear(rt); - rt->width=p_width; - rt->height=p_height; + rt->width = p_width; + rt->height = p_height; _render_target_allocate(rt); - } - -RID RasterizerStorageGLES3::render_target_get_texture(RID p_render_target) const{ +RID RasterizerStorageGLES3::render_target_get_texture(RID p_render_target) const { RenderTarget *rt = render_target_owner.getornull(p_render_target); - ERR_FAIL_COND_V(!rt,RID()); + ERR_FAIL_COND_V(!rt, RID()); return rt->texture; } -void RasterizerStorageGLES3::render_target_set_flag(RID p_render_target,RenderTargetFlags p_flag,bool p_value) { +void RasterizerStorageGLES3::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); - rt->flags[p_flag]=p_value; + rt->flags[p_flag] = p_value; - switch(p_flag) { + switch (p_flag) { case RENDER_TARGET_NO_3D: case RENDER_TARGET_TRANSPARENT: { //must reset for these formats @@ -6020,36 +5661,34 @@ void RasterizerStorageGLES3::render_target_set_flag(RID p_render_target,RenderTa } } -bool RasterizerStorageGLES3::render_target_renedered_in_frame(RID p_render_target){ +bool RasterizerStorageGLES3::render_target_renedered_in_frame(RID p_render_target) { return false; } -void RasterizerStorageGLES3::render_target_set_msaa(RID p_render_target,VS::ViewportMSAA p_msaa) { +void RasterizerStorageGLES3::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) + if (rt->msaa == p_msaa) return; _render_target_clear(rt); - rt->msaa=p_msaa; + rt->msaa = p_msaa; _render_target_allocate(rt); - } /* CANVAS SHADOW */ - RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) { - CanvasLightShadow *cls = memnew( CanvasLightShadow ); - if (p_width>config.max_texture_size) - p_width=config.max_texture_size; + CanvasLightShadow *cls = memnew(CanvasLightShadow); + if (p_width > config.max_texture_size) + p_width = config.max_texture_size; - cls->size=p_width; - cls->height=16; + cls->size = p_width; + cls->height = 16; glActiveTexture(GL_TEXTURE0); @@ -6057,12 +5696,12 @@ RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) { glBindFramebuffer(GL_FRAMEBUFFER, cls->fbo); glGenRenderbuffers(1, &cls->depth); - glBindRenderbuffer(GL_RENDERBUFFER, cls->depth ); - glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH_COMPONENT24, cls->size, cls->height); + glBindRenderbuffer(GL_RENDERBUFFER, cls->depth); + glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, cls->size, cls->height); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, cls->depth); - glBindRenderbuffer(GL_RENDERBUFFER, 0 ); + glBindRenderbuffer(GL_RENDERBUFFER, 0); - glGenTextures(1,&cls->distance); + glGenTextures(1, &cls->distance); glBindTexture(GL_TEXTURE_2D, cls->distance); if (config.use_rgba_2d_shadows) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, cls->size, cls->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); @@ -6070,139 +5709,124 @@ RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) { glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, cls->size, cls->height, 0, GL_RED, GL_FLOAT, NULL); } - - - 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, RasterizerStorageGLES3::system_fbo); - ERR_FAIL_COND_V( status != GL_FRAMEBUFFER_COMPLETE, RID() ); + ERR_FAIL_COND_V(status != GL_FRAMEBUFFER_COMPLETE, RID()); return canvas_light_shadow_owner.make_rid(cls); } /* LIGHT SHADOW MAPPING */ - RID RasterizerStorageGLES3::canvas_light_occluder_create() { - CanvasOccluder *co = memnew( CanvasOccluder ); - co->index_id=0; - co->vertex_id=0; - co->len=0; + CanvasOccluder *co = memnew(CanvasOccluder); + co->index_id = 0; + co->vertex_id = 0; + co->len = 0; return canvas_occluder_owner.make_rid(co); } -void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2>& p_lines) { +void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2> &p_lines) { CanvasOccluder *co = canvas_occluder_owner.get(p_occluder); ERR_FAIL_COND(!co); - co->lines=p_lines; + co->lines = p_lines; - if (p_lines.size()!=co->len) { + if (p_lines.size() != co->len) { if (co->index_id) - glDeleteBuffers(1,&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; + 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); + geometry.resize(lc * 6); + indices.resize(lc * 3); - PoolVector<float>::Write vw=geometry.write(); - PoolVector<uint16_t>::Write iw=indices.write(); + PoolVector<float>::Write vw = geometry.write(); + PoolVector<uint16_t>::Write iw = indices.write(); - - PoolVector<Vector2>::Read lr=p_lines.read(); + 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; + for (int i = 0; i < lc / 2; i++) { - 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 + 0] = lr[i * 2 + 0].x; + vw[i * 12 + 1] = lr[i * 2 + 0].y; + vw[i * 12 + 2] = 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 + 3] = lr[i * 2 + 1].x; + vw[i * 12 + 4] = lr[i * 2 + 1].y; + vw[i * 12 + 5] = 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; + vw[i * 12 + 6] = lr[i * 2 + 1].x; + vw[i * 12 + 7] = lr[i * 2 + 1].y; + vw[i * 12 + 8] = -POLY_HEIGHT; - iw[i*6+0]=i*4+0; - iw[i*6+1]=i*4+1; - iw[i*6+2]=i*4+2; + 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+3]=i*4+2; - iw[i*6+4]=i*4+3; - iw[i*6+5]=i*4+0; + 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); + 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, co->vertex_id); + glBufferSubData(GL_ARRAY_BUFFER, 0, lc * 6 * sizeof(real_t), vw.ptr()); } - glBindBuffer(GL_ARRAY_BUFFER,0); //unbind + 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_STATIC_DRAW); + 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_STATIC_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, 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; + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); //unbind + co->len = lc; } - } VS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const { @@ -6234,13 +5858,13 @@ VS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const { return VS::INSTANCE_NONE; } -bool RasterizerStorageGLES3::free(RID p_rid){ +bool RasterizerStorageGLES3::free(RID p_rid) { 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 *t = texture_owner.get(rt->texture); texture_owner.free(rt->texture); memdelete(t); render_target_owner.free(p_rid); @@ -6249,14 +5873,14 @@ bool RasterizerStorageGLES3::free(RID p_rid){ } else if (texture_owner.owns(p_rid)) { // delete the texture Texture *texture = texture_owner.get(p_rid); - ERR_FAIL_COND_V(texture->render_target,true); //cant free the render target texture, dude - info.texture_mem-=texture->total_data_size; + ERR_FAIL_COND_V(texture->render_target, true); //cant free the render target texture, dude + info.texture_mem -= texture->total_data_size; texture_owner.free(p_rid); memdelete(texture); } else if (skybox_owner.owns(p_rid)) { // delete the skybox SkyBox *skybox = skybox_owner.get(p_rid); - skybox_set_texture(p_rid,RID(),256); + skybox_set_texture(p_rid, RID(), 256); skybox_owner.free(p_rid); memdelete(skybox); @@ -6265,7 +5889,6 @@ bool RasterizerStorageGLES3::free(RID p_rid){ // delete the texture Shader *shader = shader_owner.get(p_rid); - if (shader->shader) shader->shader->free_custom_shader(shader->custom_code_id); @@ -6276,10 +5899,10 @@ bool RasterizerStorageGLES3::free(RID p_rid){ Material *mat = shader->materials.first()->self(); - mat->shader=NULL; + mat->shader = NULL; _material_make_dirty(mat); - shader->materials.remove( shader->materials.first() ); + shader->materials.remove(shader->materials.first()); } //material_shader.free_custom_shader(shader->custom_code_id); @@ -6292,31 +5915,30 @@ bool RasterizerStorageGLES3::free(RID p_rid){ Material *material = material_owner.get(p_rid); if (material->shader) { - material->shader->materials.remove( & material->list ); + material->shader->materials.remove(&material->list); } if (material->ubo_id) { - glDeleteBuffers(1,&material->ubo_id); + glDeleteBuffers(1, &material->ubo_id); } //remove from owners - for (Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) { + for (Map<Geometry *, int>::Element *E = material->geometry_owners.front(); E; E = E->next()) { Geometry *g = E->key(); - g->material=RID(); + g->material = RID(); } - for (Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.front();E;E=E->next()) { - RasterizerScene::InstanceBase*ins=E->key(); - if (ins->material_override==p_rid) { - ins->material_override=RID(); + for (Map<RasterizerScene::InstanceBase *, int>::Element *E = material->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[i]=RID(); + for (int i = 0; i < ins->materials.size(); i++) { + if (ins->materials[i] == p_rid) { + ins->materials[i] = RID(); } } - } material_owner.free(p_rid); @@ -6330,11 +5952,11 @@ bool RasterizerStorageGLES3::free(RID p_rid){ skeleton_update_list.remove(&skeleton->update_list); } - for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) { - E->get()->skeleton=RID(); + for (Set<RasterizerScene::InstanceBase *>::Element *E = skeleton->instances.front(); E; E = E->next()) { + E->get()->skeleton = RID(); } - skeleton_allocate(p_rid,0,false); + skeleton_allocate(p_rid, 0, false); skeleton_owner.free(p_rid); memdelete(skeleton); @@ -6345,16 +5967,15 @@ bool RasterizerStorageGLES3::free(RID p_rid){ mesh->instance_remove_deps(); mesh_clear(p_rid); - while(mesh->multimeshes.first()) { + while (mesh->multimeshes.first()) { MultiMesh *multimesh = mesh->multimeshes.first()->self(); - multimesh->mesh=RID(); - multimesh->dirty_aabb=true; + 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); @@ -6373,10 +5994,9 @@ bool RasterizerStorageGLES3::free(RID p_rid){ } } - multimesh_allocate(p_rid,0,VS::MULTIMESH_TRANSFORM_2D,VS::MULTIMESH_COLOR_NONE); //frees multimesh + multimesh_allocate(p_rid, 0, VS::MULTIMESH_TRANSFORM_2D, VS::MULTIMESH_COLOR_NONE); //frees multimesh update_dirty_multimeshes(); - multimesh_owner.free(p_rid); memdelete(multimesh); } else if (immediate_owner.owns(p_rid)) { @@ -6409,7 +6029,6 @@ bool RasterizerStorageGLES3::free(RID p_rid){ // delete the texture GIProbe *gi_probe = gi_probe_owner.get(p_rid); - gi_probe_owner.free(p_rid); memdelete(gi_probe); } else if (gi_probe_data_owner.owns(p_rid)) { @@ -6418,18 +6037,17 @@ bool RasterizerStorageGLES3::free(RID p_rid){ GIProbeData *gi_probe_data = gi_probe_data_owner.get(p_rid); print_line("dyndata delete"); - glDeleteTextures(1,&gi_probe_data->tex_id); + glDeleteTextures(1, &gi_probe_data->tex_id); gi_probe_owner.free(p_rid); memdelete(gi_probe_data); } 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); + glDeleteBuffers(1, &co->index_id); if (co->vertex_id) - glDeleteBuffers(1,&co->vertex_id); + glDeleteBuffers(1, &co->vertex_id); canvas_occluder_owner.free(p_rid); memdelete(co); @@ -6437,9 +6055,9 @@ bool RasterizerStorageGLES3::free(RID p_rid){ } else if (canvas_light_shadow_owner.owns(p_rid)) { CanvasLightShadow *cls = canvas_light_shadow_owner.get(p_rid); - glDeleteFramebuffers(1,&cls->fbo); - glDeleteRenderbuffers(1,&cls->depth); - glDeleteTextures(1,&cls->distance); + glDeleteFramebuffers(1, &cls->fbo); + glDeleteRenderbuffers(1, &cls->depth); + glDeleteTextures(1, &cls->distance); canvas_light_shadow_owner.free(p_rid); memdelete(cls); } else { @@ -6449,206 +6067,193 @@ bool RasterizerStorageGLES3::free(RID p_rid){ return true; } +bool RasterizerStorageGLES3::has_os_feature(const String &p_feature) const { -bool RasterizerStorageGLES3::has_os_feature(const String& p_feature) const { - - if (p_feature=="s3tc") + if (p_feature == "s3tc") return config.s3tc_supported; - if (p_feature=="etc") + if (p_feature == "etc") return config.etc_supported; - if (p_feature=="etc2") + if (p_feature == "etc2") return config.etc2_supported; - if (p_feature=="pvrtc") + if (p_feature == "pvrtc") return config.pvrtc_supported; return false; - } //////////////////////////////////////////// - void RasterizerStorageGLES3::initialize() { - config.render_arch=RENDER_ARCH_DESKTOP; + config.render_arch = RENDER_ARCH_DESKTOP; //config.fbo_deferred=int(Globals::get_singleton()->get("rendering/gles3/lighting_technique")); - RasterizerStorageGLES3::system_fbo=0; - + RasterizerStorageGLES3::system_fbo = 0; //// extensions config /// { - int max_extensions=0; + int max_extensions = 0; print_line("getting extensions"); - glGetIntegerv(GL_NUM_EXTENSIONS,&max_extensions); - print_line("total "+itos(max_extensions)); - for(int i=0;i<max_extensions;i++) { - const GLubyte *s = glGetStringi( GL_EXTENSIONS,i ); + glGetIntegerv(GL_NUM_EXTENSIONS, &max_extensions); + print_line("total " + itos(max_extensions)); + for (int i = 0; i < max_extensions; i++) { + const GLubyte *s = glGetStringi(GL_EXTENSIONS, i); if (!s) break; - config.extensions.insert((const char*)s); + config.extensions.insert((const char *)s); } } - config.shrink_textures_x2=false; - config.use_fast_texture_filter=int(GlobalConfig::get_singleton()->get("rendering/quality/use_nearest_mipmap_filter")); + config.shrink_textures_x2 = false; + config.use_fast_texture_filter = int(GlobalConfig::get_singleton()->get("rendering/quality/use_nearest_mipmap_filter")); config.use_anisotropic_filter = config.extensions.has("GL_EXT_texture_filter_anisotropic"); - config.s3tc_supported=config.extensions.has("GL_EXT_texture_compression_dxt1") || config.extensions.has("GL_EXT_texture_compression_s3tc") || config.extensions.has("WEBGL_compressed_texture_s3tc"); - config.etc_supported=config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture"); - config.latc_supported=config.extensions.has("GL_EXT_texture_compression_latc"); - config.bptc_supported=config.extensions.has("GL_ARB_texture_compression_bptc"); + config.s3tc_supported = config.extensions.has("GL_EXT_texture_compression_dxt1") || config.extensions.has("GL_EXT_texture_compression_s3tc") || config.extensions.has("WEBGL_compressed_texture_s3tc"); + config.etc_supported = config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture"); + config.latc_supported = config.extensions.has("GL_EXT_texture_compression_latc"); + config.bptc_supported = config.extensions.has("GL_ARB_texture_compression_bptc"); #ifdef GLES_OVER_GL - config.hdr_supported=true; - config.etc2_supported=false; + config.hdr_supported = true; + config.etc2_supported = false; #else - config.etc2_supported=true; - config.hdr_supported=false; + config.etc2_supported = true; + config.hdr_supported = false; #endif - config.pvrtc_supported=config.extensions.has("GL_IMG_texture_compression_pvrtc"); - config.srgb_decode_supported=config.extensions.has("GL_EXT_texture_sRGB_decode"); - + config.pvrtc_supported = config.extensions.has("GL_IMG_texture_compression_pvrtc"); + config.srgb_decode_supported = config.extensions.has("GL_EXT_texture_sRGB_decode"); - - config.anisotropic_level=1.0; - config.use_anisotropic_filter=config.extensions.has("GL_EXT_texture_filter_anisotropic"); + config.anisotropic_level = 1.0; + config.use_anisotropic_filter = config.extensions.has("GL_EXT_texture_filter_anisotropic"); if (config.use_anisotropic_filter) { - glGetFloatv(_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,&config.anisotropic_level); - config.anisotropic_level=MIN(int(GlobalConfig::get_singleton()->get("rendering/quality/anisotropic_filter_level")),config.anisotropic_level); + glGetFloatv(_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &config.anisotropic_level); + config.anisotropic_level = MIN(int(GlobalConfig::get_singleton()->get("rendering/quality/anisotropic_filter_level")), config.anisotropic_level); } - - frame.clear_request=false; + frame.clear_request = false; shaders.copy.init(); { //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; + 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); + 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); + 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; + 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); + 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); + 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; + 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); + 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); - + 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; + 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); + 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); - + glBindTexture(GL_TEXTURE_2D, 0); } - glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&config.max_texture_image_units); - glGetIntegerv(GL_MAX_TEXTURE_SIZE,&config.max_texture_size); + glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &config.max_texture_image_units); + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &config.max_texture_size); #ifdef GLES_OVER_GL - config.use_rgba_2d_shadows=false; + config.use_rgba_2d_shadows = false; #else - config.use_rgba_2d_shadows=true; + config.use_rgba_2d_shadows = true; #endif - //generic quadie for copying { //quad buffers - glGenBuffers(1,&resources.quadie); - glBindBuffer(GL_ARRAY_BUFFER,resources.quadie); + glGenBuffers(1, &resources.quadie); + glBindBuffer(GL_ARRAY_BUFFER, resources.quadie); { - const float qv[16]={ - -1,-1, - 0, 0, + const float qv[16] = { + -1, -1, + 0, 0, -1, 1, - 0, 1, - 1, 1, - 1, 1, - 1,-1, - 1, 0, + 0, 1, + 1, 1, + 1, 1, + 1, -1, + 1, 0, }; - glBufferData(GL_ARRAY_BUFFER,sizeof(float)*16,qv,GL_STATIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 16, qv, GL_STATIC_DRAW); } - glBindBuffer(GL_ARRAY_BUFFER,0); //unbind - + glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind - glGenVertexArrays(1,&resources.quadie_array); + glGenVertexArrays(1, &resources.quadie_array); glBindVertexArray(resources.quadie_array); - glBindBuffer(GL_ARRAY_BUFFER,resources.quadie); - glVertexAttribPointer(VS::ARRAY_VERTEX,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,0); + glBindBuffer(GL_ARRAY_BUFFER, resources.quadie); + glVertexAttribPointer(VS::ARRAY_VERTEX, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, 0); glEnableVertexAttribArray(0); - glVertexAttribPointer(VS::ARRAY_TEX_UV,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,((uint8_t*)NULL)+8); + glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, ((uint8_t *)NULL) + 8); glEnableVertexAttribArray(4); glBindVertexArray(0); - glBindBuffer(GL_ARRAY_BUFFER,0); //unbind + glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind } //generic quadie for copying without touching skybox { //transform feedback buffers - uint32_t xf_feedback_size = GLOBAL_DEF("rendering/buffers/blend_shape_max_buffer_size_kb",4096); - for(int i=0;i<2;i++) { + uint32_t xf_feedback_size = GLOBAL_DEF("rendering/buffers/blend_shape_max_buffer_size_kb", 4096); + for (int i = 0; i < 2; i++) { - glGenBuffers(1,&resources.transform_feedback_buffers[i]); - glBindBuffer(GL_ARRAY_BUFFER,resources.transform_feedback_buffers[i]); - glBufferData(GL_ARRAY_BUFFER,xf_feedback_size*1024,NULL,GL_STREAM_DRAW); + glGenBuffers(1, &resources.transform_feedback_buffers[i]); + glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[i]); + glBufferData(GL_ARRAY_BUFFER, xf_feedback_size * 1024, NULL, GL_STREAM_DRAW); } shaders.blend_shapes.init(); - glGenVertexArrays(1,&resources.transform_feedback_array); - + glGenVertexArrays(1, &resources.transform_feedback_array); } shaders.cubemap_filter.init(); @@ -6656,10 +6261,10 @@ void RasterizerStorageGLES3::initialize() { glEnable(_EXT_TEXTURE_CUBE_MAP_SEAMLESS); - frame.count=0; - frame.prev_tick=0; - frame.delta=0; - config.keep_original_textures=false; + frame.count = 0; + frame.prev_tick = 0; + frame.delta = 0; + config.keep_original_textures = false; } void RasterizerStorageGLES3::finalize() { @@ -6667,7 +6272,6 @@ void RasterizerStorageGLES3::finalize() { glDeleteTextures(1, &resources.white_tex); glDeleteTextures(1, &resources.black_tex); glDeleteTextures(1, &resources.normal_tex); - } void RasterizerStorageGLES3::update_dirty_resources() { @@ -6679,7 +6283,5 @@ void RasterizerStorageGLES3::update_dirty_resources() { update_particles(); } -RasterizerStorageGLES3::RasterizerStorageGLES3() -{ - +RasterizerStorageGLES3::RasterizerStorageGLES3() { } |