2016-10-03 19:33:42 +00:00
|
|
|
#include "rasterizer_storage_gles3.h"
|
2016-10-10 21:31:01 +00:00
|
|
|
#include "rasterizer_canvas_gles3.h"
|
2016-10-19 14:14:41 +00:00
|
|
|
#include "rasterizer_scene_gles3.h"
|
2016-10-03 19:33:42 +00:00
|
|
|
#include "globals.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_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_RED_RGTC1_EXT 0x8DBB
|
|
|
|
#define _EXT_COMPRESSED_RED_RGTC1 0x8DBB
|
|
|
|
#define _EXT_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
|
|
|
|
#define _EXT_COMPRESSED_RG_RGTC2 0x8DBD
|
|
|
|
#define _EXT_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
|
|
|
|
#define _EXT_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC
|
|
|
|
#define _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD
|
|
|
|
#define _EXT_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE
|
|
|
|
#define _EXT_ETC1_RGB8_OES 0x8D64
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define _EXT_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_ATC_RGB_AMD 0x8C92
|
|
|
|
#define _EXT_ATC_RGBA_EXPLICIT_ALPHA_AMD 0x8C93
|
|
|
|
#define _EXT_ATC_RGBA_INTERPOLATED_ALPHA_AMD 0x87EE
|
|
|
|
|
|
|
|
|
2016-10-30 01:11:05 +00:00
|
|
|
#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
#define _GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
|
|
|
|
#define _GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
#define _EXT_COMPRESSED_R11_EAC 0x9270
|
|
|
|
#define _EXT_COMPRESSED_SIGNED_R11_EAC 0x9271
|
|
|
|
#define _EXT_COMPRESSED_RG11_EAC 0x9272
|
|
|
|
#define _EXT_COMPRESSED_SIGNED_RG11_EAC 0x9273
|
|
|
|
#define _EXT_COMPRESSED_RGB8_ETC2 0x9274
|
|
|
|
#define _EXT_COMPRESSED_SRGB8_ETC2 0x9275
|
|
|
|
#define _EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
|
|
|
|
#define _EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
|
|
|
|
#define _EXT_COMPRESSED_RGBA8_ETC2_EAC 0x9278
|
|
|
|
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
|
|
|
|
|
|
|
|
#define _EXT_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C
|
|
|
|
#define _EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D
|
|
|
|
#define _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E
|
|
|
|
#define _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-07 08:33:11 +00:00
|
|
|
GLuint RasterizerStorageGLES3::system_fbo = 0;
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
bool need_decompress=false;
|
|
|
|
|
|
|
|
switch(p_format) {
|
|
|
|
|
|
|
|
case Image::FORMAT_L8: {
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=GL_R8;
|
|
|
|
r_gl_format=GL_RED;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_LA8: {
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=GL_RG8;
|
|
|
|
r_gl_format=GL_RG;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_R8: {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} 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;
|
|
|
|
|
|
|
|
} 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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_RGB565: {
|
2017-01-31 02:46:30 +00:00
|
|
|
#ifndef GLES_OVER_GL
|
2017-01-07 08:33:11 +00:00
|
|
|
r_gl_internal_format=GL_RGB565;
|
|
|
|
#else
|
2016-12-21 05:29:58 +00:00
|
|
|
//#warning TODO: Convert tod 555 if 565 is not supported (GLES3.3-)
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=GL_RGB5;
|
2017-01-07 08:33:11 +00:00
|
|
|
#endif
|
2016-11-22 23:51:56 +00:00
|
|
|
//r_gl_internal_format=GL_RGB565;
|
2016-10-03 19:33:42 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_RGBA5551: {
|
|
|
|
|
|
|
|
r_gl_internal_format=GL_RGB5_A1;
|
|
|
|
r_gl_format=GL_RGBA;
|
|
|
|
r_gl_type=GL_UNSIGNED_SHORT_5_5_5_1;
|
|
|
|
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_RF: {
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_RGBF: {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_RH: {
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_RGBH: {
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_DXT1: {
|
|
|
|
|
|
|
|
if (config.s3tc_supported) {
|
|
|
|
|
|
|
|
|
2017-02-06 03:38:39 +00:00
|
|
|
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;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RGBA;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
srgb=true;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
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;
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_BPTC_RGBA: {
|
|
|
|
|
|
|
|
if (config.bptc_supported) {
|
|
|
|
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
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;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RGBA;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
srgb=true;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_BPTC_RGBF: {
|
|
|
|
|
|
|
|
if (config.bptc_supported) {
|
|
|
|
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RGB;
|
|
|
|
r_gl_type=GL_FLOAT;
|
|
|
|
r_compressed=true;
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_BPTC_RGBFU: {
|
|
|
|
if (config.bptc_supported) {
|
|
|
|
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RGB;
|
|
|
|
r_gl_type=GL_FLOAT;
|
|
|
|
r_compressed=true;
|
|
|
|
} else {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_PVRTC4A: {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_ETC2_R11: {
|
|
|
|
|
|
|
|
if (config.etc2_supported) {
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=_EXT_COMPRESSED_R11_EAC;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RED;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_ETC2_R11S: {
|
|
|
|
|
|
|
|
if (config.etc2_supported) {
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=_EXT_COMPRESSED_SIGNED_R11_EAC;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RED;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_ETC2_RG11: {
|
|
|
|
|
|
|
|
if (config.etc2_supported) {
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=_EXT_COMPRESSED_RG11_EAC;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RG;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_ETC2_RG11S: {
|
|
|
|
if (config.etc2_supported) {
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=_EXT_COMPRESSED_SIGNED_RG11_EAC;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RG;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_ETC2_RGB8: {
|
|
|
|
|
|
|
|
if (config.etc2_supported) {
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ETC2:_EXT_COMPRESSED_RGB8_ETC2;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RGB;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
srgb=true;
|
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_ETC2_RGBA8: {
|
|
|
|
|
|
|
|
if (config.etc2_supported) {
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
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;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RGBA;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
srgb=true;
|
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case Image::FORMAT_ETC2_RGB8A1: {
|
|
|
|
|
|
|
|
if (config.etc2_supported) {
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
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;
|
2016-10-03 19:33:42 +00:00
|
|
|
r_gl_format=GL_RGBA;
|
|
|
|
r_gl_type=GL_UNSIGNED_BYTE;
|
|
|
|
r_compressed=true;
|
|
|
|
srgb=true;
|
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
need_decompress=true;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
default: {
|
|
|
|
|
|
|
|
ERR_FAIL_V(Image());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (need_decompress) {
|
|
|
|
|
|
|
|
if (!image.empty()) {
|
|
|
|
image.decompress();
|
|
|
|
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;
|
|
|
|
|
|
|
|
return image;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return image;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const GLenum _cube_side_enum[6]={
|
|
|
|
|
|
|
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
|
|
|
|
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
|
|
|
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
|
|
|
|
GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
|
|
|
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
|
|
|
|
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::texture_create() {
|
|
|
|
|
|
|
|
Texture *texture = memnew(Texture);
|
|
|
|
ERR_FAIL_COND_V(!texture,RID());
|
|
|
|
glGenTextures(1, &texture->tex_id);
|
|
|
|
texture->active=false;
|
|
|
|
texture->total_data_size=0;
|
|
|
|
|
|
|
|
return texture_owner.make_rid( texture );
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
GLenum internal_format;
|
|
|
|
GLenum type;
|
|
|
|
|
|
|
|
bool compressed;
|
|
|
|
bool srgb;
|
|
|
|
|
|
|
|
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 );
|
|
|
|
ERR_FAIL_COND(!texture);
|
|
|
|
texture->width=p_width;
|
|
|
|
texture->height=p_height;
|
|
|
|
texture->format=p_format;
|
|
|
|
texture->flags=p_flags;
|
2016-10-27 14:50:26 +00:00
|
|
|
texture->stored_cube_sides=0;
|
2016-10-03 19:33:42 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glBindTexture(texture->target, texture->tex_id);
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
texture->active=true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side) {
|
|
|
|
|
|
|
|
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() );
|
|
|
|
|
|
|
|
GLenum type;
|
|
|
|
GLenum format;
|
|
|
|
GLenum internal_format;
|
|
|
|
bool compressed;
|
|
|
|
bool srgb;
|
|
|
|
|
|
|
|
|
2016-12-23 03:37:38 +00:00
|
|
|
if (config.keep_original_textures && !(texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
|
|
|
|
texture->images[p_cube_side]=p_image;
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
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)) {
|
|
|
|
|
|
|
|
texture->alloc_height = MAX(1,texture->alloc_height/2);
|
|
|
|
texture->alloc_width = MAX(1,texture->alloc_width/2);
|
|
|
|
|
|
|
|
if (texture->alloc_width == img.get_width()/2 && texture->alloc_height == img.get_height()/2) {
|
|
|
|
|
|
|
|
img.shrink_x2();
|
|
|
|
} else if (img.get_format() <= Image::FORMAT_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;
|
|
|
|
|
|
|
|
texture->data_size=img.get_data().size();
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Read read = img.get_data().read();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glBindTexture(texture->target, texture->tex_id);
|
|
|
|
|
|
|
|
texture->ignore_mipmaps = compressed && !img.has_mipmaps();
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps)
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,config.use_fast_texture_filter?GL_LINEAR_MIPMAP_NEAREST:GL_LINEAR_MIPMAP_LINEAR);
|
|
|
|
else {
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
|
|
|
|
} else {
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (config.srgb_decode_supported && srgb) {
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
|
|
|
|
|
|
|
|
glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
|
2016-10-29 23:48:09 +00:00
|
|
|
texture->using_srgb=true;
|
2016-10-03 19:33:42 +00:00
|
|
|
} else {
|
|
|
|
glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
|
2016-10-29 23:48:09 +00:00
|
|
|
texture->using_srgb=false;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
|
|
|
|
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_NEAREST); // raw Filtering
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((texture->flags&VS::TEXTURE_FLAG_REPEAT || texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT) && texture->target != GL_TEXTURE_CUBE_MAP) {
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT){
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT );
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT );
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
//glTexParameterf( texture->target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
|
|
|
|
glTexParameterf( texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
|
|
|
glTexParameterf( texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
|
|
|
}
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
//set swizle for older format compatibility
|
|
|
|
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);
|
|
|
|
|
|
|
|
} 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);
|
|
|
|
} 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);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
if (config.use_anisotropic_filter) {
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) {
|
|
|
|
|
|
|
|
glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, config.anisotropic_level);
|
|
|
|
} else {
|
|
|
|
glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, 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 tsize=0;
|
|
|
|
for(int i=0;i<mipmaps;i++) {
|
|
|
|
|
|
|
|
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);
|
2017-02-06 03:38:39 +00:00
|
|
|
glCompressedTexImage2D( blit_target, i, internal_format,w,h,0,size,&read[ofs] );
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
} 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] );
|
|
|
|
} else {
|
|
|
|
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);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
texture->stored_cube_sides|=(1<<p_cube_side);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
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)) {
|
2016-10-03 19:33:42 +00:00
|
|
|
//generate mipmaps if they were requested and the image does not contain them
|
|
|
|
glGenerateMipmap(texture->target);
|
2017-02-06 03:38:39 +00:00
|
|
|
} else if (mipmaps>1) {
|
|
|
|
glTexParameteri(texture->target, GL_TEXTURE_BASE_LEVEL, 0);
|
|
|
|
glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, mipmaps-1);
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
texture->mipmaps=mipmaps;
|
|
|
|
|
|
|
|
//texture_set_flags(p_texture,texture->flags);
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
Image RasterizerStorageGLES3::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side) const {
|
|
|
|
|
|
|
|
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());
|
|
|
|
|
2016-12-23 03:37:38 +00:00
|
|
|
if (!texture->images[p_cube_side].empty())
|
|
|
|
return texture->images[p_cube_side];
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
#ifdef GLES_OVER_GL
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t> data;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-12-21 17:20:35 +00:00
|
|
|
int data_size = Image::get_image_data_size(texture->alloc_width,texture->alloc_height,texture->format,texture->mipmaps>1?-1:0);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-12-21 17:20:35 +00:00
|
|
|
data.resize(data_size*2); //add some memory at the end, just in case for buggy drivers
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Write wb = data.write();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
|
|
|
|
glBindTexture(texture->target,texture->tex_id);
|
|
|
|
|
2016-12-21 17:20:35 +00:00
|
|
|
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
|
|
|
|
|
|
|
print_line("GET FORMAT: "+Image::get_format_name(texture->format)+" mipmaps: "+itos(texture->mipmaps));
|
|
|
|
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (texture->compressed) {
|
|
|
|
|
|
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
|
|
|
glGetCompressedTexImage(texture->target,i,&wb[ofs]);
|
|
|
|
|
|
|
|
} else {
|
2016-12-21 17:20:35 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
2016-12-21 17:20:35 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
glGetTexImage(texture->target,i,texture->gl_format_cache,texture->gl_type_cache,&wb[ofs]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
wb=PoolVector<uint8_t>::Write();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-12-21 17:20:35 +00:00
|
|
|
data.resize(data_size);
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
Image img(texture->alloc_width,texture->alloc_height,texture->mipmaps>1?true:false,texture->format,data);
|
|
|
|
|
|
|
|
return img;
|
|
|
|
#else
|
|
|
|
|
|
|
|
ERR_EXPLAIN("Sorry, It's not posible to obtain images back in OpenGL ES");
|
2016-12-23 03:37:38 +00:00
|
|
|
return Image();
|
2016-10-03 19:33:42 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::texture_set_flags(RID p_texture,uint32_t p_flags) {
|
|
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
|
|
|
if ((texture->flags&VS::TEXTURE_FLAG_REPEAT || texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT) && texture->target != GL_TEXTURE_CUBE_MAP) {
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT){
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT );
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT );
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
//glTexParameterf( texture->target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
|
|
|
|
glTexParameterf( texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
|
|
|
glTexParameterf( texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (config.use_anisotropic_filter) {
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) {
|
|
|
|
|
|
|
|
glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, config.anisotropic_level);
|
|
|
|
} else {
|
|
|
|
glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, 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);
|
|
|
|
|
|
|
|
} else{
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
|
|
|
|
} else {
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (config.srgb_decode_supported && texture->srgb) {
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
|
|
|
|
|
|
|
|
glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
|
2016-10-29 23:48:09 +00:00
|
|
|
texture->using_srgb=true;
|
2016-10-03 19:33:42 +00:00
|
|
|
} else {
|
|
|
|
glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
|
2016-10-29 23:48:09 +00:00
|
|
|
texture->using_srgb=false;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
|
|
|
|
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_NEAREST); // raw Filtering
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
uint32_t RasterizerStorageGLES3::texture_get_flags(RID p_texture) const {
|
|
|
|
|
|
|
|
Texture * texture = texture_owner.get(p_texture);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V(!texture,0);
|
|
|
|
|
|
|
|
return texture->height;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::texture_set_size_override(RID p_texture,int p_width, int p_height) {
|
|
|
|
|
|
|
|
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);
|
|
|
|
//real texture size is in alloc width and 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);
|
|
|
|
ERR_FAIL_COND(!texture);
|
|
|
|
|
|
|
|
texture->path=p_path;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
String RasterizerStorageGLES3::texture_get_path(RID p_texture) const{
|
|
|
|
|
|
|
|
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){
|
|
|
|
|
|
|
|
List<RID> textures;
|
|
|
|
texture_owner.get_owned_list(&textures);
|
|
|
|
|
|
|
|
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;
|
|
|
|
r_info->push_back(tinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::texture_set_shrink_all_x2_on_set_data(bool p_enable) {
|
|
|
|
|
|
|
|
config.shrink_textures_x2=p_enable;
|
|
|
|
}
|
|
|
|
|
2016-12-23 03:37:38 +00:00
|
|
|
void RasterizerStorageGLES3::textures_keep_original(bool p_enable) {
|
|
|
|
|
|
|
|
config.keep_original_textures=p_enable;
|
|
|
|
}
|
|
|
|
|
2017-02-06 03:38:39 +00:00
|
|
|
void RasterizerStorageGLES3::texture_set_detect_3d_callback(RID p_texture,VisualServer::TextureDetectCallback p_callback,void* p_userdata) {
|
|
|
|
|
|
|
|
Texture * texture = texture_owner.get(p_texture);
|
|
|
|
ERR_FAIL_COND(!texture);
|
|
|
|
|
|
|
|
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);
|
|
|
|
ERR_FAIL_COND(!texture);
|
|
|
|
|
|
|
|
texture->detect_srgb=p_callback;
|
|
|
|
texture->detect_srgb_ud=p_userdata;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source,int p_resolution) const {
|
2016-10-21 10:27:13 +00:00
|
|
|
|
|
|
|
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=true;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
glActiveTexture(GL_TEXTURE0);
|
2016-10-21 10:27:13 +00:00
|
|
|
glBindTexture(texture->target, texture->tex_id);
|
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
if (config.srgb_decode_supported && texture->srgb && !texture->using_srgb) {
|
|
|
|
|
|
|
|
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;
|
|
|
|
//notify that texture must be set to linear beforehand, so it works in other platforms when exported
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
glActiveTexture(GL_TEXTURE1);
|
2016-10-21 10:27:13 +00:00
|
|
|
GLuint new_cubemap;
|
|
|
|
glGenTextures(1, &new_cubemap);
|
2016-10-27 14:50:26 +00:00
|
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, new_cubemap);
|
2016-10-21 10:27:13 +00:00
|
|
|
|
|
|
|
|
|
|
|
GLuint tmp_fb;
|
|
|
|
|
|
|
|
glGenFramebuffers(1, &tmp_fb);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb);
|
|
|
|
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
int size = p_resolution;
|
2016-10-21 10:27:13 +00:00
|
|
|
|
|
|
|
int lod=0;
|
|
|
|
|
|
|
|
shaders.cubemap_filter.bind();
|
|
|
|
|
|
|
|
int mipmaps=6;
|
|
|
|
|
|
|
|
int mm_level=mipmaps;
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
while(mm_level) {
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
|
|
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1);
|
|
|
|
|
|
|
|
lod=0;
|
|
|
|
mm_level=mipmaps;
|
|
|
|
|
|
|
|
size = p_resolution;
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,false);
|
|
|
|
|
2016-10-21 10:27:13 +00:00
|
|
|
while(mm_level) {
|
|
|
|
|
|
|
|
for(int i=0;i<6;i++) {
|
2016-10-27 14:50:26 +00:00
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _cube_side_enum[i], new_cubemap, lod);
|
2016-10-21 10:27:13 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
glViewport(0,0,size,size);
|
2016-10-21 10:27:13 +00:00
|
|
|
glBindVertexArray(resources.quadie_array);
|
|
|
|
|
|
|
|
shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::FACE_ID,i);
|
2016-10-27 14:50:26 +00:00
|
|
|
shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,lod/float(mipmaps-1));
|
2016-10-21 10:27:13 +00:00
|
|
|
|
|
|
|
|
|
|
|
glDrawArrays(GL_TRIANGLE_FAN,0,4);
|
|
|
|
glBindVertexArray(0);
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
|
|
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
|
|
ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
if (size>1)
|
|
|
|
size>>=1;
|
2016-10-21 10:27:13 +00:00
|
|
|
lod++;
|
|
|
|
mm_level--;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
//restore ranges
|
|
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
|
|
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1);
|
2016-10-21 10:27:13 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
|
|
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
|
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
2016-10-21 10:27:13 +00:00
|
|
|
|
2017-01-07 08:33:11 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2016-10-21 10:27:13 +00:00
|
|
|
glDeleteFramebuffers(1, &tmp_fb);
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
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);
|
2016-10-21 10:27:13 +00:00
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
RID RasterizerStorageGLES3::skybox_create() {
|
|
|
|
|
|
|
|
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){
|
|
|
|
|
|
|
|
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=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));
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
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);
|
|
|
|
|
|
|
|
GLuint tmp_fb;
|
|
|
|
|
|
|
|
glGenFramebuffers(1, &tmp_fb);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb);
|
|
|
|
|
|
|
|
|
|
|
|
int size = p_radiance_size;
|
|
|
|
|
|
|
|
int lod=0;
|
|
|
|
|
|
|
|
|
|
|
|
int mipmaps=6;
|
|
|
|
|
|
|
|
int mm_level=mipmaps;
|
|
|
|
|
|
|
|
bool use_float=true;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
while(mm_level) {
|
|
|
|
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, lod, internal_format, size, size*2, 0, format, type, NULL);
|
|
|
|
lod++;
|
|
|
|
mm_level--;
|
|
|
|
|
|
|
|
if (size>1)
|
|
|
|
size>>=1;
|
|
|
|
}
|
|
|
|
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod-1);
|
|
|
|
|
|
|
|
lod=0;
|
|
|
|
mm_level=mipmaps;
|
|
|
|
|
|
|
|
size = p_radiance_size;
|
|
|
|
|
|
|
|
shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,true);
|
|
|
|
shaders.cubemap_filter.bind();
|
|
|
|
|
|
|
|
while(mm_level) {
|
|
|
|
|
|
|
|
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);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
|
|
|
|
|
|
|
glDrawArrays(GL_TRIANGLE_FAN,0,4);
|
|
|
|
glBindVertexArray(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size>1)
|
|
|
|
size>>=1;
|
|
|
|
lod++;
|
|
|
|
mm_level--;
|
|
|
|
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
|
|
|
2017-01-07 08:33:11 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2016-11-19 16:23:37 +00:00
|
|
|
glDeleteFramebuffers(1, &tmp_fb);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
/* SHADER API */
|
|
|
|
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::shader_create(VS::ShaderMode p_mode){
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
Shader *shader = memnew( Shader );
|
|
|
|
shader->mode=p_mode;
|
|
|
|
RID rid = shader_owner.make_rid(shader);
|
|
|
|
shader_set_mode(rid,p_mode);
|
|
|
|
_shader_make_dirty(shader);
|
|
|
|
shader->self=rid;
|
|
|
|
|
|
|
|
return rid;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::_shader_make_dirty(Shader* p_shader) {
|
|
|
|
|
|
|
|
if (p_shader->dirty_list.in_list())
|
|
|
|
return;
|
|
|
|
|
|
|
|
_shader_dirty_list.add(&p_shader->dirty_list);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::shader_set_mode(RID p_shader,VS::ShaderMode p_mode){
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
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)
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
|
|
if (shader->custom_code_id) {
|
|
|
|
|
|
|
|
shader->shader->free_custom_shader(shader->custom_code_id);
|
|
|
|
shader->custom_code_id=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
shader->mode=p_mode;
|
|
|
|
|
|
|
|
ShaderGLES3* shaders[VS::SHADER_MAX]={
|
2016-10-19 14:14:41 +00:00
|
|
|
&scene->state.scene_shader,
|
2016-10-10 21:31:01 +00:00
|
|
|
&canvas->state.canvas_shader,
|
2017-01-02 01:16:52 +00:00
|
|
|
&this->shaders.particles,
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
shader->shader=shaders[p_mode];
|
|
|
|
|
|
|
|
shader->custom_code_id = shader->shader->create_custom_shader();
|
|
|
|
|
|
|
|
_shader_make_dirty(shader);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
VS::ShaderMode RasterizerStorageGLES3::shader_get_mode(RID p_shader) const {
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
const Shader *shader=shader_owner.get(p_shader);
|
|
|
|
ERR_FAIL_COND_V(!shader,VS::SHADER_MAX);
|
|
|
|
|
|
|
|
return shader->mode;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::shader_set_code(RID p_shader, const String& p_code){
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
Shader *shader=shader_owner.get(p_shader);
|
|
|
|
ERR_FAIL_COND(!shader);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
shader->code=p_code;
|
|
|
|
_shader_make_dirty(shader);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
String RasterizerStorageGLES3::shader_get_code(RID p_shader) const{
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
const Shader *shader=shader_owner.get(p_shader);
|
|
|
|
ERR_FAIL_COND_V(!shader,String());
|
|
|
|
|
|
|
|
|
|
|
|
return shader->code;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
void RasterizerStorageGLES3::_update_shader(Shader* p_shader) const {
|
|
|
|
|
|
|
|
|
|
|
|
_shader_dirty_list.remove( &p_shader->dirty_list );
|
|
|
|
|
|
|
|
p_shader->valid=false;
|
|
|
|
|
|
|
|
p_shader->uniforms.clear();
|
|
|
|
|
|
|
|
ShaderCompilerGLES3::GeneratedCode gen_code;
|
|
|
|
ShaderCompilerGLES3::IdentifierActions *actions=NULL;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
actions=&shaders.actions_canvas;
|
|
|
|
actions->uniforms=&p_shader->uniforms;
|
|
|
|
|
|
|
|
} break;
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
case VS::SHADER_SPATIAL: {
|
|
|
|
|
|
|
|
p_shader->spatial.blend_mode=Shader::Spatial::BLEND_MODE_MIX;
|
|
|
|
p_shader->spatial.depth_draw_mode=Shader::Spatial::DEPTH_DRAW_OPAQUE;
|
|
|
|
p_shader->spatial.cull_mode=Shader::Spatial::CULL_MODE_BACK;
|
|
|
|
p_shader->spatial.uses_alpha=false;
|
2016-12-23 11:47:16 +00:00
|
|
|
p_shader->spatial.uses_discard=false;
|
2016-10-19 14:14:41 +00:00
|
|
|
p_shader->spatial.unshaded=false;
|
|
|
|
p_shader->spatial.ontop=false;
|
2016-12-03 01:23:16 +00:00
|
|
|
p_shader->spatial.uses_sss=false;
|
2016-12-23 11:47:16 +00:00
|
|
|
p_shader->spatial.uses_vertex=false;
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
shaders.actions_scene.render_mode_values["blend_add"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_ADD);
|
|
|
|
shaders.actions_scene.render_mode_values["blend_mix"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_MIX);
|
|
|
|
shaders.actions_scene.render_mode_values["blend_sub"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_SUB);
|
|
|
|
shaders.actions_scene.render_mode_values["blend_mul"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_MUL);
|
|
|
|
|
|
|
|
shaders.actions_scene.render_mode_values["depth_draw_opaque"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_OPAQUE);
|
|
|
|
shaders.actions_scene.render_mode_values["depth_draw_always"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_ALWAYS);
|
|
|
|
shaders.actions_scene.render_mode_values["depth_draw_never"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_NEVER);
|
|
|
|
shaders.actions_scene.render_mode_values["depth_draw_alpha_prepass"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS);
|
|
|
|
|
|
|
|
shaders.actions_scene.render_mode_values["cull_front"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_FRONT);
|
|
|
|
shaders.actions_scene.render_mode_values["cull_back"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_BACK);
|
2016-11-10 02:55:06 +00:00
|
|
|
shaders.actions_scene.render_mode_values["cull_disabled"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_DISABLED);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
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["ALPHA"]=&p_shader->spatial.uses_alpha;
|
2016-11-10 02:55:06 +00:00
|
|
|
shaders.actions_scene.usage_flag_pointers["VERTEX"]=&p_shader->spatial.uses_vertex;
|
2016-10-27 14:50:26 +00:00
|
|
|
|
2016-12-03 01:23:16 +00:00
|
|
|
shaders.actions_scene.usage_flag_pointers["SSS_STRENGTH"]=&p_shader->spatial.uses_sss;
|
2016-12-23 11:47:16 +00:00
|
|
|
shaders.actions_scene.usage_flag_pointers["DISCARD"]=&p_shader->spatial.uses_discard;
|
2016-12-03 01:23:16 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
actions=&shaders.actions_scene;
|
|
|
|
actions->uniforms=&p_shader->uniforms;
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
|
2017-02-06 03:38:39 +00:00
|
|
|
} break;
|
2017-01-02 01:16:52 +00:00
|
|
|
case VS::SHADER_PARTICLES: {
|
|
|
|
|
|
|
|
actions=&shaders.actions_particles;
|
|
|
|
actions->uniforms=&p_shader->uniforms;
|
2017-02-06 03:38:39 +00:00
|
|
|
} break;
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Error err = shaders.compiler.compile(p_shader->mode,p_shader->code,actions,p_shader->path,gen_code);
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
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();
|
2016-10-29 23:48:09 +00:00
|
|
|
p_shader->texture_hints=gen_code.texture_hints;
|
2016-10-10 21:31:01 +00:00
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
p_shader->uses_vertex_time=gen_code.uses_vertex_time;
|
|
|
|
p_shader->uses_fragment_time=gen_code.uses_fragment_time;
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
//all materials using this shader will have to be invalidated, unfortunately
|
|
|
|
|
|
|
|
for (SelfList<Material>* E = p_shader->materials.first();E;E=E->next() ) {
|
|
|
|
|
|
|
|
_material_make_dirty(E->self());
|
|
|
|
}
|
|
|
|
|
|
|
|
p_shader->valid=true;
|
|
|
|
p_shader->version++;
|
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::update_dirty_shaders() {
|
|
|
|
|
|
|
|
while( _shader_dirty_list.first() ) {
|
|
|
|
_update_shader(_shader_dirty_list.first()->self() );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const{
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
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;
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=shader->uniforms.front();E;E=E->next()) {
|
|
|
|
|
|
|
|
|
|
|
|
order[E->get().order]=E->key();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
for(Map<int,StringName>::Element *E=order.front();E;E=E->next()) {
|
|
|
|
|
|
|
|
PropertyInfo pi;
|
|
|
|
ShaderLanguage::ShaderNode::Uniform &u=shader->uniforms[E->get()];
|
|
|
|
pi.name=E->get();
|
|
|
|
switch(u.type) {
|
|
|
|
case ShaderLanguage::TYPE_VOID: pi.type=Variant::NIL; break;
|
|
|
|
case ShaderLanguage::TYPE_BOOL: pi.type=Variant::BOOL; break;
|
|
|
|
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]);
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_IVEC2:
|
|
|
|
case ShaderLanguage::TYPE_IVEC3:
|
|
|
|
case ShaderLanguage::TYPE_IVEC4:
|
|
|
|
case ShaderLanguage::TYPE_UVEC2:
|
|
|
|
case ShaderLanguage::TYPE_UVEC3:
|
|
|
|
case ShaderLanguage::TYPE_UVEC4: {
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
pi.type=Variant::POOL_INT_ARRAY;
|
2016-10-10 21:31:01 +00:00
|
|
|
} 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]);
|
|
|
|
}
|
|
|
|
|
|
|
|
} 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;
|
|
|
|
} else {
|
|
|
|
pi.type=Variant::PLANE;
|
|
|
|
}
|
|
|
|
} break;
|
2017-01-11 03:52:51 +00:00
|
|
|
case ShaderLanguage::TYPE_MAT2: pi.type=Variant::TRANSFORM2D; break;
|
|
|
|
case ShaderLanguage::TYPE_MAT3: pi.type=Variant::BASIS; break;
|
2016-10-10 21:31:01 +00:00
|
|
|
case ShaderLanguage::TYPE_MAT4: pi.type=Variant::TRANSFORM; break;
|
|
|
|
case ShaderLanguage::TYPE_SAMPLER2D:
|
|
|
|
case ShaderLanguage::TYPE_ISAMPLER2D:
|
|
|
|
case ShaderLanguage::TYPE_USAMPLER2D: {
|
|
|
|
|
|
|
|
pi.type=Variant::OBJECT;
|
|
|
|
pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
|
|
|
|
pi.hint_string="Texture";
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_SAMPLERCUBE: {
|
|
|
|
|
|
|
|
pi.type=Variant::OBJECT;
|
|
|
|
pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
|
|
|
|
pi.hint_string="CubeMap";
|
|
|
|
} break;
|
|
|
|
};
|
|
|
|
|
|
|
|
p_param_list->push_back(pi);
|
|
|
|
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture){
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
Shader *shader=shader_owner.get(p_shader);
|
|
|
|
ERR_FAIL_COND(!shader);
|
|
|
|
ERR_FAIL_COND(p_texture.is_valid() && !texture_owner.owns(p_texture));
|
|
|
|
|
|
|
|
if (p_texture.is_valid())
|
|
|
|
shader->default_textures[p_name]=p_texture;
|
|
|
|
else
|
|
|
|
shader->default_textures.erase(p_name);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
_shader_make_dirty(shader);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
RID RasterizerStorageGLES3::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const{
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
const Shader *shader=shader_owner.get(p_shader);
|
|
|
|
ERR_FAIL_COND_V(!shader,RID());
|
|
|
|
|
|
|
|
const Map<StringName,RID>::Element *E=shader->default_textures.find(p_name);
|
|
|
|
if (!E)
|
|
|
|
return RID();
|
|
|
|
return E->get();
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* COMMON MATERIAL API */
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
void RasterizerStorageGLES3::_material_make_dirty(Material* p_material) const {
|
|
|
|
|
|
|
|
if (p_material->dirty_list.in_list())
|
|
|
|
return;
|
|
|
|
|
|
|
|
_material_dirty_list.add(&p_material->dirty_list);
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
RID RasterizerStorageGLES3::material_create(){
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
Material *material = memnew( Material );
|
|
|
|
|
|
|
|
return material_owner.make_rid(material);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
void RasterizerStorageGLES3::material_set_shader(RID p_material, RID p_shader){
|
|
|
|
|
|
|
|
Material *material = material_owner.get( p_material );
|
|
|
|
ERR_FAIL_COND(!material);
|
|
|
|
|
|
|
|
Shader *shader=shader_owner.getornull(p_shader);
|
|
|
|
|
|
|
|
if (material->shader) {
|
|
|
|
//if shader, remove from previous shader material list
|
|
|
|
material->shader->materials.remove( &material->list );
|
|
|
|
}
|
|
|
|
material->shader=shader;
|
|
|
|
|
|
|
|
if (shader) {
|
|
|
|
shader->materials.add(&material->list);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
_material_make_dirty(material);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::material_get_shader(RID p_material) const{
|
|
|
|
|
|
|
|
const Material *material = material_owner.get( p_material );
|
|
|
|
ERR_FAIL_COND_V(!material,RID());
|
|
|
|
|
|
|
|
if (material->shader)
|
|
|
|
return material->shader->self;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
return RID();
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value){
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
Material *material = material_owner.get( p_material );
|
|
|
|
ERR_FAIL_COND(!material);
|
|
|
|
|
|
|
|
if (p_value.get_type()==Variant::NIL)
|
|
|
|
material->params.erase(p_param);
|
|
|
|
else
|
|
|
|
material->params[p_param]=p_value;
|
|
|
|
|
|
|
|
_material_make_dirty(material);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringName& p_param) const{
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
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];
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
return Variant();
|
|
|
|
}
|
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
void RasterizerStorageGLES3::material_set_line_width(RID p_material, float p_width) {
|
|
|
|
|
|
|
|
Material *material = material_owner.get( p_material );
|
|
|
|
ERR_FAIL_COND(!material);
|
|
|
|
|
|
|
|
material->line_width=p_width;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
bool RasterizerStorageGLES3::material_is_animated(RID p_material) {
|
|
|
|
|
|
|
|
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) {
|
|
|
|
|
|
|
|
Material *material = material_owner.get( p_material );
|
|
|
|
ERR_FAIL_COND_V(!material,false);
|
|
|
|
if (material->dirty_list.in_list()) {
|
|
|
|
_update_material(material);
|
|
|
|
}
|
|
|
|
|
|
|
|
return material->can_cast_shadow_cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::material_add_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance) {
|
|
|
|
|
|
|
|
Material *material = material_owner.get( p_material );
|
|
|
|
ERR_FAIL_COND(!material);
|
|
|
|
|
|
|
|
Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.find(p_instance);
|
|
|
|
if (E) {
|
|
|
|
E->get()++;
|
|
|
|
} else {
|
|
|
|
material->instance_owners[p_instance]=1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::material_remove_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance) {
|
|
|
|
|
|
|
|
Material *material = material_owner.get( p_material );
|
|
|
|
ERR_FAIL_COND(!material);
|
|
|
|
|
|
|
|
Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.find(p_instance);
|
|
|
|
ERR_FAIL_COND(!E);
|
|
|
|
E->get()--;
|
|
|
|
|
|
|
|
if (E->get()==0) {
|
|
|
|
material->instance_owners.erase(E);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant& value, uint8_t *data,bool p_linear_color) {
|
2016-10-10 21:31:01 +00:00
|
|
|
switch(type) {
|
|
|
|
case ShaderLanguage::TYPE_BOOL: {
|
|
|
|
|
|
|
|
bool v = value;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} 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;
|
|
|
|
|
|
|
|
} 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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_INT: {
|
|
|
|
|
|
|
|
int v = value;
|
|
|
|
GLint *gui = (GLint*)data;
|
|
|
|
gui[0]=v;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_IVEC2: {
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int> iv = value;
|
2016-10-10 21:31:01 +00:00
|
|
|
int s = iv.size();
|
|
|
|
GLint *gui = (GLint*)data;
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int>::Read r = iv.read();
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
for(int i=0;i<2;i++) {
|
|
|
|
if (i<s)
|
|
|
|
gui[i]=r[i];
|
|
|
|
else
|
|
|
|
gui[i]=0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_IVEC3: {
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int> iv = value;
|
2016-10-10 21:31:01 +00:00
|
|
|
int s = iv.size();
|
|
|
|
GLint *gui = (GLint*)data;
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int>::Read r = iv.read();
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
for(int i=0;i<3;i++) {
|
|
|
|
if (i<s)
|
|
|
|
gui[i]=r[i];
|
|
|
|
else
|
|
|
|
gui[i]=0;
|
|
|
|
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_IVEC4: {
|
|
|
|
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int> iv = value;
|
2016-10-10 21:31:01 +00:00
|
|
|
int s = iv.size();
|
|
|
|
GLint *gui = (GLint*)data;
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int>::Read r = iv.read();
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
for(int i=0;i<4;i++) {
|
|
|
|
if (i<s)
|
|
|
|
gui[i]=r[i];
|
|
|
|
else
|
|
|
|
gui[i]=0;
|
|
|
|
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_UINT: {
|
|
|
|
|
|
|
|
int v = value;
|
|
|
|
GLuint *gui = (GLuint*)data;
|
|
|
|
gui[0]=v;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_UVEC2: {
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int> iv = value;
|
2016-10-10 21:31:01 +00:00
|
|
|
int s = iv.size();
|
|
|
|
GLuint *gui = (GLuint*)data;
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int>::Read r = iv.read();
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
for(int i=0;i<2;i++) {
|
|
|
|
if (i<s)
|
|
|
|
gui[i]=r[i];
|
|
|
|
else
|
|
|
|
gui[i]=0;
|
|
|
|
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_UVEC3: {
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int> iv = value;
|
2016-10-10 21:31:01 +00:00
|
|
|
int s = iv.size();
|
|
|
|
GLuint *gui = (GLuint*)data;
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int>::Read r = iv.read();
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
for(int i=0;i<3;i++) {
|
|
|
|
if (i<s)
|
|
|
|
gui[i]=r[i];
|
|
|
|
else
|
|
|
|
gui[i]=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_UVEC4: {
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int> iv = value;
|
2016-10-10 21:31:01 +00:00
|
|
|
int s = iv.size();
|
|
|
|
GLuint *gui = (GLuint*)data;
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int>::Read r = iv.read();
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
for(int i=0;i<4;i++) {
|
|
|
|
if (i<s)
|
|
|
|
gui[i]=r[i];
|
|
|
|
else
|
|
|
|
gui[i]=0;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_FLOAT: {
|
|
|
|
float v = value;
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_VEC3: {
|
|
|
|
Vector3 v = value;
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (value.get_type()==Variant::COLOR) {
|
|
|
|
Color v=value;
|
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
if (p_linear_color) {
|
|
|
|
v=v.to_linear();
|
|
|
|
}
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
gui[0]=v.r;
|
|
|
|
gui[1]=v.g;
|
2016-10-27 14:50:26 +00:00
|
|
|
gui[2]=v.b;
|
|
|
|
gui[3]=v.a;
|
2016-10-10 21:31:01 +00:00
|
|
|
} else if (value.get_type()==Variant::RECT2) {
|
|
|
|
Rect2 v=value;
|
|
|
|
|
|
|
|
gui[0]=v.pos.x;
|
|
|
|
gui[1]=v.pos.y;
|
2016-10-27 14:50:26 +00:00
|
|
|
gui[2]=v.size.x;
|
|
|
|
gui[3]=v.size.y;
|
2016-10-10 21:31:01 +00:00
|
|
|
} else if (value.get_type()==Variant::QUAT) {
|
|
|
|
Quat v=value;
|
|
|
|
|
|
|
|
gui[0]=v.x;
|
|
|
|
gui[1]=v.y;
|
2016-10-27 14:50:26 +00:00
|
|
|
gui[2]=v.z;
|
|
|
|
gui[3]=v.w;
|
2016-10-10 21:31:01 +00:00
|
|
|
} else {
|
|
|
|
Plane v=value;
|
|
|
|
|
|
|
|
gui[0]=v.normal.x;
|
|
|
|
gui[1]=v.normal.y;
|
2016-10-27 14:50:26 +00:00
|
|
|
gui[2]=v.normal.x;
|
|
|
|
gui[3]=v.d;
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_MAT2: {
|
2017-01-11 03:52:51 +00:00
|
|
|
Transform2D v = value;
|
2016-10-10 21:31:01 +00:00
|
|
|
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];
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_MAT3: {
|
|
|
|
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Basis v = value;
|
2016-10-10 21:31:01 +00:00
|
|
|
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;
|
|
|
|
} break;
|
|
|
|
default: {}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value>& value, uint8_t *data) {
|
|
|
|
|
|
|
|
switch(type) {
|
|
|
|
case ShaderLanguage::TYPE_BOOL: {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} 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;
|
|
|
|
|
|
|
|
} 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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_INT: {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_IVEC3: {
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_UINT: {
|
|
|
|
|
|
|
|
|
|
|
|
GLuint *gui = (GLuint*)data;
|
|
|
|
gui[0]=value[0].uint;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_UVEC2: {
|
|
|
|
|
|
|
|
GLint *gui = (GLint*)data;
|
|
|
|
|
|
|
|
for(int i=0;i<2;i++) {
|
|
|
|
gui[i]=value[i].uint;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_UVEC3: {
|
|
|
|
GLint *gui = (GLint*)data;
|
|
|
|
|
|
|
|
for(int i=0;i<3;i++) {
|
|
|
|
gui[i]=value[i].uint;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_UVEC4: {
|
|
|
|
GLint *gui = (GLint*)data;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_VEC2: {
|
|
|
|
|
|
|
|
GLfloat *gui = (GLfloat*)data;
|
|
|
|
|
|
|
|
for(int i=0;i<2;i++) {
|
|
|
|
gui[i]=value[i].real;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_VEC3: {
|
|
|
|
|
|
|
|
GLfloat *gui = (GLfloat*)data;
|
|
|
|
|
|
|
|
for(int i=0;i<3;i++) {
|
|
|
|
gui[i]=value[i].real;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_VEC4: {
|
|
|
|
|
|
|
|
GLfloat *gui = (GLfloat*)data;
|
|
|
|
|
|
|
|
for(int i=0;i<4;i++) {
|
|
|
|
gui[i]=value[i].real;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_MAT2: {
|
|
|
|
GLfloat *gui = (GLfloat*)data;
|
|
|
|
|
|
|
|
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;
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_MAT4: {
|
|
|
|
|
|
|
|
GLfloat *gui = (GLfloat*)data;
|
|
|
|
|
|
|
|
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) {
|
|
|
|
|
|
|
|
case ShaderLanguage::TYPE_BOOL:
|
|
|
|
case ShaderLanguage::TYPE_INT:
|
|
|
|
case ShaderLanguage::TYPE_UINT:
|
|
|
|
case ShaderLanguage::TYPE_FLOAT: {
|
|
|
|
zeromem(data,4);
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_BVEC2:
|
|
|
|
case ShaderLanguage::TYPE_IVEC2:
|
|
|
|
case ShaderLanguage::TYPE_UVEC2:
|
|
|
|
case ShaderLanguage::TYPE_VEC2: {
|
|
|
|
zeromem(data,8);
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_BVEC3:
|
|
|
|
case ShaderLanguage::TYPE_IVEC3:
|
|
|
|
case ShaderLanguage::TYPE_UVEC3:
|
|
|
|
case ShaderLanguage::TYPE_VEC3:
|
|
|
|
case ShaderLanguage::TYPE_BVEC4:
|
|
|
|
case ShaderLanguage::TYPE_IVEC4:
|
|
|
|
case ShaderLanguage::TYPE_UVEC4:
|
|
|
|
case ShaderLanguage::TYPE_VEC4:
|
|
|
|
case ShaderLanguage::TYPE_MAT2:{
|
|
|
|
|
|
|
|
zeromem(data,16);
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_MAT3:{
|
|
|
|
|
|
|
|
zeromem(data,48);
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::TYPE_MAT4:{
|
|
|
|
zeromem(data,64);
|
|
|
|
} break;
|
|
|
|
|
|
|
|
default: {}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::_update_material(Material* material) {
|
|
|
|
|
|
|
|
if (material->dirty_list.in_list())
|
|
|
|
_material_dirty_list.remove( &material->dirty_list );
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
if (material->shader && material->shader->dirty_list.in_list()) {
|
|
|
|
_update_shader(material->shader);
|
|
|
|
}
|
|
|
|
//update caches
|
|
|
|
|
|
|
|
{
|
|
|
|
bool can_cast_shadow = false;
|
|
|
|
bool is_animated = false;
|
|
|
|
|
|
|
|
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_discard && material->shader->uses_fragment_time) {
|
|
|
|
is_animated=true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (material->shader->spatial.uses_vertex && material->shader->uses_vertex_time) {
|
|
|
|
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;
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
for(Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) {
|
|
|
|
E->key()->material_changed_notify();
|
2016-11-10 02:55:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for(Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.front();E;E=E->next()) {
|
|
|
|
E->key()->base_material_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
//clear ubo if it needs to be cleared
|
|
|
|
if (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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//create ubo if it needs to be created
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
//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);
|
|
|
|
|
|
|
|
for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) {
|
|
|
|
|
|
|
|
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] ];
|
|
|
|
|
|
|
|
Map<StringName,Variant>::Element *V = material->params.find(E->key());
|
|
|
|
|
|
|
|
if (V) {
|
2016-11-19 16:23:37 +00:00
|
|
|
//user provided
|
2016-10-29 23:48:09 +00:00
|
|
|
_fill_std140_variant_ubo_value(E->get().type,V->get(),data,material->shader->mode==VS::SHADER_SPATIAL);
|
2016-11-21 01:49:53 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
} else if (E->get().default_value.size()){
|
|
|
|
//default value
|
|
|
|
_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);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
glBindBuffer(GL_UNIFORM_BUFFER,material->ubo_id);
|
|
|
|
glBufferSubData(GL_UNIFORM_BUFFER, 0, material->ubo_size, local_ubo);
|
|
|
|
glBindBuffer(GL_UNIFORM_BUFFER, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
//set up the texture array, for easy access when it needs to be drawn
|
|
|
|
if (material->shader && material->shader->texture_count) {
|
|
|
|
|
|
|
|
material->textures.resize(material->shader->texture_count);
|
|
|
|
|
|
|
|
for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) {
|
|
|
|
|
|
|
|
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());
|
|
|
|
if (V) {
|
|
|
|
texture=V->get();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!texture.is_valid()) {
|
|
|
|
Map<StringName,RID>::Element *W = material->shader->default_textures.find(E->key());
|
|
|
|
if (W) {
|
|
|
|
texture=W->get();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
material->textures[ E->get().texture_order ]=texture;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
material->textures.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
void RasterizerStorageGLES3::_material_add_geometry(RID p_material,Geometry *p_geometry) {
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
Material * material = material_owner.getornull(p_material);
|
|
|
|
ERR_FAIL_COND(!material);
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry);
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
if (I) {
|
|
|
|
I->get()++;
|
|
|
|
} else {
|
2016-11-24 23:46:55 +00:00
|
|
|
material->geometry_owners[p_geometry]=1;
|
2016-11-10 02:55:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
void RasterizerStorageGLES3::_material_remove_geometry(RID p_material,Geometry *p_geometry) {
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
Material * material = material_owner.getornull(p_material);
|
|
|
|
ERR_FAIL_COND(!material);
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry);
|
2016-11-10 02:55:06 +00:00
|
|
|
ERR_FAIL_COND(!I);
|
|
|
|
|
|
|
|
I->get()--;
|
|
|
|
if (I->get()==0) {
|
2016-11-24 23:46:55 +00:00
|
|
|
material->geometry_owners.erase(I);
|
2016-11-10 02:55:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
void RasterizerStorageGLES3::update_dirty_materials() {
|
|
|
|
|
|
|
|
while( _material_dirty_list.first() ) {
|
|
|
|
|
|
|
|
Material *material = _material_dirty_list.first()->self();
|
|
|
|
|
|
|
|
_update_material(material);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
/* MESH API */
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::mesh_create(){
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Mesh * mesh = memnew( Mesh );
|
|
|
|
|
|
|
|
return mesh_owner.make_rid(mesh);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
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){
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-02-06 23:18:35 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t> array = p_array;
|
2016-12-25 11:05:23 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND(!mesh);
|
|
|
|
|
|
|
|
ERR_FAIL_COND(!(p_format&VS::ARRAY_FORMAT_VERTEX));
|
|
|
|
|
|
|
|
//must have index and bones, both.
|
|
|
|
{
|
|
|
|
uint32_t bones_weight = VS::ARRAY_FORMAT_BONES|VS::ARRAY_FORMAT_WEIGHTS;
|
|
|
|
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 );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
//bool has_morph = p_blend_shapes.size();
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
Surface::Attrib attribs[VS::ARRAY_MAX];
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
int stride=0;
|
|
|
|
|
|
|
|
for(int i=0;i<VS::ARRAY_MAX;i++) {
|
|
|
|
|
2016-12-24 19:23:30 +00:00
|
|
|
attribs[i].index=i;
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
if (! (p_format&(1<<i) ) ) {
|
|
|
|
attribs[i].enabled=false;
|
2016-11-21 22:03:39 +00:00
|
|
|
attribs[i].integer=false;
|
2016-10-19 14:14:41 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
attribs[i].enabled=true;
|
|
|
|
attribs[i].offset=stride;
|
2016-11-21 22:03:39 +00:00
|
|
|
attribs[i].integer=false;
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
switch(i) {
|
|
|
|
|
|
|
|
case VS::ARRAY_VERTEX: {
|
|
|
|
|
|
|
|
if (p_format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
|
|
|
|
attribs[i].size=2;
|
|
|
|
} else {
|
2016-12-24 19:23:30 +00:00
|
|
|
attribs[i].size=(p_format&VS::ARRAY_COMPRESS_VERTEX)?4:3;
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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].normalized=GL_FALSE;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_NORMAL: {
|
|
|
|
|
|
|
|
attribs[i].size=3;
|
|
|
|
|
|
|
|
if (p_format&VS::ARRAY_COMPRESS_NORMAL) {
|
|
|
|
attribs[i].type=GL_BYTE;
|
|
|
|
stride+=4; //pad extra byte
|
|
|
|
attribs[i].normalized=GL_TRUE;
|
|
|
|
} else {
|
|
|
|
attribs[i].type=GL_FLOAT;
|
|
|
|
stride+=12;
|
|
|
|
attribs[i].normalized=GL_FALSE;
|
|
|
|
}
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_TANGENT: {
|
|
|
|
|
|
|
|
attribs[i].size=4;
|
|
|
|
|
|
|
|
if (p_format&VS::ARRAY_COMPRESS_TANGENT) {
|
|
|
|
attribs[i].type=GL_BYTE;
|
|
|
|
stride+=4;
|
|
|
|
attribs[i].normalized=GL_TRUE;
|
|
|
|
} else {
|
|
|
|
attribs[i].type=GL_FLOAT;
|
|
|
|
stride+=16;
|
|
|
|
attribs[i].normalized=GL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_COLOR: {
|
|
|
|
|
|
|
|
attribs[i].size=4;
|
|
|
|
|
|
|
|
if (p_format&VS::ARRAY_COMPRESS_COLOR) {
|
|
|
|
attribs[i].type=GL_UNSIGNED_BYTE;
|
|
|
|
stride+=4;
|
|
|
|
attribs[i].normalized=GL_TRUE;
|
|
|
|
} else {
|
|
|
|
attribs[i].type=GL_FLOAT;
|
|
|
|
stride+=16;
|
|
|
|
attribs[i].normalized=GL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_TEX_UV: {
|
|
|
|
|
|
|
|
attribs[i].size=2;
|
|
|
|
|
|
|
|
if (p_format&VS::ARRAY_COMPRESS_TEX_UV) {
|
|
|
|
attribs[i].type=GL_HALF_FLOAT;
|
|
|
|
stride+=4;
|
|
|
|
} else {
|
|
|
|
attribs[i].type=GL_FLOAT;
|
|
|
|
stride+=8;
|
|
|
|
}
|
|
|
|
|
|
|
|
attribs[i].normalized=GL_FALSE;
|
|
|
|
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_TEX_UV2: {
|
|
|
|
|
|
|
|
attribs[i].size=2;
|
|
|
|
|
|
|
|
if (p_format&VS::ARRAY_COMPRESS_TEX_UV2) {
|
|
|
|
attribs[i].type=GL_HALF_FLOAT;
|
|
|
|
stride+=4;
|
|
|
|
} else {
|
|
|
|
attribs[i].type=GL_FLOAT;
|
|
|
|
stride+=8;
|
|
|
|
}
|
|
|
|
attribs[i].normalized=GL_FALSE;
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_BONES: {
|
|
|
|
|
|
|
|
attribs[i].size=4;
|
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
if (p_format&VS::ARRAY_FLAG_USE_16_BIT_BONES) {
|
2016-10-19 14:14:41 +00:00
|
|
|
attribs[i].type=GL_UNSIGNED_SHORT;
|
|
|
|
stride+=8;
|
2016-11-21 22:03:39 +00:00
|
|
|
} else {
|
|
|
|
attribs[i].type=GL_UNSIGNED_BYTE;
|
|
|
|
stride+=4;
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
attribs[i].normalized=GL_FALSE;
|
2016-11-21 22:03:39 +00:00
|
|
|
attribs[i].integer=true;
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_WEIGHTS: {
|
|
|
|
|
|
|
|
attribs[i].size=4;
|
|
|
|
|
|
|
|
if (p_format&VS::ARRAY_COMPRESS_WEIGHTS) {
|
|
|
|
|
|
|
|
attribs[i].type=GL_UNSIGNED_SHORT;
|
|
|
|
stride+=8;
|
|
|
|
attribs[i].normalized=GL_TRUE;
|
|
|
|
} else {
|
|
|
|
attribs[i].type=GL_FLOAT;
|
|
|
|
stride+=16;
|
|
|
|
attribs[i].normalized=GL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_INDEX: {
|
|
|
|
|
|
|
|
attribs[i].size=1;
|
|
|
|
|
|
|
|
if (p_vertex_count>=(1<<16)) {
|
|
|
|
attribs[i].type=GL_UNSIGNED_INT;
|
|
|
|
attribs[i].stride=4;
|
|
|
|
} else {
|
|
|
|
attribs[i].type=GL_UNSIGNED_SHORT;
|
|
|
|
attribs[i].stride=2;
|
|
|
|
}
|
|
|
|
|
|
|
|
attribs[i].normalized=GL_FALSE;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for(int i=0;i<VS::ARRAY_MAX-1;i++) {
|
|
|
|
attribs[i].stride=stride;
|
|
|
|
}
|
|
|
|
|
|
|
|
//validate sizes
|
|
|
|
|
|
|
|
int array_size = stride * p_vertex_count;
|
|
|
|
int index_array_size=0;
|
2016-12-25 11:05:23 +00:00
|
|
|
if (array.size()!=array_size && array.size()+p_vertex_count*2 == array_size) {
|
|
|
|
//old format, convert
|
2017-01-07 21:25:37 +00:00
|
|
|
array = PoolVector<uint8_t>();
|
2016-12-25 11:05:23 +00:00
|
|
|
|
|
|
|
array.resize( p_array.size()+p_vertex_count*2 );
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Write w = array.write();
|
|
|
|
PoolVector<uint8_t>::Read r = p_array.read();
|
2016-12-25 11:05:23 +00:00
|
|
|
|
|
|
|
uint16_t *w16 = (uint16_t*)w.ptr();
|
|
|
|
const uint16_t *r16 = (uint16_t*)r.ptr();
|
|
|
|
|
|
|
|
uint16_t one = Math::make_half_float(1);
|
|
|
|
|
|
|
|
for(int i=0;i<p_vertex_count;i++) {
|
|
|
|
|
|
|
|
*w16++ = *r16++;
|
|
|
|
*w16++ = *r16++;
|
|
|
|
*w16++ = *r16++;
|
|
|
|
*w16++ = one;
|
|
|
|
for(int j=0;j<(stride/2)-4;j++) {
|
|
|
|
*w16++ = *r16++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
ERR_FAIL_COND(array.size()!=array_size);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
if (p_format&VS::ARRAY_FORMAT_INDEX) {
|
|
|
|
|
|
|
|
index_array_size=attribs[VS::ARRAY_INDEX].stride*p_index_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ERR_FAIL_COND(p_index_array.size()!=index_array_size);
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
ERR_FAIL_COND(p_blend_shapes.size()!=mesh->blend_shape_count);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
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;
|
2016-12-25 11:05:23 +00:00
|
|
|
surface->array_byte_size=array.size();
|
2016-11-10 02:55:06 +00:00
|
|
|
surface->index_array_byte_size=p_index_array.size();
|
2016-10-19 14:14:41 +00:00
|
|
|
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();
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for(int i=0;i<VS::ARRAY_MAX;i++) {
|
|
|
|
surface->attribs[i]=attribs[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Read vr = array.read();
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
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) {
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Read ir = p_index_array.read();
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
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
|
2016-12-24 19:23:30 +00:00
|
|
|
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
//generate arrays for faster state switching
|
|
|
|
|
2016-12-24 19:23:30 +00:00
|
|
|
for(int ai=0;ai<2;ai++) {
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-12-24 19:23:30 +00:00
|
|
|
if (ai==0) {
|
2016-11-22 04:26:56 +00:00
|
|
|
//for normal draw
|
|
|
|
glGenVertexArrays(1,&surface->array_id);
|
|
|
|
glBindVertexArray(surface->array_id);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
|
2016-12-24 19:23:30 +00:00
|
|
|
} else if (ai==1) {
|
2016-11-22 04:26:56 +00:00
|
|
|
//for instancing draw (can be changed and no one cares)
|
|
|
|
glGenVertexArrays(1,&surface->instancing_array_id);
|
|
|
|
glBindVertexArray(surface->instancing_array_id);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
} else {
|
|
|
|
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);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
}
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
if (surface->index_id) {
|
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
|
|
|
|
}
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
glBindVertexArray(0);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
|
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
|
|
|
|
//blend shapes
|
|
|
|
|
|
|
|
for(int i=0;i<p_blend_shapes.size();i++) {
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
Surface::BlendShape mt;
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Read vr = p_blend_shapes[i].read();
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
glBindVertexArray(mt.array_id);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,mt.vertex_id);
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
for(int j=0;j<VS::ARRAY_MAX-1;j++) {
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
if (!attribs[j].enabled)
|
2016-10-19 14:14:41 +00:00
|
|
|
continue;
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
if (attribs[j].integer) {
|
|
|
|
glVertexAttribIPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].stride,((uint8_t*)0)+attribs[j].offset);
|
2016-11-21 22:03:39 +00:00
|
|
|
} else {
|
2016-11-24 23:46:55 +00:00
|
|
|
glVertexAttribPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].normalized,attribs[j].stride,((uint8_t*)0)+attribs[j].offset);
|
2016-11-21 22:03:39 +00:00
|
|
|
}
|
2016-11-24 23:46:55 +00:00
|
|
|
glEnableVertexAttribArray(attribs[j].index);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
glBindVertexArray(0);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
surface->blend_shapes.push_back(mt);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mesh->surfaces.push_back(surface);
|
|
|
|
mesh->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
void RasterizerStorageGLES3::mesh_set_blend_shape_count(RID p_mesh,int p_amount){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND(!mesh);
|
|
|
|
|
|
|
|
|
|
|
|
ERR_FAIL_COND(mesh->surfaces.size()!=0);
|
|
|
|
ERR_FAIL_COND(p_amount<0);
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
mesh->blend_shape_count=p_amount;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2017-01-12 11:34:00 +00:00
|
|
|
int RasterizerStorageGLES3::mesh_get_blend_shape_count(RID p_mesh) const{
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND_V(!mesh,0);
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
return mesh->blend_shape_count;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
void RasterizerStorageGLES3::mesh_set_blend_shape_mode(RID p_mesh,VS::BlendShapeMode p_mode){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND(!mesh);
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
mesh->blend_shape_mode=p_mode;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2017-01-12 11:34:00 +00:00
|
|
|
VS::BlendShapeMode RasterizerStorageGLES3::mesh_get_blend_shape_mode(RID p_mesh) const{
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
2017-01-12 11:34:00 +00:00
|
|
|
ERR_FAIL_COND_V(!mesh,VS::BLEND_SHAPE_MODE_NORMALIZED);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
return mesh->blend_shape_mode;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material){
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND(!mesh);
|
|
|
|
ERR_FAIL_INDEX(p_surface,mesh->surfaces.size());
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
if (mesh->surfaces[p_surface]->material==p_material)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (mesh->surfaces[p_surface]->material.is_valid()) {
|
2016-11-24 23:46:55 +00:00
|
|
|
_material_remove_geometry(mesh->surfaces[p_surface]->material,mesh->surfaces[p_surface]);
|
2016-11-10 02:55:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
mesh->surfaces[p_surface]->material=p_material;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
if (mesh->surfaces[p_surface]->material.is_valid()) {
|
2016-11-24 23:46:55 +00:00
|
|
|
_material_add_geometry(mesh->surfaces[p_surface]->material,mesh->surfaces[p_surface]);
|
2016-11-10 02:55:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mesh->instance_material_change_notify();
|
|
|
|
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
RID RasterizerStorageGLES3::mesh_surface_get_material(RID p_mesh, int p_surface) const{
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND_V(!mesh,RID());
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),RID());
|
|
|
|
|
|
|
|
return mesh->surfaces[p_surface]->material;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int RasterizerStorageGLES3::mesh_surface_get_array_len(RID p_mesh, int p_surface) const{
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND_V(!mesh,0);
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
|
|
|
|
|
|
|
|
return mesh->surfaces[p_surface]->array_len;
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
int RasterizerStorageGLES3::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const{
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND_V(!mesh,0);
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
return mesh->surfaces[p_surface]->index_array_len;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, int p_surface) const{
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
2017-01-07 21:25:37 +00:00
|
|
|
ERR_FAIL_COND_V(!mesh,PoolVector<uint8_t>());
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),PoolVector<uint8_t>());
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
Surface *surface = mesh->surfaces[p_surface];
|
|
|
|
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
|
2016-11-10 02:55:06 +00:00
|
|
|
void * data = glMapBufferRange(GL_ARRAY_BUFFER,0,surface->array_byte_size,GL_MAP_READ_BIT);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
ERR_FAIL_COND_V(!data,PoolVector<uint8_t>());
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t> ret;
|
2016-11-10 02:55:06 +00:00
|
|
|
ret.resize(surface->array_byte_size);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
{
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Write w = ret.write();
|
2016-11-10 02:55:06 +00:00
|
|
|
copymem(w.ptr(),data,surface->array_byte_size);
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
glUnmapBuffer(GL_ARRAY_BUFFER);
|
|
|
|
|
|
|
|
|
|
|
|
return ret;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_mesh, int p_surface) const {
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
2017-01-07 21:25:37 +00:00
|
|
|
ERR_FAIL_COND_V(!mesh,PoolVector<uint8_t>());
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),PoolVector<uint8_t>());
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
Surface *surface = mesh->surfaces[p_surface];
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
ERR_FAIL_COND_V(surface->index_array_len==0,PoolVector<uint8_t>());
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
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);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
ERR_FAIL_COND_V(!data,PoolVector<uint8_t>());
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t> ret;
|
2016-11-10 02:55:06 +00:00
|
|
|
ret.resize(surface->index_array_byte_size);
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
{
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Write w = ret.write();
|
2016-11-10 02:55:06 +00:00
|
|
|
copymem(w.ptr(),data,surface->index_array_byte_size);
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
return ret;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
uint32_t RasterizerStorageGLES3::mesh_surface_get_format(RID p_mesh, int p_surface) const{
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V(!mesh,0);
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
|
|
|
|
|
|
|
|
return mesh->surfaces[p_surface]->format;
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const{
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND_V(!mesh,VS::PRIMITIVE_MAX);
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),VS::PRIMITIVE_MAX);
|
|
|
|
|
|
|
|
return mesh->surfaces[p_surface]->primitive;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::mesh_surface_get_aabb(RID p_mesh, int p_surface) const {
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!mesh,Rect3());
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Rect3());
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
return mesh->surfaces[p_surface]->aabb;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
2017-01-07 21:25:37 +00:00
|
|
|
Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const{
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
2017-01-07 21:25:37 +00:00
|
|
|
ERR_FAIL_COND_V(!mesh,Vector<PoolVector<uint8_t> >());
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<PoolVector<uint8_t> >());
|
2016-11-10 02:55:06 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
Vector<PoolVector<uint8_t> > bsarr;
|
2016-11-10 02:55:06 +00:00
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
for(int i=0;i<mesh->surfaces[p_surface]->blend_shapes.size();i++) {
|
2016-11-10 02:55:06 +00:00
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh->surfaces[p_surface]->blend_shapes[i].vertex_id);
|
2016-11-10 02:55:06 +00:00
|
|
|
void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,mesh->surfaces[p_surface]->array_byte_size,GL_MAP_READ_BIT);
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
ERR_FAIL_COND_V(!data,Vector<PoolVector<uint8_t> >());
|
2016-11-10 02:55:06 +00:00
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t> ret;
|
2016-11-10 02:55:06 +00:00
|
|
|
ret.resize(mesh->surfaces[p_surface]->array_byte_size);
|
|
|
|
|
|
|
|
{
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<uint8_t>::Write w = ret.write();
|
2016-11-10 02:55:06 +00:00
|
|
|
copymem(w.ptr(),data,mesh->surfaces[p_surface]->array_byte_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
bsarr.push_back(ret);
|
|
|
|
|
|
|
|
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
|
|
|
|
}
|
|
|
|
|
|
|
|
return bsarr;
|
|
|
|
|
|
|
|
}
|
2017-01-11 03:52:51 +00:00
|
|
|
Vector<Rect3> RasterizerStorageGLES3::mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const{
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!mesh,Vector<Rect3 >());
|
|
|
|
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<Rect3 >());
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
return mesh->surfaces[p_surface]->skeleton_bone_aabb;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
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());
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Surface *surface = mesh->surfaces[p_surface];
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
if (surface->material.is_valid()) {
|
2016-11-24 23:46:55 +00:00
|
|
|
_material_remove_geometry(surface->material,mesh->surfaces[p_surface]);
|
2016-11-10 02:55:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
glDeleteBuffers(1,&surface->vertex_id);
|
2016-10-19 14:14:41 +00:00
|
|
|
if (surface->index_id) {
|
|
|
|
glDeleteBuffers(1,&surface->index_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
glDeleteVertexArrays(1,&surface->array_id);
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
for(int i=0;i<surface->blend_shapes.size();i++) {
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
glDeleteBuffers(1,&surface->blend_shapes[i].vertex_id);
|
|
|
|
glDeleteVertexArrays(1,&surface->blend_shapes[i].array_id);
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
mesh->instance_material_change_notify();
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
memdelete(surface);
|
|
|
|
|
|
|
|
mesh->surfaces.remove(p_surface);
|
|
|
|
|
|
|
|
mesh->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const{
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND_V(!mesh,0);
|
|
|
|
return mesh->surfaces.size();
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh,const Rect3& p_aabb){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND(!mesh);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
mesh->custom_aabb=p_aabb;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const{
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
const Mesh *mesh = mesh_owner.getornull(p_mesh);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!mesh,Rect3());
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
return mesh->custom_aabb;
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
Mesh *mesh = mesh_owner.get( p_mesh );
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!mesh,Rect3());
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
if (mesh->custom_aabb!=Rect3())
|
2016-10-19 14:14:41 +00:00
|
|
|
return mesh->custom_aabb;
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Skeleton *sk=NULL;
|
|
|
|
if (p_skeleton.is_valid())
|
|
|
|
sk=skeleton_owner.get(p_skeleton);
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 aabb;
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
if (sk && sk->size!=0) {
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
|
|
|
|
for (int i=0;i<mesh->surfaces.size();i++) {
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 laabb;
|
2016-10-19 14:14:41 +00:00
|
|
|
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();
|
2017-01-11 03:52:51 +00:00
|
|
|
const Rect3 *skbones = mesh->surfaces[i]->skeleton_bone_aabb.ptr();
|
2016-10-19 14:14:41 +00:00
|
|
|
const bool *skused = mesh->surfaces[i]->skeleton_bone_used.ptr();
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
int sbs = sk->size;
|
2016-10-19 14:14:41 +00:00
|
|
|
ERR_CONTINUE(bs>sbs);
|
2016-11-22 04:26:56 +00:00
|
|
|
float *skb = sk->bones.ptr();
|
|
|
|
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
|
|
|
|
bool first=true;
|
2016-11-22 04:26:56 +00:00
|
|
|
if (sk->use_2d) {
|
|
|
|
for(int j=0;j<bs;j++) {
|
|
|
|
|
|
|
|
if (!skused[j])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
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];
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 baabb = mtx.xform( skbones[j] );
|
2016-11-22 04:26:56 +00:00
|
|
|
if (first) {
|
|
|
|
laabb=baabb;
|
|
|
|
first=false;
|
|
|
|
} else {
|
|
|
|
laabb.merge_with(baabb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for(int j=0;j<bs;j++) {
|
|
|
|
|
|
|
|
if (!skused[j])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
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];
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 baabb = mtx.xform ( skbones[j] );
|
2016-11-22 04:26:56 +00:00
|
|
|
if (first) {
|
|
|
|
laabb=baabb;
|
|
|
|
first=false;
|
|
|
|
} else {
|
|
|
|
laabb.merge_with(baabb);
|
|
|
|
}
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
laabb=mesh->surfaces[i]->aabb;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i==0)
|
|
|
|
aabb=laabb;
|
|
|
|
else
|
|
|
|
aabb.merge_with(laabb);
|
|
|
|
}
|
|
|
|
} else {
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
for (int i=0;i<mesh->surfaces.size();i++) {
|
|
|
|
|
|
|
|
if (i==0)
|
|
|
|
aabb=mesh->surfaces[i]->aabb;
|
|
|
|
else
|
|
|
|
aabb.merge_with(mesh->surfaces[i]->aabb);
|
|
|
|
}
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
return aabb;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::mesh_clear(RID p_mesh){
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
Mesh *mesh = mesh_owner.getornull(p_mesh);
|
|
|
|
ERR_FAIL_COND(!mesh);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
while(mesh->surfaces.size()) {
|
|
|
|
mesh_remove_surface(p_mesh,0);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
void RasterizerStorageGLES3::mesh_render_blend_shapes(Surface *s, float *p_weights) {
|
|
|
|
|
|
|
|
glBindVertexArray(s->array_id);
|
|
|
|
|
|
|
|
BlendShapeShaderGLES3::Conditionals cond[VS::ARRAY_MAX-1]={
|
|
|
|
BlendShapeShaderGLES3::ENABLE_NORMAL, //will be ignored
|
|
|
|
BlendShapeShaderGLES3::ENABLE_NORMAL,
|
|
|
|
BlendShapeShaderGLES3::ENABLE_TANGENT,
|
|
|
|
BlendShapeShaderGLES3::ENABLE_COLOR,
|
|
|
|
BlendShapeShaderGLES3::ENABLE_UV,
|
|
|
|
BlendShapeShaderGLES3::ENABLE_UV2,
|
|
|
|
BlendShapeShaderGLES3::ENABLE_SKELETON,
|
|
|
|
BlendShapeShaderGLES3::ENABLE_SKELETON,
|
|
|
|
};
|
|
|
|
|
|
|
|
int stride=0;
|
|
|
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
int mtc = s->blend_shapes.size();
|
2016-11-24 23:46:55 +00:00
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
if (s->mesh->blend_shape_mode==VS::BLEND_SHAPE_MODE_NORMALIZED) {
|
2016-11-24 23:46:55 +00:00
|
|
|
|
|
|
|
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.bind();
|
|
|
|
|
|
|
|
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);
|
|
|
|
glEndTransformFeedback();
|
|
|
|
|
|
|
|
|
|
|
|
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++) {
|
|
|
|
float weight = p_weights[ti];
|
|
|
|
|
|
|
|
if (weight<0.001) //not bother with this one
|
|
|
|
continue;
|
|
|
|
|
2017-01-12 11:34:00 +00:00
|
|
|
glBindVertexArray(s->blend_shapes[ti].array_id);
|
2016-11-24 23:46:55 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
int ofs=0;
|
|
|
|
for(int i=0;i<VS::ARRAY_MAX-1;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;
|
|
|
|
} else {
|
|
|
|
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;
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_TANGENT: {
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_TEX_UV: {
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_BONES: {
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
glDisableVertexAttribArray(i+8);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
glBeginTransformFeedback(GL_POINTS);
|
|
|
|
glDrawArrays(GL_POINTS,0,s->array_len);
|
|
|
|
glEndTransformFeedback();
|
|
|
|
|
|
|
|
|
|
|
|
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++) {
|
|
|
|
|
|
|
|
if (s->format&(1<<i)) {
|
|
|
|
glEnableVertexAttribArray(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;
|
|
|
|
} else {
|
|
|
|
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;
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_TANGENT: {
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_TEX_UV: {
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case VS::ARRAY_BONES: {
|
|
|
|
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;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
glDisableVertexAttribArray(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->index_array_len) {
|
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,s->index_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
/* MULTIMESH API */
|
|
|
|
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::multimesh_create(){
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = memnew( MultiMesh );
|
|
|
|
return multimesh_owner.make_rid(multimesh);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
void RasterizerStorageGLES3::multimesh_allocate(RID p_multimesh, int p_instances, VS::MultimeshTransformFormat p_transform_format, VS::MultimeshColorFormat p_color_format){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
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)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (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;
|
|
|
|
|
|
|
|
if (multimesh->size) {
|
|
|
|
|
|
|
|
if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
|
|
|
|
multimesh->xform_floats=8;
|
|
|
|
} else {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (multimesh->color_format==VS::MULTIMESH_COLOR_NONE) {
|
|
|
|
//none
|
|
|
|
} 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;
|
|
|
|
|
|
|
|
} 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);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
multimesh->dirty_data=true;
|
|
|
|
multimesh->dirty_aabb=true;
|
|
|
|
|
|
|
|
if (!multimesh->update_list.in_list()) {
|
|
|
|
multimesh_update_list.add(&multimesh->update_list);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
int RasterizerStorageGLES3::multimesh_get_instance_count(RID p_multimesh) const{
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
|
|
|
ERR_FAIL_COND_V(!multimesh,0);
|
|
|
|
|
|
|
|
return multimesh->size;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
|
|
|
ERR_FAIL_COND(!multimesh);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
multimesh->mesh=p_mesh;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
multimesh->dirty_aabb=true;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
if (!multimesh->update_list.in_list()) {
|
|
|
|
multimesh_update_list.add(&multimesh->update_list);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
void RasterizerStorageGLES3::multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
if (!multimesh->update_list.in_list()) {
|
|
|
|
multimesh_update_list.add(&multimesh->update_list);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
void RasterizerStorageGLES3::multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Transform2D& p_transform){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
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);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
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];
|
|
|
|
|
|
|
|
multimesh->dirty_data=true;
|
|
|
|
multimesh->dirty_aabb=true;
|
|
|
|
|
|
|
|
if (!multimesh->update_list.in_list()) {
|
|
|
|
multimesh_update_list.add(&multimesh->update_list);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color){
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
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);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
int stride = multimesh->color_floats+multimesh->xform_floats;
|
2016-12-20 03:21:07 +00:00
|
|
|
float *dataptr=&multimesh->data[stride*p_index+multimesh->xform_floats];
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
|
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
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);
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
} else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
|
|
|
|
dataptr[ 0]=p_color.r;
|
|
|
|
dataptr[ 1]=p_color.g;
|
|
|
|
dataptr[ 2]=p_color.b;
|
|
|
|
dataptr[ 3]=p_color.a;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
multimesh->dirty_data=true;
|
|
|
|
multimesh->dirty_aabb=true;
|
|
|
|
|
|
|
|
if (!multimesh->update_list.in_list()) {
|
|
|
|
multimesh_update_list.add(&multimesh->update_list);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::multimesh_get_mesh(RID p_multimesh) const{
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
|
|
|
ERR_FAIL_COND_V(!multimesh,RID());
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
return multimesh->mesh;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Transform RasterizerStorageGLES3::multimesh_instance_get_transform(RID p_multimesh,int p_index) const{
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
|
|
|
ERR_FAIL_COND_V(!multimesh,Transform());
|
|
|
|
ERR_FAIL_INDEX_V(p_index,multimesh->size,Transform());
|
|
|
|
ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D,Transform());
|
|
|
|
|
|
|
|
int stride = multimesh->color_floats+multimesh->xform_floats;
|
|
|
|
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];
|
|
|
|
|
|
|
|
return xform;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2017-01-11 03:52:51 +00:00
|
|
|
Transform2D RasterizerStorageGLES3::multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const{
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
2017-01-11 03:52:51 +00:00
|
|
|
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());
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
int stride = multimesh->color_floats+multimesh->xform_floats;
|
|
|
|
float *dataptr=&multimesh->data[stride*p_index];
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Transform2D xform;
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
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;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
Color RasterizerStorageGLES3::multimesh_instance_get_color(RID p_multimesh,int p_index) const{
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
|
|
|
ERR_FAIL_COND_V(!multimesh,Color());
|
|
|
|
ERR_FAIL_INDEX_V(p_index,multimesh->size,Color());
|
|
|
|
ERR_FAIL_COND_V(multimesh->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];
|
|
|
|
|
|
|
|
if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
|
|
|
|
union {
|
|
|
|
uint32_t colu;
|
|
|
|
float colf;
|
|
|
|
} cu;
|
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
return Color::hex(BSWAP32(cu.colu));
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
} else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
|
|
|
|
Color c;
|
|
|
|
c.r=dataptr[ 0];
|
|
|
|
c.g=dataptr[ 1];
|
|
|
|
c.b=dataptr[ 2];
|
|
|
|
c.a=dataptr[ 3];
|
|
|
|
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
return Color();
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::multimesh_set_visible_instances(RID p_multimesh,int p_visible){
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
|
|
|
ERR_FAIL_COND(!multimesh);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
multimesh->visible_instances=p_visible;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
int RasterizerStorageGLES3::multimesh_get_visible_instances(RID p_multimesh) const{
|
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
|
|
|
ERR_FAIL_COND_V(!multimesh,-1);
|
|
|
|
|
|
|
|
return multimesh->visible_instances;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const{
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!multimesh,Rect3());
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
const_cast<RasterizerStorageGLES3*>(this)->update_dirty_multimeshes(); //update pending AABBs
|
|
|
|
|
|
|
|
return multimesh->aabb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::update_dirty_multimeshes() {
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (multimesh->size && multimesh->dirty_aabb) {
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 mesh_aabb;
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
if (multimesh->mesh.is_valid()) {
|
|
|
|
mesh_aabb=mesh_get_aabb(multimesh->mesh,RID());
|
|
|
|
} else {
|
|
|
|
mesh_aabb.size+=Vector3(0.001,0.001,0.001);
|
|
|
|
}
|
|
|
|
|
|
|
|
int stride=multimesh->color_floats+multimesh->xform_floats;
|
|
|
|
int count = multimesh->data.size();
|
|
|
|
float *data=multimesh->data.ptr();
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 aabb;
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
|
|
|
|
|
|
|
|
for(int i=0;i<count;i+=stride) {
|
|
|
|
|
|
|
|
float *dataptr=&data[i];
|
|
|
|
Transform xform;
|
|
|
|
xform.basis[0][0]=dataptr[ 0];
|
|
|
|
xform.basis[0][1]=dataptr[ 1];
|
|
|
|
xform.origin[0]=dataptr[ 3];
|
|
|
|
xform.basis[1][0]=dataptr[ 4];
|
|
|
|
xform.basis[1][1]=dataptr[ 5];
|
|
|
|
xform.origin[1]=dataptr[ 7];
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 laabb = xform.xform(mesh_aabb);
|
2016-11-22 04:26:56 +00:00
|
|
|
if (i==0)
|
|
|
|
aabb=laabb;
|
|
|
|
else
|
|
|
|
aabb.merge_with(laabb);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
for(int i=0;i<count;i+=stride) {
|
|
|
|
|
|
|
|
float *dataptr=&data[i];
|
|
|
|
Transform xform;
|
|
|
|
|
|
|
|
xform.basis.elements[0][0]=dataptr[ 0];
|
|
|
|
xform.basis.elements[0][1]=dataptr[ 1];
|
|
|
|
xform.basis.elements[0][2]=dataptr[ 2];
|
|
|
|
xform.origin.x=dataptr[ 3];
|
|
|
|
xform.basis.elements[1][0]=dataptr[ 4];
|
|
|
|
xform.basis.elements[1][1]=dataptr[ 5];
|
|
|
|
xform.basis.elements[1][2]=dataptr[ 6];
|
|
|
|
xform.origin.y=dataptr[ 7];
|
|
|
|
xform.basis.elements[2][0]=dataptr[ 8];
|
|
|
|
xform.basis.elements[2][1]=dataptr[ 9];
|
|
|
|
xform.basis.elements[2][2]=dataptr[10];
|
|
|
|
xform.origin.z=dataptr[11];
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 laabb = xform.xform(mesh_aabb);
|
2016-11-22 04:26:56 +00:00
|
|
|
if (i==0)
|
|
|
|
aabb=laabb;
|
|
|
|
else
|
|
|
|
aabb.merge_with(laabb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
multimesh->aabb=aabb;
|
|
|
|
}
|
|
|
|
multimesh->dirty_aabb=false;
|
|
|
|
multimesh->dirty_data=false;
|
|
|
|
|
|
|
|
multimesh->instance_change_notify();
|
|
|
|
|
|
|
|
multimesh_update_list.remove(multimesh_update_list.first());
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* IMMEDIATE API */
|
|
|
|
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
RID RasterizerStorageGLES3::immediate_create() {
|
|
|
|
|
|
|
|
Immediate *im = memnew( Immediate );
|
|
|
|
return immediate_owner.make_rid(im);
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-11-23 10:04:55 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
im->chunks.push_back(ic);
|
|
|
|
im->mask=0;
|
|
|
|
im->building=true;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::immediate_vertex(RID p_immediate,const Vector3& p_vertex){
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
|
|
|
ERR_FAIL_COND(!im);
|
|
|
|
ERR_FAIL_COND(!im->building);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate::Chunk *c = &im->chunks.back()->get();
|
|
|
|
|
|
|
|
|
|
|
|
if (c->vertices.empty() && im->chunks.size()==1) {
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
im->aabb.pos=p_vertex;
|
|
|
|
im->aabb.size=Vector3();
|
|
|
|
} else {
|
|
|
|
im->aabb.expand_to(p_vertex);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (im->mask&VS::ARRAY_FORMAT_NORMAL)
|
|
|
|
c->normals.push_back(chunk_normal);
|
|
|
|
if (im->mask&VS::ARRAY_FORMAT_TANGENT)
|
|
|
|
c->tangents.push_back(chunk_tangent);
|
|
|
|
if (im->mask&VS::ARRAY_FORMAT_COLOR)
|
|
|
|
c->colors.push_back(chunk_color);
|
|
|
|
if (im->mask&VS::ARRAY_FORMAT_TEX_UV)
|
|
|
|
c->uvs.push_back(chunk_uv);
|
|
|
|
if (im->mask&VS::ARRAY_FORMAT_TEX_UV2)
|
|
|
|
c->uvs2.push_back(chunk_uv2);
|
|
|
|
im->mask|=VS::ARRAY_FORMAT_VERTEX;
|
|
|
|
c->vertices.push_back(p_vertex);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2016-11-23 10:04:55 +00:00
|
|
|
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
void RasterizerStorageGLES3::immediate_normal(RID p_immediate,const Vector3& p_normal){
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
|
|
|
ERR_FAIL_COND(!im);
|
|
|
|
ERR_FAIL_COND(!im->building);
|
|
|
|
|
|
|
|
im->mask|=VS::ARRAY_FORMAT_NORMAL;
|
|
|
|
chunk_normal=p_normal;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::immediate_tangent(RID p_immediate,const Plane& p_tangent){
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
|
|
|
ERR_FAIL_COND(!im);
|
|
|
|
ERR_FAIL_COND(!im->building);
|
|
|
|
|
|
|
|
im->mask|=VS::ARRAY_FORMAT_TANGENT;
|
|
|
|
chunk_tangent=p_tangent;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::immediate_color(RID p_immediate,const Color& p_color){
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
|
|
|
ERR_FAIL_COND(!im);
|
|
|
|
ERR_FAIL_COND(!im->building);
|
|
|
|
|
|
|
|
im->mask|=VS::ARRAY_FORMAT_COLOR;
|
|
|
|
chunk_color=p_color;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::immediate_uv(RID p_immediate,const Vector2& tex_uv){
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
|
|
|
ERR_FAIL_COND(!im);
|
|
|
|
ERR_FAIL_COND(!im->building);
|
|
|
|
|
|
|
|
im->mask|=VS::ARRAY_FORMAT_TEX_UV;
|
|
|
|
chunk_uv=tex_uv;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::immediate_uv2(RID p_immediate,const Vector2& tex_uv){
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
|
|
|
ERR_FAIL_COND(!im);
|
|
|
|
ERR_FAIL_COND(!im->building);
|
|
|
|
|
|
|
|
im->mask|=VS::ARRAY_FORMAT_TEX_UV2;
|
|
|
|
chunk_uv2=tex_uv;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2016-11-23 10:04:55 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
void RasterizerStorageGLES3::immediate_end(RID p_immediate){
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
|
|
|
ERR_FAIL_COND(!im);
|
|
|
|
ERR_FAIL_COND(!im->building);
|
|
|
|
|
|
|
|
im->building=false;
|
|
|
|
|
|
|
|
im->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2016-11-23 10:04:55 +00:00
|
|
|
void RasterizerStorageGLES3::immediate_clear(RID p_immediate) {
|
|
|
|
|
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
|
|
|
ERR_FAIL_COND(!im);
|
|
|
|
ERR_FAIL_COND(im->building);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
im->chunks.clear();
|
|
|
|
im->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::immediate_get_aabb(RID p_immediate) const {
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
Immediate *im = immediate_owner.get(p_immediate);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!im,Rect3());
|
2016-11-23 10:04:55 +00:00
|
|
|
return im->aabb;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
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->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());
|
|
|
|
return im->material;
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* SKELETON API */
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::skeleton_create(){
|
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
Skeleton *skeleton = memnew( Skeleton );
|
|
|
|
return skeleton_owner.make_rid(skeleton);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-11-21 22:03:39 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
void RasterizerStorageGLES3::skeleton_allocate(RID p_skeleton,int p_bones,bool p_2d_skeleton){
|
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
|
|
|
|
ERR_FAIL_COND(!skeleton);
|
|
|
|
ERR_FAIL_COND(p_bones<0);
|
|
|
|
|
|
|
|
if (skeleton->size==p_bones && skeleton->use_2d==p_2d_skeleton)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (skeleton->ubo) {
|
|
|
|
glDeleteBuffers(1,&skeleton->ubo);
|
|
|
|
skeleton->ubo=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
} 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
glBindBuffer(GL_UNIFORM_BUFFER, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!skeleton->update_list.in_list()) {
|
|
|
|
skeleton_update_list.add(&skeleton->update_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
int RasterizerStorageGLES3::skeleton_get_bone_count(RID p_skeleton) const{
|
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
|
|
|
|
ERR_FAIL_COND_V(!skeleton,0);
|
|
|
|
|
|
|
|
return skeleton->size;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-11-21 22:03:39 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
void RasterizerStorageGLES3::skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform){
|
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
|
|
|
|
|
|
|
|
ERR_FAIL_COND(!skeleton);
|
|
|
|
ERR_FAIL_INDEX(p_bone,skeleton->size);
|
|
|
|
ERR_FAIL_COND(skeleton->use_2d);
|
|
|
|
|
|
|
|
float * 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);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2016-11-21 22:03:39 +00:00
|
|
|
|
|
|
|
|
2016-10-04 02:46:24 +00:00
|
|
|
Transform RasterizerStorageGLES3::skeleton_bone_get_transform(RID p_skeleton,int p_bone) const{
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V(!skeleton,Transform());
|
|
|
|
ERR_FAIL_INDEX_V(p_bone,skeleton->size,Transform());
|
|
|
|
ERR_FAIL_COND_V(skeleton->use_2d,Transform());
|
|
|
|
|
|
|
|
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];
|
|
|
|
|
|
|
|
return mtx;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2017-01-11 03:52:51 +00:00
|
|
|
void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Transform2D& p_transform){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
|
|
|
|
|
|
|
|
ERR_FAIL_COND(!skeleton);
|
|
|
|
ERR_FAIL_INDEX(p_bone,skeleton->size);
|
|
|
|
ERR_FAIL_COND(!skeleton->use_2d);
|
|
|
|
|
|
|
|
float * 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);
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2017-01-11 03:52:51 +00:00
|
|
|
Transform2D RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const{
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
|
|
|
|
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!skeleton,Transform2D());
|
|
|
|
ERR_FAIL_INDEX_V(p_bone,skeleton->size,Transform2D());
|
|
|
|
ERR_FAIL_COND_V(!skeleton->use_2d,Transform2D());
|
2016-11-21 22:03:39 +00:00
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Transform2D mtx;
|
2016-11-21 22:03:39 +00:00
|
|
|
|
|
|
|
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()) {
|
|
|
|
|
|
|
|
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());
|
|
|
|
glBindBuffer(GL_UNIFORM_BUFFER, 0);
|
|
|
|
}
|
2016-11-24 23:46:55 +00:00
|
|
|
|
|
|
|
for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) {
|
|
|
|
E->get()->base_changed();
|
|
|
|
}
|
2016-11-21 22:03:39 +00:00
|
|
|
|
|
|
|
skeleton_update_list.remove(skeleton_update_list.first());
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Light API */
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::light_create(VS::LightType p_type){
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light *light = memnew( Light );
|
|
|
|
light->type=p_type;
|
|
|
|
|
|
|
|
light->param[VS::LIGHT_PARAM_ENERGY]=1.0;
|
2016-11-21 01:49:53 +00:00
|
|
|
light->param[VS::LIGHT_PARAM_SPECULAR]=0.5;
|
2016-10-27 14:50:26 +00:00
|
|
|
light->param[VS::LIGHT_PARAM_RANGE]=1.0;
|
|
|
|
light->param[VS::LIGHT_PARAM_SPOT_ANGLE]=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;
|
2016-11-10 02:55:06 +00:00
|
|
|
light->omni_shadow_mode=VS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID;
|
|
|
|
light->omni_shadow_detail=VS::LIGHT_OMNI_SHADOW_DETAIL_VERTICAL;
|
2016-11-11 15:27:52 +00:00
|
|
|
light->directional_blend_splits=false;
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
light->version=0;
|
2016-10-27 14:50:26 +00:00
|
|
|
|
|
|
|
return light_owner.make_rid(light);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::light_set_color(RID p_light,const Color& p_color){
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
light->color=p_color;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::light_set_param(RID p_light,VS::LightParam p_param,float p_value){
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
|
|
|
ERR_FAIL_INDEX(p_param,VS::LIGHT_PARAM_MAX);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
switch(p_param) {
|
|
|
|
case VS::LIGHT_PARAM_RANGE:
|
|
|
|
case VS::LIGHT_PARAM_SPOT_ANGLE:
|
|
|
|
case VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE:
|
|
|
|
case VS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET:
|
|
|
|
case VS::LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET:
|
|
|
|
case VS::LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET:
|
|
|
|
case VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS:
|
|
|
|
case VS::LIGHT_PARAM_SHADOW_BIAS:
|
|
|
|
case VS::LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE: {
|
|
|
|
|
|
|
|
light->version++;
|
|
|
|
light->instance_change_notify();
|
|
|
|
} break;
|
2016-10-27 14:50:26 +00:00
|
|
|
}
|
2016-11-10 02:55:06 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
light->param[p_param]=p_value;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::light_set_shadow(RID p_light,bool p_enabled){
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
|
|
|
light->shadow=p_enabled;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
light->version++;
|
|
|
|
light->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-11-11 15:27:52 +00:00
|
|
|
|
|
|
|
void RasterizerStorageGLES3::light_set_shadow_color(RID p_light,const Color& p_color) {
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
2016-11-11 15:27:52 +00:00
|
|
|
light->shadow_color=p_color;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2016-11-11 15:27:52 +00:00
|
|
|
|
|
|
|
void RasterizerStorageGLES3::light_set_projector(RID p_light,RID p_texture){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
2016-11-11 15:27:52 +00:00
|
|
|
|
|
|
|
light->projector=p_texture;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
2016-11-10 02:55:06 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
void RasterizerStorageGLES3::light_set_negative(RID p_light,bool p_enable){
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
light->negative=p_enable;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::light_set_cull_mask(RID p_light,uint32_t p_mask){
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
light->cull_mask=p_mask;
|
2016-11-10 02:55:06 +00:00
|
|
|
|
|
|
|
light->version++;
|
|
|
|
light->instance_change_notify();
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
void RasterizerStorageGLES3::light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode) {
|
|
|
|
|
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return light->omni_shadow_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::light_omni_set_shadow_detail(RID p_light,VS::LightOmniShadowDetail p_detail) {
|
|
|
|
|
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
|
|
|
|
|
|
|
light->omni_shadow_detail=p_detail;
|
|
|
|
light->version++;
|
|
|
|
light->instance_change_notify();
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
void RasterizerStorageGLES3::light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode){
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
light->directional_shadow_mode=p_mode;
|
|
|
|
light->version++;
|
|
|
|
light->instance_change_notify();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-11 15:27:52 +00:00
|
|
|
void RasterizerStorageGLES3::light_directional_set_blend_splits(RID p_light,bool p_enable) {
|
|
|
|
|
|
|
|
Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND(!light);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return light->directional_blend_splits;
|
|
|
|
}
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
return light->directional_shadow_mode;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
VS::LightType RasterizerStorageGLES3::light_get_type(RID p_light) const {
|
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
const Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL);
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
return light->type;
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
return light->param[p_param];
|
|
|
|
}
|
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
Color RasterizerStorageGLES3::light_get_color(RID p_light) {
|
|
|
|
|
|
|
|
const Light * light = light_owner.getornull(p_light);
|
|
|
|
ERR_FAIL_COND_V(!light,Color());
|
|
|
|
|
|
|
|
return light->color;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-10 02:55:06 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return light->version;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
const Light * light = light_owner.getornull(p_light);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!light,Rect3());
|
2016-10-27 14:50:26 +00:00
|
|
|
|
|
|
|
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;
|
2017-01-11 03:52:51 +00:00
|
|
|
return Rect3( Vector3( -size,-size,-len ), Vector3( size*2, size*2, len ) );
|
2016-10-27 14:50:26 +00:00
|
|
|
} break;
|
|
|
|
case VS::LIGHT_OMNI: {
|
|
|
|
|
|
|
|
float r = light->param[VS::LIGHT_PARAM_RANGE];
|
2017-01-11 03:52:51 +00:00
|
|
|
return Rect3( -Vector3(r,r,r), Vector3(r,r,r)*2 );
|
2016-10-27 14:50:26 +00:00
|
|
|
} break;
|
|
|
|
case VS::LIGHT_DIRECTIONAL: {
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
return Rect3();
|
2016-10-27 14:50:26 +00:00
|
|
|
} break;
|
|
|
|
default: {}
|
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_V( Rect3() );
|
|
|
|
return Rect3();
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
/* PROBE API */
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::reflection_probe_create(){
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
return reflection_probe_owner.make_rid(reflection_probe);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
void RasterizerStorageGLES3::reflection_probe_set_update_mode(RID p_probe, VS::ReflectionProbeUpdateMode p_mode) {
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!reflection_probe);
|
|
|
|
|
|
|
|
reflection_probe->update_mode=p_mode;
|
|
|
|
reflection_probe->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
void RasterizerStorageGLES3::reflection_probe_set_intensity(RID p_probe, float p_intensity) {
|
|
|
|
|
|
|
|
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!reflection_probe);
|
|
|
|
|
|
|
|
reflection_probe->intensity=p_intensity;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_energy(RID p_probe, float p_energy) {
|
|
|
|
|
|
|
|
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!reflection_probe);
|
|
|
|
|
|
|
|
reflection_probe->interior_ambient_energy=p_energy;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_probe_contribution(RID p_probe, float p_contrib) {
|
|
|
|
|
|
|
|
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!reflection_probe);
|
|
|
|
|
|
|
|
reflection_probe->interior_ambient_probe_contrib=p_contrib;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::reflection_probe_set_extents(RID p_probe, const Vector3& p_extents){
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!reflection_probe);
|
|
|
|
|
|
|
|
reflection_probe->extents=p_extents;
|
|
|
|
reflection_probe->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::reflection_probe_set_origin_offset(RID p_probe, const Vector3& p_offset){
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!reflection_probe);
|
|
|
|
|
|
|
|
reflection_probe->origin_offset=p_offset;
|
|
|
|
reflection_probe->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
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;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
2016-11-19 16:23:37 +00:00
|
|
|
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);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
reflection_probe->box_projection=p_enable;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
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->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers){
|
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!reflection_probe);
|
|
|
|
|
|
|
|
reflection_probe->cull_mask=p_layers;
|
|
|
|
reflection_probe->instance_change_notify();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::reflection_probe_get_aabb(RID p_probe) const {
|
2016-11-19 16:23:37 +00:00
|
|
|
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!reflection_probe,Rect3());
|
2016-11-19 16:23:37 +00:00
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 aabb;
|
2016-11-19 16:23:37 +00:00
|
|
|
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{
|
|
|
|
|
|
|
|
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND_V(!reflection_probe,VS::REFLECTION_PROBE_UPDATE_ALWAYS);
|
|
|
|
|
|
|
|
return reflection_probe->update_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
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());
|
|
|
|
|
|
|
|
return reflection_probe->extents;
|
|
|
|
|
|
|
|
}
|
|
|
|
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());
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return reflection_probe->enable_shadows;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return reflection_probe->max_distance;
|
|
|
|
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
/* ROOM API */
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::room_create(){
|
|
|
|
|
|
|
|
return RID();
|
|
|
|
}
|
2017-01-07 21:25:37 +00:00
|
|
|
void RasterizerStorageGLES3::room_add_bounds(RID p_room, const PoolVector<Vector2>& p_convex_polygon,float p_height,const Transform& p_transform){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
|
|
|
}
|
2016-10-04 02:46:24 +00:00
|
|
|
void RasterizerStorageGLES3::room_clear_bounds(RID p_room){
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PORTAL API */
|
|
|
|
|
|
|
|
// portals are only (x/y) points, forming a convex shape, which its clockwise
|
|
|
|
// order points outside. (z is 0);
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::portal_create(){
|
|
|
|
|
|
|
|
return RID();
|
|
|
|
}
|
|
|
|
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_disable_distance(RID p_portal, float p_distance){
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::portal_set_disabled_color(RID p_portal, const Color& p_color){
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
RID RasterizerStorageGLES3::gi_probe_create() {
|
|
|
|
|
|
|
|
GIProbe *gip = memnew( GIProbe );
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
gip->bounds=Rect3(Vector3(),Vector3(1,1,1));
|
2016-12-20 03:21:07 +00:00
|
|
|
gip->dynamic_range=1.0;
|
2016-12-22 13:00:15 +00:00
|
|
|
gip->energy=1.0;
|
2017-02-06 08:12:15 +00:00
|
|
|
gip->propagation=1.0;
|
2016-12-22 13:00:15 +00:00
|
|
|
gip->interior=false;
|
2016-12-31 13:53:29 +00:00
|
|
|
gip->compress=false;
|
2016-12-20 03:21:07 +00:00
|
|
|
gip->version=1;
|
|
|
|
gip->cell_size=1.0;
|
|
|
|
|
|
|
|
return gi_probe_owner.make_rid(gip);
|
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe,const Rect3& p_bounds){
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
GIProbe *gip = gi_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!gip);
|
|
|
|
|
|
|
|
gip->bounds=p_bounds;
|
|
|
|
gip->version++;
|
|
|
|
gip->instance_change_notify();
|
|
|
|
}
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const{
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!gip,Rect3());
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
return gip->bounds;
|
|
|
|
}
|
|
|
|
|
|
|
|
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->version++;
|
|
|
|
gip->instance_change_notify();
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return gip->cell_size;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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());
|
|
|
|
|
|
|
|
return gip->to_cell;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
void RasterizerStorageGLES3::gi_probe_set_dynamic_data(RID p_probe,const PoolVector<int>& p_data){
|
2016-12-20 03:21:07 +00:00
|
|
|
GIProbe *gip = gi_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!gip);
|
|
|
|
|
|
|
|
gip->dynamic_data=p_data;
|
|
|
|
gip->version++;
|
|
|
|
gip->instance_change_notify();
|
|
|
|
|
|
|
|
}
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<int> RasterizerStorageGLES3::gi_probe_get_dynamic_data(RID p_probe) const{
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
|
2017-01-07 21:25:37 +00:00
|
|
|
ERR_FAIL_COND_V(!gip,PoolVector<int>());
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
return gip->dynamic_data;
|
|
|
|
}
|
|
|
|
|
2016-12-22 13:00:15 +00:00
|
|
|
void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe,int p_range){
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
GIProbe *gip = gi_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND(!gip);
|
|
|
|
|
|
|
|
gip->dynamic_range=p_range;
|
|
|
|
|
|
|
|
}
|
2016-12-22 13:00:15 +00:00
|
|
|
int RasterizerStorageGLES3::gi_probe_get_dynamic_range(RID p_probe) const{
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
|
|
|
|
ERR_FAIL_COND_V(!gip,0);
|
|
|
|
|
|
|
|
return gip->dynamic_range;
|
|
|
|
}
|
|
|
|
|
2016-12-22 13:00:15 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-06 08:12:15 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-12-22 13:00:15 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return gip->interior;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-12-31 13:53:29 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return gip->compress;
|
|
|
|
|
|
|
|
}
|
2016-12-22 13:00:15 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
return gip->energy;
|
|
|
|
}
|
|
|
|
|
2017-02-06 08:12:15 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
return gip->propagation;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
return gip->version;
|
|
|
|
}
|
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
RasterizerStorage::GIProbeCompression RasterizerStorageGLES3::gi_probe_get_dynamic_data_get_preferred_compression() const {
|
|
|
|
if (config.s3tc_supported) {
|
|
|
|
return GI_PROBE_S3TC;
|
|
|
|
} else {
|
|
|
|
return GI_PROBE_UNCOMPRESSED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::gi_probe_dynamic_data_create(int p_width, int p_height, int p_depth, GIProbeCompression p_compression) {
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
GIProbeData *gipd = memnew( GIProbeData );
|
|
|
|
|
|
|
|
gipd->width=p_width;
|
|
|
|
gipd->height=p_height;
|
|
|
|
gipd->depth=p_depth;
|
2016-12-30 11:35:54 +00:00
|
|
|
gipd->compression=p_compression;
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glGenTextures(1,&gipd->tex_id);
|
|
|
|
glBindTexture(GL_TEXTURE_3D,gipd->tex_id);
|
|
|
|
|
|
|
|
int level=0;
|
2016-12-30 11:35:54 +00:00
|
|
|
int min_size=1;
|
|
|
|
|
|
|
|
if (gipd->compression==GI_PROBE_S3TC) {
|
|
|
|
min_size=4;
|
|
|
|
}
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
print_line("dyndata create");
|
|
|
|
while(true) {
|
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
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);
|
|
|
|
} else {
|
|
|
|
glTexImage3D(GL_TEXTURE_3D,level,GL_RGBA8,p_width,p_height,p_depth,0,GL_RGBA,GL_UNSIGNED_BYTE,NULL);
|
2016-12-20 03:21:07 +00:00
|
|
|
}
|
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
if (p_width<=min_size || p_height<=min_size || p_depth<=min_size)
|
2016-12-20 03:21:07 +00:00
|
|
|
break;
|
|
|
|
p_width>>=1;
|
|
|
|
p_height>>=1;
|
|
|
|
p_depth>>=1;
|
|
|
|
level++;
|
|
|
|
}
|
|
|
|
|
|
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
|
|
|
|
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, level);
|
|
|
|
|
|
|
|
gipd->levels=level+1;
|
|
|
|
|
|
|
|
return gi_probe_data_owner.make_rid(gipd);
|
|
|
|
}
|
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
void RasterizerStorageGLES3::gi_probe_dynamic_data_update(RID p_gi_probe_data, int p_depth_slice, int p_slice_count, int p_mipmap, const void *p_data) {
|
2016-12-20 03:21:07 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
for(int i=0;i<(gipd->width>>p_mipmap);i++) {
|
|
|
|
for(int j=0;j<(gipd->height>>p_mipmap);j++) {
|
|
|
|
for(int k=0;k<(gipd->depth>>p_mipmap);k++) {
|
|
|
|
|
|
|
|
int ofs = (k*(gipd->height>>p_mipmap)*(gipd->width>>p_mipmap)) + j *(gipd->width>>p_mipmap) + i;
|
|
|
|
ofs*=4;
|
|
|
|
data[ofs+0]=i*0xFF/(gipd->width>>p_mipmap);
|
|
|
|
data[ofs+1]=j*0xFF/(gipd->height>>p_mipmap);
|
|
|
|
data[ofs+2]=k*0xFF/(gipd->depth>>p_mipmap);
|
|
|
|
data[ofs+3]=0xFF;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glBindTexture(GL_TEXTURE_3D,gipd->tex_id);
|
2016-12-30 11:35:54 +00:00
|
|
|
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);
|
|
|
|
}
|
2016-12-20 03:21:07 +00:00
|
|
|
//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());
|
2016-12-30 11:35:54 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
///////
|
|
|
|
|
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
RID RasterizerStorageGLES3::particles_create() {
|
|
|
|
|
|
|
|
Particles *particles = memnew( Particles );
|
|
|
|
|
|
|
|
|
|
|
|
return particles_owner.make_rid(particles);
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
void RasterizerStorageGLES3::particles_set_amount(RID p_particles,int p_amount) {
|
|
|
|
|
|
|
|
Particles *particles = particles_owner.getornull(p_particles);
|
|
|
|
ERR_FAIL_COND(!particles);
|
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
int floats = p_amount*24;
|
|
|
|
float * data = memnew_arr(float,floats);
|
|
|
|
|
|
|
|
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[1]);
|
|
|
|
glBufferData(GL_ARRAY_BUFFER,floats*sizeof(float),data,GL_DYNAMIC_DRAW);
|
|
|
|
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,0);
|
|
|
|
|
|
|
|
particles->prev_ticks=0;
|
|
|
|
particles->phase=0;
|
|
|
|
particles->prev_phase=0;
|
|
|
|
|
|
|
|
memdelete_arr(data);
|
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
}
|
2017-01-02 01:16:52 +00:00
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
2017-01-11 03:52:51 +00:00
|
|
|
void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles,const Rect3& p_aabb) {
|
2016-12-30 11:35:54 +00:00
|
|
|
|
|
|
|
Particles *particles = particles_owner.getornull(p_particles);
|
|
|
|
ERR_FAIL_COND(!particles);
|
|
|
|
particles->custom_aabb=p_aabb;
|
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
}
|
2016-12-30 11:35:54 +00:00
|
|
|
void RasterizerStorageGLES3::particles_set_gravity(RID p_particles,const Vector3& p_gravity) {
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
Particles *particles = particles_owner.getornull(p_particles);
|
|
|
|
ERR_FAIL_COND(!particles);
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
particles->gravity=p_gravity;
|
|
|
|
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::particles_set_emission_shape(RID p_particles, VS::ParticlesEmissionShape p_shape) {
|
|
|
|
|
|
|
|
Particles *particles = particles_owner.getornull(p_particles);
|
|
|
|
ERR_FAIL_COND(!particles);
|
|
|
|
|
|
|
|
particles->emission_shape=p_shape;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
2017-01-07 21:25:37 +00:00
|
|
|
void RasterizerStorageGLES3::particles_set_emission_points(RID p_particles,const PoolVector<Vector3>& p_points) {
|
2016-12-30 11:35:54 +00:00
|
|
|
|
|
|
|
Particles *particles = particles_owner.getornull(p_particles);
|
|
|
|
ERR_FAIL_COND(!particles);
|
|
|
|
|
|
|
|
particles->emission_points=p_points;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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) {
|
|
|
|
|
|
|
|
Particles *particles = particles_owner.getornull(p_particles);
|
|
|
|
ERR_FAIL_COND(!particles);
|
|
|
|
ERR_FAIL_INDEX(p_pass,particles->draw_passes.size());
|
2017-01-02 01:16:52 +00:00
|
|
|
particles->draw_passes[p_pass].material=p_material;
|
2016-12-30 11:35:54 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
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());
|
2017-01-02 01:16:52 +00:00
|
|
|
particles->draw_passes[p_pass].mesh=p_mesh;
|
2016-12-30 11:35:54 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-01-11 03:52:51 +00:00
|
|
|
Rect3 RasterizerStorageGLES3::particles_get_current_aabb(RID p_particles) {
|
2016-12-30 11:35:54 +00:00
|
|
|
|
|
|
|
const Particles *particles = particles_owner.getornull(p_particles);
|
2017-01-11 03:52:51 +00:00
|
|
|
ERR_FAIL_COND_V(!particles,Rect3());
|
2016-12-30 11:35:54 +00:00
|
|
|
|
|
|
|
return particles->computed_aabb;
|
|
|
|
}
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
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) {
|
|
|
|
|
|
|
|
shaders.particles.set_custom_shader(0);
|
|
|
|
} else {
|
|
|
|
shaders.particles.set_custom_shader( material->shader->custom_code_id );
|
|
|
|
|
|
|
|
if (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();
|
|
|
|
|
|
|
|
|
|
|
|
for(int i=0;i<tc;i++) {
|
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0+i);
|
|
|
|
|
|
|
|
GLenum target;
|
|
|
|
GLuint tex;
|
|
|
|
|
|
|
|
RasterizerStorageGLES3::Texture *t = texture_owner.getornull( textures[i] );
|
|
|
|
|
|
|
|
if (!t) {
|
|
|
|
//check hints
|
|
|
|
target=GL_TEXTURE_2D;
|
|
|
|
|
|
|
|
switch(texture_hints[i]) {
|
|
|
|
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO:
|
|
|
|
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK: {
|
|
|
|
tex=resources.black_tex;
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::ShaderNode::Uniform::HINT_ANISO: {
|
|
|
|
tex=resources.aniso_tex;
|
|
|
|
} break;
|
|
|
|
case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
|
|
|
|
tex=resources.normal_tex;
|
|
|
|
} break;
|
|
|
|
default: {
|
|
|
|
tex=resources.white_tex;
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
target=t->target;
|
|
|
|
tex = t->tex_id;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
glBindTexture(target,tex);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
shaders.particles.bind();
|
|
|
|
|
|
|
|
shaders.particles.set_uniform(ParticlesShaderGLES3::ORIGIN,particles->origin);
|
|
|
|
|
2017-01-14 20:35:39 +00:00
|
|
|
float new_phase = Math::fmod((float)particles->phase+(frame.delta/particles->lifetime),(float)1.0);
|
2017-01-02 01:16:52 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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++) {
|
|
|
|
glEnableVertexAttribArray(i);
|
|
|
|
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);
|
|
|
|
glEndTransformFeedback();
|
|
|
|
|
|
|
|
particle_update_list.remove(particle_update_list.first());
|
|
|
|
|
|
|
|
SWAP(particles->particle_buffers[0],particles->particle_buffers[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
glDisable(GL_RASTERIZER_DISCARD);
|
|
|
|
|
|
|
|
for(int i=0;i<6;i++) {
|
|
|
|
glDisableVertexAttribArray(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-12-30 11:35:54 +00:00
|
|
|
////////
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
void RasterizerStorageGLES3::instance_add_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance) {
|
|
|
|
|
|
|
|
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
|
|
|
|
ERR_FAIL_COND(!skeleton);
|
|
|
|
|
|
|
|
skeleton->instances.insert(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);
|
|
|
|
|
|
|
|
skeleton->instances.erase(p_instance);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
void RasterizerStorageGLES3::instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance) {
|
|
|
|
|
|
|
|
Instantiable *inst=NULL;
|
|
|
|
switch(p_instance->base_type) {
|
|
|
|
case VS::INSTANCE_MESH: {
|
|
|
|
inst = mesh_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-11-22 04:26:56 +00:00
|
|
|
case VS::INSTANCE_MULTIMESH: {
|
|
|
|
inst = multimesh_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-11-23 10:04:55 +00:00
|
|
|
case VS::INSTANCE_IMMEDIATE: {
|
|
|
|
inst = immediate_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-11-19 16:23:37 +00:00
|
|
|
case VS::INSTANCE_REFLECTION_PROBE: {
|
|
|
|
inst = reflection_probe_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-10-27 14:50:26 +00:00
|
|
|
case VS::INSTANCE_LIGHT: {
|
|
|
|
inst = light_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-12-20 03:21:07 +00:00
|
|
|
case VS::INSTANCE_GI_PROBE: {
|
|
|
|
inst = gi_probe_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-10-19 14:14:41 +00:00
|
|
|
default: {
|
2016-11-21 22:03:39 +00:00
|
|
|
if (!inst) {
|
|
|
|
ERR_FAIL();
|
|
|
|
}
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inst->instance_list.add( &p_instance->dependency_item );
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance){
|
|
|
|
|
|
|
|
Instantiable *inst=NULL;
|
|
|
|
|
|
|
|
switch(p_instance->base_type) {
|
|
|
|
case VS::INSTANCE_MESH: {
|
|
|
|
inst = mesh_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-11-22 04:26:56 +00:00
|
|
|
case VS::INSTANCE_MULTIMESH: {
|
|
|
|
inst = multimesh_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-11-23 10:04:55 +00:00
|
|
|
case VS::INSTANCE_IMMEDIATE: {
|
|
|
|
inst = immediate_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-11-19 16:23:37 +00:00
|
|
|
case VS::INSTANCE_REFLECTION_PROBE: {
|
|
|
|
inst = reflection_probe_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-10-27 14:50:26 +00:00
|
|
|
case VS::INSTANCE_LIGHT: {
|
|
|
|
inst = light_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-12-20 03:21:07 +00:00
|
|
|
case VS::INSTANCE_GI_PROBE: {
|
|
|
|
inst = gi_probe_owner.getornull(p_base);
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
} break;
|
2016-10-19 14:14:41 +00:00
|
|
|
default: {
|
2016-11-24 23:46:55 +00:00
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
if (!inst) {
|
|
|
|
ERR_FAIL();
|
|
|
|
}
|
2016-10-19 14:14:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ERR_FAIL_COND(!inst);
|
|
|
|
|
|
|
|
inst->instance_list.remove( &p_instance->dependency_item );
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
/* RENDER TARGET */
|
|
|
|
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
|
|
|
|
|
2017-02-06 23:18:35 +00:00
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
if (rt->fbo) {
|
|
|
|
glDeleteFramebuffers(1,&rt->fbo);
|
|
|
|
glDeleteTextures(1,&rt->color);
|
|
|
|
rt->fbo=0;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-02-06 23:18:35 +00:00
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
if (rt->buffers.fbo) {
|
|
|
|
glDeleteFramebuffers(1,&rt->buffers.fbo);
|
2017-01-02 01:16:52 +00:00
|
|
|
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);
|
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
rt->buffers.fbo=0;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-02-06 23:18:35 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
if (rt->depth) {
|
2016-11-29 22:55:12 +00:00
|
|
|
glDeleteTextures(1,&rt->depth);
|
2016-10-03 19:33:42 +00:00
|
|
|
rt->depth=0;
|
|
|
|
}
|
|
|
|
|
2017-02-06 23:18:35 +00:00
|
|
|
|
2016-12-04 15:45:30 +00:00
|
|
|
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]);
|
|
|
|
}
|
|
|
|
|
|
|
|
rt->effects.ssao.depth_mipmap_fbos.clear();
|
|
|
|
|
|
|
|
glDeleteTextures(1,&rt->effects.ssao.linear_depth);
|
2017-02-06 23:18:35 +00:00
|
|
|
|
|
|
|
rt->effects.ssao.blur_fbo[0]=0;
|
|
|
|
rt->effects.ssao.blur_fbo[1]=0;
|
2016-12-04 15:45:30 +00:00
|
|
|
}
|
|
|
|
|
2017-02-06 23:18:35 +00:00
|
|
|
|
2016-12-07 20:49:52 +00:00
|
|
|
if (rt->exposure.fbo) {
|
|
|
|
glDeleteFramebuffers(1,&rt->exposure.fbo);
|
|
|
|
glDeleteTextures(1,&rt->exposure.color);
|
2017-02-06 23:18:35 +00:00
|
|
|
rt->exposure.fbo=0;
|
2016-12-07 20:49:52 +00:00
|
|
|
}
|
2016-10-05 04:26:35 +00:00
|
|
|
Texture *tex = texture_owner.get(rt->texture);
|
|
|
|
tex->alloc_height=0;
|
|
|
|
tex->alloc_width=0;
|
|
|
|
tex->width=0;
|
|
|
|
tex->height=0;
|
|
|
|
|
2017-02-06 23:18:35 +00:00
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
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);
|
|
|
|
rt->effects.mip_maps[i].sizes.clear();
|
|
|
|
rt->effects.mip_maps[i].levels=0;
|
|
|
|
}
|
2017-02-06 23:18:35 +00:00
|
|
|
|
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
/*
|
|
|
|
if (rt->effects.screen_space_depth) {
|
|
|
|
glDeleteTextures(1,&rt->effects.screen_space_depth);
|
|
|
|
rt->effects.screen_space_depth=0;
|
|
|
|
|
|
|
|
}
|
|
|
|
*/
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
|
|
|
|
|
|
|
|
if (rt->width<=0 || rt->height<=0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
GLuint color_internal_format;
|
|
|
|
GLuint color_format;
|
|
|
|
GLuint color_type;
|
2016-10-05 04:26:35 +00:00
|
|
|
Image::Format image_format;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
if (!rt->flags[RENDER_TARGET_HDR] || rt->flags[RENDER_TARGET_NO_3D]) {
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
color_internal_format=GL_RGBA8;
|
|
|
|
color_format=GL_RGBA;
|
|
|
|
color_type=GL_UNSIGNED_BYTE;
|
|
|
|
image_format=Image::FORMAT_RGBA8;
|
2016-10-29 23:48:09 +00:00
|
|
|
} else {
|
2016-10-03 19:33:42 +00:00
|
|
|
color_internal_format=GL_RGBA16F;
|
|
|
|
color_format=GL_RGBA;
|
|
|
|
color_type=GL_HALF_FLOAT;
|
2016-10-05 04:26:35 +00:00
|
|
|
image_format=Image::FORMAT_RGBAH;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
{
|
|
|
|
/* FRONT FBO */
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
glGenFramebuffers(1, &rt->fbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, rt->fbo);
|
2016-10-29 23:48:09 +00:00
|
|
|
|
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
glGenTextures(1, &rt->depth);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, rt->depth);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, rt->width, rt->height, 0,
|
|
|
|
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);
|
2016-10-29 23:48:09 +00:00
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
|
|
|
|
GL_TEXTURE_2D, rt->depth, 0);
|
2016-10-29 23:48:09 +00:00
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
glGenTextures(1, &rt->color);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, rt->color);
|
2016-10-29 23:48:09 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
2016-11-29 22:55:12 +00:00
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->color, 0);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
2017-01-07 08:33:11 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
|
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
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;
|
2016-11-29 22:55:12 +00:00
|
|
|
tex->tex_id=rt->color;
|
2016-10-29 23:48:09 +00:00
|
|
|
tex->width=rt->width;
|
|
|
|
tex->alloc_width=rt->width;
|
|
|
|
tex->height=rt->height;
|
|
|
|
tex->alloc_height=rt->height;
|
|
|
|
|
2016-10-05 04:26:35 +00:00
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
texture_set_flags(rt->texture,tex->flags);
|
|
|
|
|
|
|
|
}
|
2016-10-05 04:26:35 +00:00
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
|
|
|
|
/* BACK FBO */
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
if (config.render_arch==RENDER_ARCH_DESKTOP && !rt->flags[RENDER_TARGET_NO_3D]) {
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
static const int msaa_value[]={0,2,4,8,16};
|
|
|
|
int msaa=msaa_value[rt->msaa];
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
//regular fbo
|
2016-10-29 23:48:09 +00:00
|
|
|
glGenFramebuffers(1, &rt->buffers.fbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, rt->buffers.fbo);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
glGenRenderbuffers(1, &rt->buffers.depth);
|
|
|
|
glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.depth);
|
|
|
|
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);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,rt->buffers.depth);
|
|
|
|
|
|
|
|
glGenRenderbuffers(1, &rt->buffers.diffuse);
|
|
|
|
glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.diffuse);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
if (msaa==0)
|
|
|
|
glRenderbufferStorage(GL_RENDERBUFFER,color_internal_format,rt->width,rt->height);
|
|
|
|
else
|
|
|
|
glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA16F,rt->width,rt->height);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
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,GL_RGBA16F,rt->width,rt->height);
|
|
|
|
else
|
|
|
|
glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,color_internal_format,rt->width,rt->height);
|
|
|
|
|
|
|
|
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);
|
|
|
|
else
|
|
|
|
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);
|
|
|
|
else
|
|
|
|
glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA8,rt->width,rt->height);
|
|
|
|
|
|
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT3,GL_RENDERBUFFER,rt->buffers.motion_sss);
|
2016-12-03 01:23:16 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
|
|
|
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
2017-01-07 08:33:11 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
if (status != GL_FRAMEBUFFER_COMPLETE) {
|
2017-01-02 01:16:52 +00:00
|
|
|
printf("err status: %x\n",status);
|
2016-10-03 19:33:42 +00:00
|
|
|
_render_target_clear(rt);
|
|
|
|
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
|
2017-01-02 01:16:52 +00:00
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
glBindRenderbuffer(GL_RENDERBUFFER,0);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
// effect resolver
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
glGenFramebuffers(1, &rt->buffers.effect_fbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, rt->buffers.effect_fbo);
|
|
|
|
|
|
|
|
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);
|
|
|
|
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);
|
2016-11-29 22:55:12 +00:00
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
if (status != GL_FRAMEBUFFER_COMPLETE) {
|
|
|
|
printf("err status: %x\n",status);
|
|
|
|
_render_target_clear(rt);
|
|
|
|
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
|
|
|
|
}
|
|
|
|
|
2017-01-07 08:33:11 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
if (status != GL_FRAMEBUFFER_COMPLETE) {
|
|
|
|
_render_target_clear(rt);
|
|
|
|
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
|
|
|
|
}
|
2016-10-29 23:48:09 +00:00
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
int level=0;
|
|
|
|
|
|
|
|
while(true) {
|
|
|
|
|
|
|
|
RenderTarget::Effects::MipMaps::Size mm;
|
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
glTexImage2D(GL_TEXTURE_2D, level, color_internal_format, w, h, 0, color_format, color_type, NULL);
|
2016-11-29 22:55:12 +00:00
|
|
|
mm.width=w;
|
|
|
|
mm.height=h;
|
|
|
|
rt->effects.mip_maps[i].sizes.push_back(mm);
|
|
|
|
|
|
|
|
w>>=1;
|
|
|
|
h>>=1;
|
|
|
|
|
2016-12-08 12:48:38 +00:00
|
|
|
if (w<2 || h<2)
|
|
|
|
break;
|
2016-11-29 22:55:12 +00:00
|
|
|
|
|
|
|
level++;
|
|
|
|
|
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
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++) {
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
|
|
if (status != GL_FRAMEBUFFER_COMPLETE) {
|
|
|
|
_render_target_clear(rt);
|
|
|
|
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
float zero[4]={1,0,1,0};
|
|
|
|
glClearBufferfv(GL_COLOR,0,zero);
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-01-07 08:33:11 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2016-11-29 22:55:12 +00:00
|
|
|
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);
|
|
|
|
//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);
|
2016-12-04 15:45:30 +00:00
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
///////////////// ssao
|
|
|
|
|
|
|
|
//AO strength textures
|
|
|
|
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);
|
|
|
|
|
|
|
|
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);
|
|
|
|
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->effects.ssao.blur_red[i], 0);
|
|
|
|
|
|
|
|
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
|
|
if (status != GL_FRAMEBUFFER_COMPLETE) {
|
|
|
|
_render_target_clear(rt);
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_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);
|
|
|
|
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
|
|
|
|
|
|
|
|
GLuint fbo;
|
|
|
|
glGenFramebuffers(1, &fbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->effects.ssao.linear_depth, i);
|
|
|
|
rt->effects.ssao.depth_mipmap_fbos.push_back(fbo);
|
2016-11-29 22:55:12 +00:00
|
|
|
}
|
|
|
|
|
2016-12-07 20:49:52 +00:00
|
|
|
|
|
|
|
//////Exposure
|
|
|
|
|
|
|
|
glGenFramebuffers(1, &rt->exposure.fbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, rt->exposure.fbo);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
|
|
|
|
if (status != GL_FRAMEBUFFER_COMPLETE) {
|
|
|
|
_render_target_clear(rt);
|
|
|
|
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
|
|
|
|
}
|
|
|
|
|
2016-11-29 22:55:12 +00:00
|
|
|
}
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
RID RasterizerStorageGLES3::render_target_create(){
|
|
|
|
|
|
|
|
RenderTarget *rt = memnew( RenderTarget );
|
2016-10-05 04:26:35 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
rt->texture=texture_owner.make_rid(t);
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
return render_target_owner.make_rid(rt);
|
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
return;
|
|
|
|
|
|
|
|
_render_target_clear(rt);
|
|
|
|
rt->width=p_width;
|
|
|
|
rt->height=p_height;
|
|
|
|
_render_target_allocate(rt);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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());
|
|
|
|
|
2016-10-05 04:26:35 +00:00
|
|
|
return rt->texture;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
switch(p_flag) {
|
|
|
|
case RENDER_TARGET_NO_3D:
|
|
|
|
case RENDER_TARGET_TRANSPARENT: {
|
|
|
|
//must reset for these formats
|
|
|
|
_render_target_clear(rt);
|
|
|
|
_render_target_allocate(rt);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
default: {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool RasterizerStorageGLES3::render_target_renedered_in_frame(RID p_render_target){
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-01-02 01:16:52 +00:00
|
|
|
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)
|
|
|
|
return;
|
|
|
|
|
|
|
|
_render_target_clear(rt);
|
|
|
|
rt->msaa=p_msaa;
|
|
|
|
_render_target_allocate(rt);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
/* 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;
|
|
|
|
|
|
|
|
cls->size=p_width;
|
|
|
|
cls->height=16;
|
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
|
|
|
|
glGenFramebuffers(1, &cls->fbo);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, cls->fbo);
|
|
|
|
|
|
|
|
glGenRenderbuffers(1, &cls->depth);
|
|
|
|
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 );
|
|
|
|
|
|
|
|
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);
|
|
|
|
} else {
|
|
|
|
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);
|
2017-01-07 08:33:11 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
return canvas_occluder_owner.make_rid(co);
|
|
|
|
}
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2>& p_lines) {
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
CanvasOccluder *co = canvas_occluder_owner.get(p_occluder);
|
|
|
|
ERR_FAIL_COND(!co);
|
|
|
|
|
|
|
|
co->lines=p_lines;
|
|
|
|
|
|
|
|
if (p_lines.size()!=co->len) {
|
|
|
|
|
|
|
|
if (co->index_id)
|
|
|
|
glDeleteBuffers(1,&co->index_id);
|
|
|
|
if (co->vertex_id)
|
|
|
|
glDeleteBuffers(1,&co->vertex_id);
|
|
|
|
|
|
|
|
co->index_id=0;
|
|
|
|
co->vertex_id=0;
|
|
|
|
co->len=0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p_lines.size()) {
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<float> geometry;
|
|
|
|
PoolVector<uint16_t> indices;
|
2016-10-03 19:33:42 +00:00
|
|
|
int lc = p_lines.size();
|
|
|
|
|
|
|
|
geometry.resize(lc*6);
|
|
|
|
indices.resize(lc*3);
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<float>::Write vw=geometry.write();
|
|
|
|
PoolVector<uint16_t>::Write iw=indices.write();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
2017-01-07 21:25:37 +00:00
|
|
|
PoolVector<Vector2>::Read lr=p_lines.read();
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
const int POLY_HEIGHT = 16384;
|
|
|
|
|
|
|
|
for(int i=0;i<lc/2;i++) {
|
|
|
|
|
|
|
|
vw[i*12+0]=lr[i*2+0].x;
|
|
|
|
vw[i*12+1]=lr[i*2+0].y;
|
|
|
|
vw[i*12+2]=POLY_HEIGHT;
|
|
|
|
|
|
|
|
vw[i*12+3]=lr[i*2+1].x;
|
|
|
|
vw[i*12+4]=lr[i*2+1].y;
|
|
|
|
vw[i*12+5]=POLY_HEIGHT;
|
|
|
|
|
|
|
|
vw[i*12+6]=lr[i*2+1].x;
|
|
|
|
vw[i*12+7]=lr[i*2+1].y;
|
|
|
|
vw[i*12+8]=-POLY_HEIGHT;
|
|
|
|
|
|
|
|
vw[i*12+9]=lr[i*2+0].x;
|
|
|
|
vw[i*12+10]=lr[i*2+0].y;
|
|
|
|
vw[i*12+11]=-POLY_HEIGHT;
|
|
|
|
|
|
|
|
iw[i*6+0]=i*4+0;
|
|
|
|
iw[i*6+1]=i*4+1;
|
|
|
|
iw[i*6+2]=i*4+2;
|
|
|
|
|
|
|
|
iw[i*6+3]=i*4+2;
|
|
|
|
iw[i*6+4]=i*4+3;
|
|
|
|
iw[i*6+5]=i*4+0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//if same buffer len is being set, just use BufferSubData to avoid a pipeline flush
|
|
|
|
|
|
|
|
|
|
|
|
if (!co->vertex_id) {
|
|
|
|
glGenBuffers(1,&co->vertex_id);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
|
|
|
|
glBufferData(GL_ARRAY_BUFFER,lc*6*sizeof(real_t),vw.ptr(),GL_STATIC_DRAW);
|
|
|
|
} else {
|
|
|
|
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
|
|
|
|
glBufferSubData(GL_ARRAY_BUFFER,0,lc*6*sizeof(real_t),vw.ptr());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
|
|
|
|
|
|
|
|
if (!co->index_id) {
|
|
|
|
|
|
|
|
glGenBuffers(1,&co->index_id);
|
|
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,co->index_id);
|
|
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER,lc*3*sizeof(uint16_t),iw.ptr(),GL_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,0); //unbind
|
|
|
|
|
|
|
|
co->len=lc;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
VS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const {
|
|
|
|
|
|
|
|
if (mesh_owner.owns(p_rid)) {
|
|
|
|
return VS::INSTANCE_MESH;
|
|
|
|
}
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
if (multimesh_owner.owns(p_rid)) {
|
|
|
|
return VS::INSTANCE_MULTIMESH;
|
|
|
|
}
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
if (immediate_owner.owns(p_rid)) {
|
|
|
|
return VS::INSTANCE_IMMEDIATE;
|
|
|
|
}
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2016-10-27 14:50:26 +00:00
|
|
|
if (light_owner.owns(p_rid)) {
|
|
|
|
return VS::INSTANCE_LIGHT;
|
|
|
|
}
|
2016-12-20 03:21:07 +00:00
|
|
|
|
2016-11-19 16:23:37 +00:00
|
|
|
if (reflection_probe_owner.owns(p_rid)) {
|
|
|
|
return VS::INSTANCE_REFLECTION_PROBE;
|
|
|
|
}
|
2016-10-19 14:14:41 +00:00
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
if (gi_probe_owner.owns(p_rid)) {
|
|
|
|
return VS::INSTANCE_GI_PROBE;
|
|
|
|
}
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
return VS::INSTANCE_NONE;
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
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);
|
2016-10-05 04:26:35 +00:00
|
|
|
Texture *t=texture_owner.get(rt->texture);
|
|
|
|
texture_owner.free(rt->texture);
|
|
|
|
memdelete(t);
|
2016-10-03 19:33:42 +00:00
|
|
|
render_target_owner.free(p_rid);
|
|
|
|
memdelete(rt);
|
|
|
|
|
|
|
|
} else if (texture_owner.owns(p_rid)) {
|
|
|
|
// delete the texture
|
|
|
|
Texture *texture = texture_owner.get(p_rid);
|
2016-10-05 04:26:35 +00:00
|
|
|
ERR_FAIL_COND_V(texture->render_target,true); //cant free the render target texture, dude
|
2016-10-03 19:33:42 +00:00
|
|
|
info.texture_mem-=texture->total_data_size;
|
|
|
|
texture_owner.free(p_rid);
|
|
|
|
memdelete(texture);
|
2016-11-19 16:23:37 +00:00
|
|
|
} 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_owner.free(p_rid);
|
|
|
|
memdelete(skybox);
|
2016-10-10 21:31:01 +00:00
|
|
|
|
|
|
|
} else if (shader_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
// delete the texture
|
|
|
|
Shader *shader = shader_owner.get(p_rid);
|
|
|
|
|
2016-11-25 02:30:54 +00:00
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
if (shader->shader)
|
|
|
|
shader->shader->free_custom_shader(shader->custom_code_id);
|
|
|
|
|
|
|
|
if (shader->dirty_list.in_list())
|
|
|
|
_shader_dirty_list.remove(&shader->dirty_list);
|
|
|
|
|
|
|
|
while (shader->materials.first()) {
|
|
|
|
|
|
|
|
Material *mat = shader->materials.first()->self();
|
|
|
|
|
|
|
|
mat->shader=NULL;
|
|
|
|
_material_make_dirty(mat);
|
|
|
|
|
|
|
|
shader->materials.remove( shader->materials.first() );
|
|
|
|
}
|
|
|
|
|
|
|
|
//material_shader.free_custom_shader(shader->custom_code_id);
|
|
|
|
shader_owner.free(p_rid);
|
|
|
|
memdelete(shader);
|
|
|
|
|
|
|
|
} else if (material_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
// delete the texture
|
|
|
|
Material *material = material_owner.get(p_rid);
|
|
|
|
|
|
|
|
if (material->shader) {
|
|
|
|
material->shader->materials.remove( & material->list );
|
|
|
|
}
|
|
|
|
|
|
|
|
if (material->ubo_id) {
|
|
|
|
glDeleteBuffers(1,&material->ubo_id);
|
|
|
|
}
|
|
|
|
|
2016-11-24 23:46:55 +00:00
|
|
|
//remove from owners
|
|
|
|
for (Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) {
|
|
|
|
|
|
|
|
Geometry *g = E->key();
|
|
|
|
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(int i=0;i<ins->materials.size();i++) {
|
|
|
|
if (ins->materials[i]==p_rid) {
|
|
|
|
ins->materials[i]=RID();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-10-10 21:31:01 +00:00
|
|
|
material_owner.free(p_rid);
|
|
|
|
memdelete(material);
|
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
} else if (skeleton_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
// delete the texture
|
|
|
|
Skeleton *skeleton = skeleton_owner.get(p_rid);
|
|
|
|
if (skeleton->update_list.in_list()) {
|
|
|
|
skeleton_update_list.remove(&skeleton->update_list);
|
|
|
|
}
|
2016-11-24 23:46:55 +00:00
|
|
|
|
|
|
|
for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) {
|
|
|
|
E->get()->skeleton=RID();
|
|
|
|
}
|
|
|
|
|
2016-11-21 22:03:39 +00:00
|
|
|
skeleton_allocate(p_rid,0,false);
|
|
|
|
skeleton_owner.free(p_rid);
|
|
|
|
memdelete(skeleton);
|
|
|
|
|
2016-10-19 14:14:41 +00:00
|
|
|
} else if (mesh_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
// delete the texture
|
|
|
|
Mesh *mesh = mesh_owner.get(p_rid);
|
2016-11-25 02:30:54 +00:00
|
|
|
mesh->instance_remove_deps();
|
2016-10-19 14:14:41 +00:00
|
|
|
mesh_clear(p_rid);
|
|
|
|
|
|
|
|
mesh_owner.free(p_rid);
|
|
|
|
memdelete(mesh);
|
2016-10-10 21:31:01 +00:00
|
|
|
|
2016-11-22 04:26:56 +00:00
|
|
|
} else if (multimesh_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
// delete the texture
|
|
|
|
MultiMesh *multimesh = multimesh_owner.get(p_rid);
|
2016-11-25 02:30:54 +00:00
|
|
|
multimesh->instance_remove_deps();
|
2016-11-22 04:26:56 +00:00
|
|
|
|
|
|
|
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);
|
2016-11-23 10:04:55 +00:00
|
|
|
} else if (immediate_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
Immediate *immediate = immediate_owner.get(p_rid);
|
2016-11-25 02:30:54 +00:00
|
|
|
immediate->instance_remove_deps();
|
2016-11-22 04:26:56 +00:00
|
|
|
|
2016-11-23 10:04:55 +00:00
|
|
|
immediate_owner.free(p_rid);
|
|
|
|
memdelete(immediate);
|
2016-10-27 14:50:26 +00:00
|
|
|
} else if (light_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
// delete the texture
|
|
|
|
Light *light = light_owner.get(p_rid);
|
2016-11-25 02:30:54 +00:00
|
|
|
light->instance_remove_deps();
|
2016-10-27 14:50:26 +00:00
|
|
|
|
|
|
|
light_owner.free(p_rid);
|
|
|
|
memdelete(light);
|
|
|
|
|
2016-11-25 02:30:54 +00:00
|
|
|
} else if (reflection_probe_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
// delete the texture
|
|
|
|
ReflectionProbe *reflection_probe = reflection_probe_owner.get(p_rid);
|
|
|
|
reflection_probe->instance_remove_deps();
|
|
|
|
|
|
|
|
reflection_probe_owner.free(p_rid);
|
|
|
|
memdelete(reflection_probe);
|
|
|
|
|
2016-12-20 03:21:07 +00:00
|
|
|
} else if (gi_probe_owner.owns(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)) {
|
|
|
|
|
|
|
|
// delete the texture
|
|
|
|
GIProbeData *gi_probe_data = gi_probe_data_owner.get(p_rid);
|
|
|
|
|
|
|
|
print_line("dyndata delete");
|
|
|
|
glDeleteTextures(1,&gi_probe_data->tex_id);
|
|
|
|
gi_probe_owner.free(p_rid);
|
|
|
|
memdelete(gi_probe_data);
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
} else if (canvas_occluder_owner.owns(p_rid)) {
|
|
|
|
|
|
|
|
|
|
|
|
CanvasOccluder *co = canvas_occluder_owner.get(p_rid);
|
|
|
|
if (co->index_id)
|
|
|
|
glDeleteBuffers(1,&co->index_id);
|
|
|
|
if (co->vertex_id)
|
|
|
|
glDeleteBuffers(1,&co->vertex_id);
|
|
|
|
|
|
|
|
canvas_occluder_owner.free(p_rid);
|
|
|
|
memdelete(co);
|
|
|
|
|
|
|
|
} 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);
|
|
|
|
canvas_light_shadow_owner.free(p_rid);
|
|
|
|
memdelete(cls);
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-02-06 03:38:39 +00:00
|
|
|
|
|
|
|
bool RasterizerStorageGLES3::has_os_feature(const String& p_feature) const {
|
|
|
|
|
|
|
|
if (p_feature=="s3tc")
|
|
|
|
return config.s3tc_supported;
|
|
|
|
|
|
|
|
if (p_feature=="etc")
|
|
|
|
return config.etc_supported;
|
|
|
|
|
|
|
|
if (p_feature=="etc2")
|
|
|
|
return config.etc2_supported;
|
|
|
|
|
|
|
|
if (p_feature=="pvrtc")
|
|
|
|
return config.pvrtc_supported;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::initialize() {
|
|
|
|
|
2016-10-29 23:48:09 +00:00
|
|
|
config.render_arch=RENDER_ARCH_DESKTOP;
|
|
|
|
//config.fbo_deferred=int(Globals::get_singleton()->get("rendering/gles3/lighting_technique"));
|
2016-10-03 19:33:42 +00:00
|
|
|
|
2017-01-07 08:33:11 +00:00
|
|
|
RasterizerStorageGLES3::system_fbo=0;
|
2016-10-03 19:33:42 +00:00
|
|
|
|
|
|
|
|
|
|
|
//// extensions config
|
|
|
|
///
|
|
|
|
|
|
|
|
{
|
2016-11-22 23:51:56 +00:00
|
|
|
|
|
|
|
int max_extensions=0;
|
2016-12-25 11:05:23 +00:00
|
|
|
print_line("getting extensions");
|
2016-11-22 23:51:56 +00:00
|
|
|
glGetIntegerv(GL_NUM_EXTENSIONS,&max_extensions);
|
2016-12-25 11:05:23 +00:00
|
|
|
print_line("total "+itos(max_extensions));
|
2016-11-22 23:51:56 +00:00
|
|
|
for(int i=0;i<max_extensions;i++) {
|
|
|
|
const GLubyte *s = glGetStringi( GL_EXTENSIONS,i );
|
|
|
|
if (!s)
|
|
|
|
break;
|
|
|
|
config.extensions.insert((const char*)s);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
config.shrink_textures_x2=false;
|
2017-01-05 12:16:00 +00:00
|
|
|
config.use_fast_texture_filter=int(GlobalConfig::get_singleton()->get("rendering/quality/use_nearest_mipmap_filter"));
|
2016-10-03 19:33:42 +00:00
|
|
|
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");
|
2016-11-22 23:51:56 +00:00
|
|
|
#ifdef GLES_OVER_GL
|
2016-10-03 19:33:42 +00:00
|
|
|
config.etc2_supported=false;
|
|
|
|
#else
|
|
|
|
config.etc2_supported=true;
|
|
|
|
#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.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);
|
2017-01-05 12:16:00 +00:00
|
|
|
config.anisotropic_level=MIN(int(GlobalConfig::get_singleton()->get("rendering/quality/anisotropic_filter_level")),config.anisotropic_level);
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glBindTexture(GL_TEXTURE_2D,resources.white_tex);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,whitetexdata);
|
|
|
|
glGenerateMipmap(GL_TEXTURE_2D);
|
|
|
|
glBindTexture(GL_TEXTURE_2D,0);
|
|
|
|
|
|
|
|
glGenTextures(1, &resources.black_tex);
|
|
|
|
unsigned char blacktexdata[8*8*3];
|
2016-11-21 01:49:53 +00:00
|
|
|
for(int i=0;i<8*8*3;i++) {
|
2016-10-03 19:33:42 +00:00
|
|
|
blacktexdata[i]=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glBindTexture(GL_TEXTURE_2D,resources.black_tex);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,blacktexdata);
|
|
|
|
glGenerateMipmap(GL_TEXTURE_2D);
|
|
|
|
glBindTexture(GL_TEXTURE_2D,0);
|
|
|
|
|
|
|
|
glGenTextures(1, &resources.normal_tex);
|
|
|
|
unsigned char normaltexdata[8*8*3];
|
|
|
|
for(int i=0;i<8*8*3;i+=3) {
|
|
|
|
normaltexdata[i+0]=128;
|
|
|
|
normaltexdata[i+1]=128;
|
|
|
|
normaltexdata[i+2]=255;
|
|
|
|
}
|
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glBindTexture(GL_TEXTURE_2D,resources.normal_tex);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,normaltexdata);
|
|
|
|
glGenerateMipmap(GL_TEXTURE_2D);
|
|
|
|
glBindTexture(GL_TEXTURE_2D,0);
|
|
|
|
|
2016-11-21 01:49:53 +00:00
|
|
|
|
|
|
|
glGenTextures(1, &resources.aniso_tex);
|
|
|
|
unsigned char anisotexdata[8*8*3];
|
|
|
|
for(int i=0;i<8*8*3;i+=3) {
|
|
|
|
anisotexdata[i+0]=255;
|
|
|
|
anisotexdata[i+1]=128;
|
|
|
|
anisotexdata[i+2]=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glBindTexture(GL_TEXTURE_2D,resources.aniso_tex);
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,anisotexdata);
|
|
|
|
glGenerateMipmap(GL_TEXTURE_2D);
|
|
|
|
glBindTexture(GL_TEXTURE_2D,0);
|
|
|
|
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&config.max_texture_image_units);
|
|
|
|
glGetIntegerv(GL_MAX_TEXTURE_SIZE,&config.max_texture_size);
|
|
|
|
|
2016-11-22 23:51:56 +00:00
|
|
|
#ifdef GLES_OVER_GL
|
2016-10-03 19:33:42 +00:00
|
|
|
config.use_rgba_2d_shadows=false;
|
|
|
|
#else
|
|
|
|
config.use_rgba_2d_shadows=true;
|
|
|
|
#endif
|
2016-10-21 10:27:13 +00:00
|
|
|
|
|
|
|
|
|
|
|
//generic quadie for copying
|
|
|
|
|
|
|
|
{
|
|
|
|
//quad buffers
|
|
|
|
|
|
|
|
glGenBuffers(1,&resources.quadie);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,resources.quadie);
|
|
|
|
{
|
|
|
|
const float qv[16]={
|
|
|
|
-1,-1,
|
|
|
|
0, 0,
|
|
|
|
-1, 1,
|
|
|
|
0, 1,
|
|
|
|
1, 1,
|
|
|
|
1, 1,
|
|
|
|
1,-1,
|
|
|
|
1, 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
glBufferData(GL_ARRAY_BUFFER,sizeof(float)*16,qv,GL_STATIC_DRAW);
|
|
|
|
}
|
|
|
|
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
|
|
|
|
|
|
|
|
|
|
|
|
glGenVertexArrays(1,&resources.quadie_array);
|
|
|
|
glBindVertexArray(resources.quadie_array);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,resources.quadie);
|
2016-10-29 23:48:09 +00:00
|
|
|
glVertexAttribPointer(VS::ARRAY_VERTEX,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,0);
|
2016-10-21 10:27:13 +00:00
|
|
|
glEnableVertexAttribArray(0);
|
2016-10-29 23:48:09 +00:00
|
|
|
glVertexAttribPointer(VS::ARRAY_TEX_UV,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,((uint8_t*)NULL)+8);
|
|
|
|
glEnableVertexAttribArray(4);
|
2016-10-21 10:27:13 +00:00
|
|
|
glBindVertexArray(0);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
|
|
|
|
}
|
|
|
|
|
2016-12-04 15:45:30 +00:00
|
|
|
//generic quadie for copying without touching skybox
|
2016-11-24 23:46:55 +00:00
|
|
|
|
|
|
|
{
|
|
|
|
//transform feedback buffers
|
2017-01-05 12:16:00 +00:00
|
|
|
uint32_t xf_feedback_size = GLOBAL_DEF("rendering/buffers/blend_shape_max_buffer_size_kb",4096);
|
2016-11-24 23:46:55 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-01-14 17:03:38 +00:00
|
|
|
shaders.blend_shapes.init();
|
2016-11-24 23:46:55 +00:00
|
|
|
|
|
|
|
glGenVertexArrays(1,&resources.transform_feedback_array);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-10-21 10:27:13 +00:00
|
|
|
shaders.cubemap_filter.init();
|
2017-01-02 01:16:52 +00:00
|
|
|
shaders.particles.init();
|
2016-10-30 01:11:05 +00:00
|
|
|
|
|
|
|
glEnable(_EXT_TEXTURE_CUBE_MAP_SEAMLESS);
|
2016-11-19 16:23:37 +00:00
|
|
|
|
|
|
|
frame.count=0;
|
2017-01-02 01:16:52 +00:00
|
|
|
frame.prev_tick=0;
|
|
|
|
frame.delta=0;
|
2016-12-23 03:37:38 +00:00
|
|
|
config.keep_original_textures=false;
|
2016-10-03 19:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerStorageGLES3::finalize() {
|
|
|
|
|
|
|
|
glDeleteTextures(1, &resources.white_tex);
|
|
|
|
glDeleteTextures(1, &resources.black_tex);
|
|
|
|
glDeleteTextures(1, &resources.normal_tex);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
RasterizerStorageGLES3::RasterizerStorageGLES3()
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|