godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
07bbcf91f7
godot/drivers/gles3/rasterizer_storage_gles3.cpp

6576 lines
170 KiB
C++
Raw Blame History

#include "rasterizer_storage_gles3.h"
#include "rasterizer_canvas_gles3.h"
#include "rasterizer_scene_gles3.h"
#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
#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
#define _GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
#define _GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
#define _EXT_COMPRESSED_R11_EAC 0x9270
#define _EXT_COMPRESSED_SIGNED_R11_EAC 0x9271
#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
GLuint RasterizerStorageGLES3::system_fbo = 0;
Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Image::Format p_format, uint32_t p_flags,GLenum& r_gl_format,GLenum& r_gl_internal_format,GLenum &r_gl_type,bool &r_compressed,bool &srgb) {
r_compressed=false;
r_gl_format=0;
Image image=p_image;
srgb=false;
bool need_decompress=false;
switch(p_format) {
case Image::FORMAT_L8: {
r_gl_internal_format=GL_R8;
r_gl_format=GL_RED;
r_gl_type=GL_UNSIGNED_BYTE;
} break;
case Image::FORMAT_LA8: {
r_gl_internal_format=GL_RG8;
r_gl_format=GL_RG;
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: {
#ifndef GLES_OVER_GL
r_gl_internal_format=GL_RGB565;
#else
//#warning TODO: Convert tod 555 if 565 is not supported (GLES3.3-)
r_gl_internal_format=GL_RGB5;
#endif
//r_gl_internal_format=GL_RGB565;
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) {
r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_S3TC_DXT1_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT;
r_gl_format=GL_RGBA;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
srgb=true;
} else {
need_decompress=true;
}
} 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) {
r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:_EXT_COMPRESSED_RGBA_BPTC_UNORM;
r_gl_format=GL_RGBA;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
srgb=true;
} else {
need_decompress=true;
}
} break;
case Image::FORMAT_BPTC_RGBF: {
if (config.bptc_supported) {
r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
r_gl_format=GL_RGB;
r_gl_type=GL_FLOAT;
r_compressed=true;
} else {
need_decompress=true;
}
} break;
case Image::FORMAT_BPTC_RGBFU: {
if (config.bptc_supported) {
r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
r_gl_format=GL_RGB;
r_gl_type=GL_FLOAT;
r_compressed=true;
} 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) {
r_gl_internal_format=_EXT_COMPRESSED_R11_EAC;
r_gl_format=GL_RED;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
} else {
need_decompress=true;
}
} break;
case Image::FORMAT_ETC2_R11S: {
if (config.etc2_supported) {
r_gl_internal_format=_EXT_COMPRESSED_SIGNED_R11_EAC;
r_gl_format=GL_RED;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
} else {
need_decompress=true;
}
} break;
case Image::FORMAT_ETC2_RG11: {
if (config.etc2_supported) {
r_gl_internal_format=_EXT_COMPRESSED_RG11_EAC;
r_gl_format=GL_RG;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
} else {
need_decompress=true;
}
} break;
case Image::FORMAT_ETC2_RG11S: {
if (config.etc2_supported) {
r_gl_internal_format=_EXT_COMPRESSED_SIGNED_RG11_EAC;
r_gl_format=GL_RG;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
} else {
need_decompress=true;
}
} break;
case Image::FORMAT_ETC2_RGB8: {
if (config.etc2_supported) {
r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ETC2:_EXT_COMPRESSED_RGB8_ETC2;
r_gl_format=GL_RGB;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
srgb=true;
} else {
need_decompress=true;
}
} break;
case Image::FORMAT_ETC2_RGBA8: {
if (config.etc2_supported) {
r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:_EXT_COMPRESSED_RGBA8_ETC2_EAC;
r_gl_format=GL_RGBA;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
srgb=true;
} else {
need_decompress=true;
}
} break;
case Image::FORMAT_ETC2_RGB8A1: {
if (config.etc2_supported) {
r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:_EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
r_gl_format=GL_RGBA;
r_gl_type=GL_UNSIGNED_BYTE;
r_compressed=true;
srgb=true;
} 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;
texture->stored_cube_sides=0;
texture->target = (p_flags & VS::TEXTURE_FLAG_CUBEMAP) ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D;
_get_gl_image_and_format(Image(),texture->format,texture->flags,format,internal_format,type,compressed,srgb);
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;
if (config.keep_original_textures && !(texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
texture->images[p_cube_side]=p_image;
}
Image img = _get_gl_image_and_format(p_image, p_image.get_format(),texture->flags,format,internal_format,type,compressed,srgb);
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();
PoolVector<uint8_t>::Read read = img.get_data().read();
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);
texture->using_srgb=true;
} else {
glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
texture->using_srgb=false;
}
}
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 );
}
//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;
}
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);
glCompressedTexImage2D( blit_target, i, internal_format,w,h,0,size,&read[ofs] );
} else {
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if (texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
glTexSubImage2D( blit_target, i, 0,0,w, h,format,type,&read[ofs] );
} 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);
texture->stored_cube_sides|=(1<<p_cube_side);
if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && mipmaps==1 && !texture->ignore_mipmaps && (!(texture->flags&VS::TEXTURE_FLAG_CUBEMAP) || texture->stored_cube_sides==(1<<6)-1)) {
//generate mipmaps if they were requested and the image does not contain them
glGenerateMipmap(texture->target);
} else if (mipmaps>1) {
glTexParameteri(texture->target, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, mipmaps-1);
}
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());
if (!texture->images[p_cube_side].empty())
return texture->images[p_cube_side];
#ifdef GLES_OVER_GL
PoolVector<uint8_t> data;
int data_size = Image::get_image_data_size(texture->alloc_width,texture->alloc_height,texture->format,texture->mipmaps>1?-1:0);
data.resize(data_size*2); //add some memory at the end, just in case for buggy drivers
PoolVector<uint8_t>::Write wb = data.write();
glActiveTexture(GL_TEXTURE0);
glBindTexture(texture->target,texture->tex_id);
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
print_line("GET FORMAT: "+Image::get_format_name(texture->format)+" mipmaps: "+itos(texture->mipmaps));
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 {
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glGetTexImage(texture->target,i,texture->gl_format_cache,texture->gl_type_cache,&wb[ofs]);
}
}
wb=PoolVector<uint8_t>::Write();
data.resize(data_size);
Image img(texture->alloc_width,texture->alloc_height,texture->mipmaps>1?true:false,texture->format,data);
return img;
#else
ERR_EXPLAIN("Sorry, It's not posible to obtain images back in OpenGL ES");
return Image();
#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);
texture->using_srgb=true;
} else {
glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
texture->using_srgb=false;
}
}
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;
}
void RasterizerStorageGLES3::textures_keep_original(bool p_enable) {
config.keep_original_textures=p_enable;
}
void RasterizerStorageGLES3::texture_set_detect_3d_callback(RID p_texture,VisualServer::TextureDetectCallback p_callback,void* p_userdata) {
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;
}
RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source,int p_resolution) const {
Texture * texture = texture_owner.get(p_source);
ERR_FAIL_COND_V(!texture,RID());
ERR_FAIL_COND_V(!(texture->flags&VS::TEXTURE_FLAG_CUBEMAP),RID());
bool use_float=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);
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);
GLuint new_cubemap;
glGenTextures(1, &new_cubemap);
glBindTexture(GL_TEXTURE_CUBE_MAP, new_cubemap);
GLuint tmp_fb;
glGenFramebuffers(1, &tmp_fb);
glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb);
int size = p_resolution;
int lod=0;
shaders.cubemap_filter.bind();
int mipmaps=6;
int mm_level=mipmaps;
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;
shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,false);
while(mm_level) {
for(int i=0;i<6;i++) {
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _cube_side_enum[i], new_cubemap, lod);
glViewport(0,0,size,size);
glBindVertexArray(resources.quadie_array);
shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::FACE_ID,i);
shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,lod/float(mipmaps-1));
glDrawArrays(GL_TRIANGLE_FAN,0,4);
glBindVertexArray(0);
#ifdef DEBUG_ENABLED
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
#endif
}
if (size>1)
size>>=1;
lod++;
mm_level--;
}
//restore ranges
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1);
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);
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
glDeleteFramebuffers(1, &tmp_fb);
Texture * ctex = memnew( Texture );
ctex->flags=VS::TEXTURE_FLAG_CUBEMAP|VS::TEXTURE_FLAG_MIPMAPS|VS::TEXTURE_FLAG_FILTER;
ctex->width=p_resolution;
ctex->height=p_resolution;
ctex->alloc_width=p_resolution;
ctex->alloc_height=p_resolution;
ctex->format=use_float?Image::FORMAT_RGBAH:Image::FORMAT_RGBA8;
ctex->target=GL_TEXTURE_CUBE_MAP;
ctex->gl_format_cache=format;
ctex->gl_internal_format_cache=internal_format;
ctex->gl_type_cache=type;
ctex->data_size=0;
ctex->compressed=false;
ctex->srgb=false;
ctex->total_data_size=0;
ctex->ignore_mipmaps=false;
ctex->mipmaps=mipmaps;
ctex->active=true;
ctex->tex_id=new_cubemap;
ctex->stored_cube_sides=(1<<6)-1;
ctex->render_target=NULL;
return texture_owner.make_rid(ctex);
}
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);
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
glDeleteFramebuffers(1, &tmp_fb);
}
/* SHADER API */
RID RasterizerStorageGLES3::shader_create(VS::ShaderMode p_mode){
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);
}
void RasterizerStorageGLES3::shader_set_mode(RID p_shader,VS::ShaderMode p_mode){
ERR_FAIL_INDEX(p_mode,VS::SHADER_MAX);
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_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]={
&scene->state.scene_shader,
&canvas->state.canvas_shader,
&this->shaders.particles,
};
shader->shader=shaders[p_mode];
shader->custom_code_id = shader->shader->create_custom_shader();
_shader_make_dirty(shader);
}
VS::ShaderMode RasterizerStorageGLES3::shader_get_mode(RID p_shader) const {
const Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND_V(!shader,VS::SHADER_MAX);
return shader->mode;
}
void RasterizerStorageGLES3::shader_set_code(RID p_shader, const String& p_code){
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
shader->code=p_code;
_shader_make_dirty(shader);
}
String RasterizerStorageGLES3::shader_get_code(RID p_shader) const{
const Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND_V(!shader,String());
return shader->code;
}
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;
case VS::SHADER_SPATIAL: {
p_shader->spatial.blend_mode=Shader::Spatial::BLEND_MODE_MIX;
p_shader->spatial.depth_draw_mode=Shader::Spatial::DEPTH_DRAW_OPAQUE;
p_shader->spatial.cull_mode=Shader::Spatial::CULL_MODE_BACK;
p_shader->spatial.uses_alpha=false;
p_shader->spatial.uses_discard=false;
p_shader->spatial.unshaded=false;
p_shader->spatial.ontop=false;
p_shader->spatial.uses_sss=false;
p_shader->spatial.uses_vertex=false;
shaders.actions_scene.render_mode_values["blend_add"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_ADD);
shaders.actions_scene.render_mode_values["blend_mix"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_MIX);
shaders.actions_scene.render_mode_values["blend_sub"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_SUB);
shaders.actions_scene.render_mode_values["blend_mul"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_MUL);
shaders.actions_scene.render_mode_values["depth_draw_opaque"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_OPAQUE);
shaders.actions_scene.render_mode_values["depth_draw_always"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_ALWAYS);
shaders.actions_scene.render_mode_values["depth_draw_never"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_NEVER);
shaders.actions_scene.render_mode_values["depth_draw_alpha_prepass"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS);
shaders.actions_scene.render_mode_values["cull_front"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_FRONT);
shaders.actions_scene.render_mode_values["cull_back"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_BACK);
shaders.actions_scene.render_mode_values["cull_disabled"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_DISABLED);
shaders.actions_scene.render_mode_flags["unshaded"]=&p_shader->spatial.unshaded;
shaders.actions_scene.render_mode_flags["ontop"]=&p_shader->spatial.ontop;
shaders.actions_scene.usage_flag_pointers["ALPHA"]=&p_shader->spatial.uses_alpha;
shaders.actions_scene.usage_flag_pointers["VERTEX"]=&p_shader->spatial.uses_vertex;
shaders.actions_scene.usage_flag_pointers["SSS_STRENGTH"]=&p_shader->spatial.uses_sss;
shaders.actions_scene.usage_flag_pointers["DISCARD"]=&p_shader->spatial.uses_discard;
actions=&shaders.actions_scene;
actions->uniforms=&p_shader->uniforms;
} break;
case VS::SHADER_PARTICLES: {
actions=&shaders.actions_particles;
actions->uniforms=&p_shader->uniforms;
} break;
}
Error err = shaders.compiler.compile(p_shader->mode,p_shader->code,actions,p_shader->path,gen_code);
ERR_FAIL_COND(err!=OK);
p_shader->shader->set_custom_shader_code(p_shader->custom_code_id,gen_code.vertex,gen_code.vertex_global,gen_code.fragment,gen_code.light,gen_code.fragment_global,gen_code.uniforms,gen_code.texture_uniforms,gen_code.defines);
p_shader->ubo_size=gen_code.uniform_total_size;
p_shader->ubo_offsets=gen_code.uniform_offsets;
p_shader->texture_count=gen_code.texture_uniforms.size();
p_shader->texture_hints=gen_code.texture_hints;
p_shader->uses_vertex_time=gen_code.uses_vertex_time;
p_shader->uses_fragment_time=gen_code.uses_fragment_time;
//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++;
}
void RasterizerStorageGLES3::update_dirty_shaders() {
while( _shader_dirty_list.first() ) {
_update_shader(_shader_dirty_list.first()->self() );
}
}
void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const{
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;
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: {
pi.type=Variant::POOL_INT_ARRAY;
} break;
case ShaderLanguage::TYPE_FLOAT: {
pi.type=Variant::REAL;
if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
pi.hint=PROPERTY_HINT_RANGE;
pi.hint_string=rtos(u.hint_range[0])+","+rtos(u.hint_range[1])+","+rtos(u.hint_range[2]);
}
} 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;
case ShaderLanguage::TYPE_MAT2: pi.type=Variant::TRANSFORM2D; break;
case ShaderLanguage::TYPE_MAT3: pi.type=Variant::BASIS; break;
case ShaderLanguage::TYPE_MAT4: pi.type=Variant::TRANSFORM; break;
case ShaderLanguage::TYPE_SAMPLER2D:
case ShaderLanguage::TYPE_ISAMPLER2D:
case ShaderLanguage::TYPE_USAMPLER2D: {
pi.type=Variant::OBJECT;
pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string="Texture";
} break;
case ShaderLanguage::TYPE_SAMPLERCUBE: {
pi.type=Variant::OBJECT;
pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string="CubeMap";
} break;
};
p_param_list->push_back(pi);
}
}
void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture){
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
ERR_FAIL_COND(p_texture.is_valid() && !texture_owner.owns(p_texture));
if (p_texture.is_valid())
shader->default_textures[p_name]=p_texture;
else
shader->default_textures.erase(p_name);
_shader_make_dirty(shader);
}
RID RasterizerStorageGLES3::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const{
const Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND_V(!shader,RID());
const Map<StringName,RID>::Element *E=shader->default_textures.find(p_name);
if (!E)
return RID();
return E->get();
}
/* COMMON MATERIAL API */
void RasterizerStorageGLES3::_material_make_dirty(Material* p_material) const {
if (p_material->dirty_list.in_list())
return;
_material_dirty_list.add(&p_material->dirty_list);
}
RID RasterizerStorageGLES3::material_create(){
Material *material = memnew( Material );
return material_owner.make_rid(material);
}
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);
}
_material_make_dirty(material);
}
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;
return RID();
}
void RasterizerStorageGLES3::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value){
Material *material = material_owner.get( p_material );
ERR_FAIL_COND(!material);
if (p_value.get_type()==Variant::NIL)
material->params.erase(p_param);
else
material->params[p_param]=p_value;
_material_make_dirty(material);
}
Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringName& p_param) const{
const Material *material = material_owner.get( p_material );
ERR_FAIL_COND_V(!material,RID());
if (material->params.has(p_param))
return material->params[p_param];
return Variant();
}
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;
}
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);
}
}
_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant& value, uint8_t *data,bool p_linear_color) {
switch(type) {
case ShaderLanguage::TYPE_BOOL: {
bool v = value;
GLuint *gui = (GLuint*)data;
*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: {
PoolVector<int> iv = value;
int s = iv.size();
GLint *gui = (GLint*)data;
PoolVector<int>::Read r = iv.read();
for(int i=0;i<2;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_IVEC3: {
PoolVector<int> iv = value;
int s = iv.size();
GLint *gui = (GLint*)data;
PoolVector<int>::Read r = iv.read();
for(int i=0;i<3;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_IVEC4: {
PoolVector<int> iv = value;
int s = iv.size();
GLint *gui = (GLint*)data;
PoolVector<int>::Read r = iv.read();
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: {
PoolVector<int> iv = value;
int s = iv.size();
GLuint *gui = (GLuint*)data;
PoolVector<int>::Read r = iv.read();
for(int i=0;i<2;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_UVEC3: {
PoolVector<int> iv = value;
int s = iv.size();
GLuint *gui = (GLuint*)data;
PoolVector<int>::Read r = iv.read();
for(int i=0;i<3;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_UVEC4: {
PoolVector<int> iv = value;
int s = iv.size();
GLuint *gui = (GLuint*)data;
PoolVector<int>::Read r = iv.read();
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;
if (p_linear_color) {
v=v.to_linear();
}
gui[0]=v.r;
gui[1]=v.g;
gui[2]=v.b;
gui[3]=v.a;
} else if (value.get_type()==Variant::RECT2) {
Rect2 v=value;
gui[0]=v.pos.x;
gui[1]=v.pos.y;
gui[2]=v.size.x;
gui[3]=v.size.y;
} else if (value.get_type()==Variant::QUAT) {
Quat v=value;
gui[0]=v.x;
gui[1]=v.y;
gui[2]=v.z;
gui[3]=v.w;
} else {
Plane v=value;
gui[0]=v.normal.x;
gui[1]=v.normal.y;
gui[2]=v.normal.x;
gui[3]=v.d;
}
} break;
case ShaderLanguage::TYPE_MAT2: {
Transform2D v = value;
GLfloat *gui = (GLfloat*)data;
gui[ 0]=v.elements[0][0];
gui[ 1]=v.elements[0][1];
gui[ 2]=v.elements[1][0];
gui[ 3]=v.elements[1][1];
} break;
case ShaderLanguage::TYPE_MAT3: {
Basis v = value;
GLfloat *gui = (GLfloat*)data;
gui[ 0]=v.elements[0][0];
gui[ 1]=v.elements[1][0];
gui[ 2]=v.elements[2][0];
gui[ 3]=0;
gui[ 4]=v.elements[0][1];
gui[ 5]=v.elements[1][1];
gui[ 6]=v.elements[2][1];
gui[ 7]=0;
gui[ 8]=v.elements[0][2];
gui[ 9]=v.elements[1][2];
gui[10]=v.elements[2][2];
gui[11]=0;
} 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 );
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;
for(Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) {
E->key()->material_changed_notify();
}
for(Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.front();E;E=E->next()) {
E->key()->base_material_changed();
}
}
}
//clear ubo if it needs to be cleared
if (material->ubo_size) {
if (!material->shader || material->shader->ubo_size!=material->ubo_size) {
//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) {
//user provided
_fill_std140_variant_ubo_value(E->get().type,V->get(),data,material->shader->mode==VS::SHADER_SPATIAL);
} else if (E->get().default_value.size()){
//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();
}
}
void RasterizerStorageGLES3::_material_add_geometry(RID p_material,Geometry *p_geometry) {
Material * material = material_owner.getornull(p_material);
ERR_FAIL_COND(!material);
Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry);
if (I) {
I->get()++;
} else {
material->geometry_owners[p_geometry]=1;
}
}
void RasterizerStorageGLES3::_material_remove_geometry(RID p_material,Geometry *p_geometry) {
Material * material = material_owner.getornull(p_material);
ERR_FAIL_COND(!material);
Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry);
ERR_FAIL_COND(!I);
I->get()--;
if (I->get()==0) {
material->geometry_owners.erase(I);
}
}
void RasterizerStorageGLES3::update_dirty_materials() {
while( _material_dirty_list.first() ) {
Material *material = _material_dirty_list.first()->self();
_update_material(material);
}
}
/* MESH API */
RID RasterizerStorageGLES3::mesh_create(){
Mesh * mesh = memnew( Mesh );
return mesh_owner.make_rid(mesh);
}
void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const PoolVector<uint8_t>& p_array,int p_vertex_count,const PoolVector<uint8_t>& p_index_array,int p_index_count,const Rect3& p_aabb,const Vector<PoolVector<uint8_t> >& p_blend_shapes,const Vector<Rect3>& p_bone_aabbs){
PoolVector<uint8_t> array = p_array;
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
ERR_FAIL_COND(!(p_format&VS::ARRAY_FORMAT_VERTEX));
//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 );
}
//bool has_morph = p_blend_shapes.size();
Surface::Attrib attribs[VS::ARRAY_MAX];
int stride=0;
for(int i=0;i<VS::ARRAY_MAX;i++) {
attribs[i].index=i;
if (! (p_format&(1<<i) ) ) {
attribs[i].enabled=false;
attribs[i].integer=false;
continue;
}
attribs[i].enabled=true;
attribs[i].offset=stride;
attribs[i].integer=false;
switch(i) {
case VS::ARRAY_VERTEX: {
if (p_format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
attribs[i].size=2;
} else {
attribs[i].size=(p_format&VS::ARRAY_COMPRESS_VERTEX)?4:3;
}
if (p_format&VS::ARRAY_COMPRESS_VERTEX) {
attribs[i].type=GL_HALF_FLOAT;
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;
}
} 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;
} break;
case VS::ARRAY_BONES: {
attribs[i].size=4;
if (p_format&VS::ARRAY_FLAG_USE_16_BIT_BONES) {
attribs[i].type=GL_UNSIGNED_SHORT;
stride+=8;
} else {
attribs[i].type=GL_UNSIGNED_BYTE;
stride+=4;
}
attribs[i].normalized=GL_FALSE;
attribs[i].integer=true;
} break;
case VS::ARRAY_WEIGHTS: {
attribs[i].size=4;
if (p_format&VS::ARRAY_COMPRESS_WEIGHTS) {
attribs[i].type=GL_UNSIGNED_SHORT;
stride+=8;
attribs[i].normalized=GL_TRUE;
} else {
attribs[i].type=GL_FLOAT;
stride+=16;
attribs[i].normalized=GL_FALSE;
}
} break;
case VS::ARRAY_INDEX: {
attribs[i].size=1;
if (p_vertex_count>=(1<<16)) {
attribs[i].type=GL_UNSIGNED_INT;
attribs[i].stride=4;
} else {
attribs[i].type=GL_UNSIGNED_SHORT;
attribs[i].stride=2;
}
attribs[i].normalized=GL_FALSE;
} break;
}
}
for(int i=0;i<VS::ARRAY_MAX-1;i++) {
attribs[i].stride=stride;
}
//validate sizes
int array_size = stride * p_vertex_count;
int index_array_size=0;
if (array.size()!=array_size && array.size()+p_vertex_count*2 == array_size) {
//old format, convert
array = PoolVector<uint8_t>();
array.resize( p_array.size()+p_vertex_count*2 );
PoolVector<uint8_t>::Write w = array.write();
PoolVector<uint8_t>::Read r = p_array.read();
uint16_t *w16 = (uint16_t*)w.ptr();
const uint16_t *r16 = (uint16_t*)r.ptr();
uint16_t one = Math::make_half_float(1);
for(int i=0;i<p_vertex_count;i++) {
*w16++ = *r16++;
*w16++ = *r16++;
*w16++ = *r16++;
*w16++ = one;
for(int j=0;j<(stride/2)-4;j++) {
*w16++ = *r16++;
}
}
}
ERR_FAIL_COND(array.size()!=array_size);
if (p_format&VS::ARRAY_FORMAT_INDEX) {
index_array_size=attribs[VS::ARRAY_INDEX].stride*p_index_count;
}
ERR_FAIL_COND(p_index_array.size()!=index_array_size);
ERR_FAIL_COND(p_blend_shapes.size()!=mesh->blend_shape_count);
for(int i=0;i<p_blend_shapes.size();i++) {
ERR_FAIL_COND(p_blend_shapes[i].size()!=array_size);
}
//ok all valid, create stuff
Surface * surface = memnew( Surface );
surface->active=true;
surface->array_len=p_vertex_count;
surface->index_array_len=p_index_count;
surface->array_byte_size=array.size();
surface->index_array_byte_size=p_index_array.size();
surface->primitive=p_primitive;
surface->mesh=mesh;
surface->format=p_format;
surface->skeleton_bone_aabb=p_bone_aabbs;
surface->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];
}
{
PoolVector<uint8_t>::Read vr = array.read();
glGenBuffers(1,&surface->vertex_id);
glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
glBufferData(GL_ARRAY_BUFFER,array_size,vr.ptr(),GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
if (p_format&VS::ARRAY_FORMAT_INDEX) {
PoolVector<uint8_t>::Read ir = p_index_array.read();
glGenBuffers(1,&surface->index_id);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,index_array_size,ir.ptr(),GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); //unbind
}
//generate arrays for faster state switching
for(int ai=0;ai<2;ai++) {
if (ai==0) {
//for normal draw
glGenVertexArrays(1,&surface->array_id);
glBindVertexArray(surface->array_id);
glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
} else if (ai==1) {
//for instancing draw (can be changed and no one cares)
glGenVertexArrays(1,&surface->instancing_array_id);
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);
}
if (surface->index_id) {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
}
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
}
}
{
//blend shapes
for(int i=0;i<p_blend_shapes.size();i++) {
Surface::BlendShape mt;
PoolVector<uint8_t>::Read vr = p_blend_shapes[i].read();
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);
for(int j=0;j<VS::ARRAY_MAX-1;j++) {
if (!attribs[j].enabled)
continue;
if (attribs[j].integer) {
glVertexAttribIPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].stride,((uint8_t*)0)+attribs[j].offset);
} else {
glVertexAttribPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].normalized,attribs[j].stride,((uint8_t*)0)+attribs[j].offset);
}
glEnableVertexAttribArray(attribs[j].index);
}
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
surface->blend_shapes.push_back(mt);
}
}
mesh->surfaces.push_back(surface);
mesh->instance_change_notify();
}
void RasterizerStorageGLES3::mesh_set_blend_shape_count(RID p_mesh,int p_amount){
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
ERR_FAIL_COND(mesh->surfaces.size()!=0);
ERR_FAIL_COND(p_amount<0);
mesh->blend_shape_count=p_amount;
}
int RasterizerStorageGLES3::mesh_get_blend_shape_count(RID p_mesh) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,0);
return mesh->blend_shape_count;
}
void RasterizerStorageGLES3::mesh_set_blend_shape_mode(RID p_mesh,VS::BlendShapeMode p_mode){
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
mesh->blend_shape_mode=p_mode;
}
VS::BlendShapeMode RasterizerStorageGLES3::mesh_get_blend_shape_mode(RID p_mesh) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,VS::BLEND_SHAPE_MODE_NORMALIZED);
return mesh->blend_shape_mode;
}
void RasterizerStorageGLES3::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material){
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
ERR_FAIL_INDEX(p_surface,mesh->surfaces.size());
if (mesh->surfaces[p_surface]->material==p_material)
return;
if (mesh->surfaces[p_surface]->material.is_valid()) {
_material_remove_geometry(mesh->surfaces[p_surface]->material,mesh->surfaces[p_surface]);
}
mesh->surfaces[p_surface]->material=p_material;
if (mesh->surfaces[p_surface]->material.is_valid()) {
_material_add_geometry(mesh->surfaces[p_surface]->material,mesh->surfaces[p_surface]);
}
mesh->instance_material_change_notify();
}
RID RasterizerStorageGLES3::mesh_surface_get_material(RID p_mesh, int p_surface) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,RID());
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),RID());
return mesh->surfaces[p_surface]->material;
}
int RasterizerStorageGLES3::mesh_surface_get_array_len(RID p_mesh, int p_surface) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,0);
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
return mesh->surfaces[p_surface]->array_len;
}
int RasterizerStorageGLES3::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,0);
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
return mesh->surfaces[p_surface]->index_array_len;
}
PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, int p_surface) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,PoolVector<uint8_t>());
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),PoolVector<uint8_t>());
Surface *surface = mesh->surfaces[p_surface];
glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
void * data = glMapBufferRange(GL_ARRAY_BUFFER,0,surface->array_byte_size,GL_MAP_READ_BIT);
ERR_FAIL_COND_V(!data,PoolVector<uint8_t>());
PoolVector<uint8_t> ret;
ret.resize(surface->array_byte_size);
{
PoolVector<uint8_t>::Write w = ret.write();
copymem(w.ptr(),data,surface->array_byte_size);
}
glUnmapBuffer(GL_ARRAY_BUFFER);
return ret;
}
PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_mesh, int p_surface) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,PoolVector<uint8_t>());
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),PoolVector<uint8_t>());
Surface *surface = mesh->surfaces[p_surface];
ERR_FAIL_COND_V(surface->index_array_len==0,PoolVector<uint8_t>());
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,surface->index_array_byte_size,GL_MAP_READ_BIT);
ERR_FAIL_COND_V(!data,PoolVector<uint8_t>());
PoolVector<uint8_t> ret;
ret.resize(surface->index_array_byte_size);
{
PoolVector<uint8_t>::Write w = ret.write();
copymem(w.ptr(),data,surface->index_array_byte_size);
}
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
return ret;
}
uint32_t RasterizerStorageGLES3::mesh_surface_get_format(RID p_mesh, int p_surface) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,0);
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
return mesh->surfaces[p_surface]->format;
}
VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,VS::PRIMITIVE_MAX);
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),VS::PRIMITIVE_MAX);
return mesh->surfaces[p_surface]->primitive;
}
Rect3 RasterizerStorageGLES3::mesh_surface_get_aabb(RID p_mesh, int p_surface) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,Rect3());
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Rect3());
return mesh->surfaces[p_surface]->aabb;
}
Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,Vector<PoolVector<uint8_t> >());
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<PoolVector<uint8_t> >());
Vector<PoolVector<uint8_t> > bsarr;
for(int i=0;i<mesh->surfaces[p_surface]->blend_shapes.size();i++) {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh->surfaces[p_surface]->blend_shapes[i].vertex_id);
void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,mesh->surfaces[p_surface]->array_byte_size,GL_MAP_READ_BIT);
ERR_FAIL_COND_V(!data,Vector<PoolVector<uint8_t> >());
PoolVector<uint8_t> ret;
ret.resize(mesh->surfaces[p_surface]->array_byte_size);
{
PoolVector<uint8_t>::Write w = ret.write();
copymem(w.ptr(),data,mesh->surfaces[p_surface]->array_byte_size);
}
bsarr.push_back(ret);
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
}
return bsarr;
}
Vector<Rect3> RasterizerStorageGLES3::mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,Vector<Rect3 >());
ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<Rect3 >());
return mesh->surfaces[p_surface]->skeleton_bone_aabb;
}
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());
Surface *surface = mesh->surfaces[p_surface];
if (surface->material.is_valid()) {
_material_remove_geometry(surface->material,mesh->surfaces[p_surface]);
}
glDeleteBuffers(1,&surface->vertex_id);
if (surface->index_id) {
glDeleteBuffers(1,&surface->index_id);
}
glDeleteVertexArrays(1,&surface->array_id);
for(int i=0;i<surface->blend_shapes.size();i++) {
glDeleteBuffers(1,&surface->blend_shapes[i].vertex_id);
glDeleteVertexArrays(1,&surface->blend_shapes[i].array_id);
}
mesh->instance_material_change_notify();
memdelete(surface);
mesh->surfaces.remove(p_surface);
mesh->instance_change_notify();
}
int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,0);
return mesh->surfaces.size();
}
void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh,const Rect3& p_aabb){
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
mesh->custom_aabb=p_aabb;
}
Rect3 RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const{
const Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND_V(!mesh,Rect3());
return mesh->custom_aabb;
}
Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
Mesh *mesh = mesh_owner.get( p_mesh );
ERR_FAIL_COND_V(!mesh,Rect3());
if (mesh->custom_aabb!=Rect3())
return mesh->custom_aabb;
Skeleton *sk=NULL;
if (p_skeleton.is_valid())
sk=skeleton_owner.get(p_skeleton);
Rect3 aabb;
if (sk && sk->size!=0) {
for (int i=0;i<mesh->surfaces.size();i++) {
Rect3 laabb;
if (mesh->surfaces[i]->format&VS::ARRAY_FORMAT_BONES && mesh->surfaces[i]->skeleton_bone_aabb.size()) {
int bs = mesh->surfaces[i]->skeleton_bone_aabb.size();
const Rect3 *skbones = mesh->surfaces[i]->skeleton_bone_aabb.ptr();
const bool *skused = mesh->surfaces[i]->skeleton_bone_used.ptr();
int sbs = sk->size;
ERR_CONTINUE(bs>sbs);
float *skb = sk->bones.ptr();
bool first=true;
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];
Rect3 baabb = mtx.xform( skbones[j] );
if (first) {
laabb=baabb;
first=false;
} else {
laabb.merge_with(baabb);
}
}
} else {
for(int j=0;j<bs;j++) {
if (!skused[j])
continue;
float *dataptr = &skb[12*j];
Transform mtx;
mtx.basis.elements[0][0]=dataptr[ 0];
mtx.basis.elements[0][1]=dataptr[ 1];
mtx.basis.elements[0][2]=dataptr[ 2];
mtx.origin.x=dataptr[ 3];
mtx.basis.elements[1][0]=dataptr[ 4];
mtx.basis.elements[1][1]=dataptr[ 5];
mtx.basis.elements[1][2]=dataptr[ 6];
mtx.origin.y=dataptr[ 7];
mtx.basis.elements[2][0]=dataptr[ 8];
mtx.basis.elements[2][1]=dataptr[ 9];
mtx.basis.elements[2][2]=dataptr[10];
mtx.origin.z=dataptr[11];
Rect3 baabb = mtx.xform ( skbones[j] );
if (first) {
laabb=baabb;
first=false;
} else {
laabb.merge_with(baabb);
}
}
}
} else {
laabb=mesh->surfaces[i]->aabb;
}
if (i==0)
aabb=laabb;
else
aabb.merge_with(laabb);
}
} else {
for (int i=0;i<mesh->surfaces.size();i++) {
if (i==0)
aabb=mesh->surfaces[i]->aabb;
else
aabb.merge_with(mesh->surfaces[i]->aabb);
}
}
return aabb;
}
void RasterizerStorageGLES3::mesh_clear(RID p_mesh){
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
while(mesh->surfaces.size()) {
mesh_remove_surface(p_mesh,0);
}
}
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;
int mtc = s->blend_shapes.size();
if (s->mesh->blend_shape_mode==VS::BLEND_SHAPE_MODE_NORMALIZED) {
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;
glBindVertexArray(s->blend_shapes[ti].array_id);
glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, resources.transform_feedback_buffers[1]);
shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT,weight);
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);
}
}
/* MULTIMESH API */
RID RasterizerStorageGLES3::multimesh_create(){
MultiMesh *multimesh = memnew( MultiMesh );
return multimesh_owner.make_rid(multimesh);
}
void RasterizerStorageGLES3::multimesh_allocate(RID p_multimesh, int p_instances, VS::MultimeshTransformFormat p_transform_format, VS::MultimeshColorFormat p_color_format){
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);
}
}
int RasterizerStorageGLES3::multimesh_get_instance_count(RID p_multimesh) const{
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND_V(!multimesh,0);
return multimesh->size;
}
void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
multimesh->mesh=p_mesh;
multimesh->dirty_aabb=true;
if (!multimesh->update_list.in_list()) {
multimesh_update_list.add(&multimesh->update_list);
}
}
void RasterizerStorageGLES3::multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform){
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);
}
}
void RasterizerStorageGLES3::multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Transform2D& p_transform){
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
ERR_FAIL_INDEX(p_index,multimesh->size);
ERR_FAIL_COND(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_3D);
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);
}
}
void RasterizerStorageGLES3::multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color){
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
ERR_FAIL_INDEX(p_index,multimesh->size);
ERR_FAIL_COND(multimesh->color_format==VS::MULTIMESH_COLOR_NONE);
int stride = multimesh->color_floats+multimesh->xform_floats;
float *dataptr=&multimesh->data[stride*p_index+multimesh->xform_floats];
if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
uint8_t *data8=(uint8_t*)dataptr;
data8[0]=CLAMP(p_color.r*255.0,0,255);
data8[1]=CLAMP(p_color.g*255.0,0,255);
data8[2]=CLAMP(p_color.b*255.0,0,255);
data8[3]=CLAMP(p_color.a*255.0,0,255);
} else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
dataptr[ 0]=p_color.r;
dataptr[ 1]=p_color.g;
dataptr[ 2]=p_color.b;
dataptr[ 3]=p_color.a;
}
multimesh->dirty_data=true;
multimesh->dirty_aabb=true;
if (!multimesh->update_list.in_list()) {
multimesh_update_list.add(&multimesh->update_list);
}
}
RID RasterizerStorageGLES3::multimesh_get_mesh(RID p_multimesh) const{
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND_V(!multimesh,RID());
return multimesh->mesh;
}
Transform RasterizerStorageGLES3::multimesh_instance_get_transform(RID p_multimesh,int p_index) const{
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND_V(!multimesh,Transform());
ERR_FAIL_INDEX_V(p_index,multimesh->size,Transform());
ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D,Transform());
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;
}
Transform2D RasterizerStorageGLES3::multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const{
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND_V(!multimesh,Transform2D());
ERR_FAIL_INDEX_V(p_index,multimesh->size,Transform2D());
ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_3D,Transform2D());
int stride = multimesh->color_floats+multimesh->xform_floats;
float *dataptr=&multimesh->data[stride*p_index];
Transform2D xform;
xform.elements[0][0]=dataptr[ 0];
xform.elements[1][0]=dataptr[ 1];
xform.elements[2][0]=dataptr[ 3];
xform.elements[0][1]=dataptr[ 4];
xform.elements[1][1]=dataptr[ 5];
xform.elements[2][1]=dataptr[ 7];
return xform;
}
Color RasterizerStorageGLES3::multimesh_instance_get_color(RID p_multimesh,int p_index) const{
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND_V(!multimesh,Color());
ERR_FAIL_INDEX_V(p_index,multimesh->size,Color());
ERR_FAIL_COND_V(multimesh->color_format==VS::MULTIMESH_COLOR_NONE,Color());
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;
return Color::hex(BSWAP32(cu.colu));
} else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
Color c;
c.r=dataptr[ 0];
c.g=dataptr[ 1];
c.b=dataptr[ 2];
c.a=dataptr[ 3];
return c;
}
return Color();
}
void RasterizerStorageGLES3::multimesh_set_visible_instances(RID p_multimesh,int p_visible){
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
multimesh->visible_instances=p_visible;
}
int RasterizerStorageGLES3::multimesh_get_visible_instances(RID p_multimesh) const{
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND_V(!multimesh,-1);
return multimesh->visible_instances;
}
Rect3 RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const{
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND_V(!multimesh,Rect3());
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) {
Rect3 mesh_aabb;
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();
Rect3 aabb;
if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
for(int i=0;i<count;i+=stride) {
float *dataptr=&data[i];
Transform xform;
xform.basis[0][0]=dataptr[ 0];
xform.basis[0][1]=dataptr[ 1];
xform.origin[0]=dataptr[ 3];
xform.basis[1][0]=dataptr[ 4];
xform.basis[1][1]=dataptr[ 5];
xform.origin[1]=dataptr[ 7];
Rect3 laabb = xform.xform(mesh_aabb);
if (i==0)
aabb=laabb;
else
aabb.merge_with(laabb);
}
} else {
for(int i=0;i<count;i+=stride) {
float *dataptr=&data[i];
Transform xform;
xform.basis.elements[0][0]=dataptr[ 0];
xform.basis.elements[0][1]=dataptr[ 1];
xform.basis.elements[0][2]=dataptr[ 2];
xform.origin.x=dataptr[ 3];
xform.basis.elements[1][0]=dataptr[ 4];
xform.basis.elements[1][1]=dataptr[ 5];
xform.basis.elements[1][2]=dataptr[ 6];
xform.origin.y=dataptr[ 7];
xform.basis.elements[2][0]=dataptr[ 8];
xform.basis.elements[2][1]=dataptr[ 9];
xform.basis.elements[2][2]=dataptr[10];
xform.origin.z=dataptr[11];
Rect3 laabb = xform.xform(mesh_aabb);
if (i==0)
aabb=laabb;
else
aabb.merge_with(laabb);
}
}
multimesh->aabb=aabb;
}
multimesh->dirty_aabb=false;
multimesh->dirty_data=false;
multimesh->instance_change_notify();
multimesh_update_list.remove(multimesh_update_list.first());
}
}
/* IMMEDIATE API */
RID RasterizerStorageGLES3::immediate_create() {
Immediate *im = memnew( Immediate );
return immediate_owner.make_rid(im);
}
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;
}
void RasterizerStorageGLES3::immediate_vertex(RID p_immediate,const Vector3& p_vertex){
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
Immediate::Chunk *c = &im->chunks.back()->get();
if (c->vertices.empty() && im->chunks.size()==1) {
im->aabb.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);
}
void RasterizerStorageGLES3::immediate_normal(RID p_immediate,const Vector3& p_normal){
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
im->mask|=VS::ARRAY_FORMAT_NORMAL;
chunk_normal=p_normal;
}
void RasterizerStorageGLES3::immediate_tangent(RID p_immediate,const Plane& p_tangent){
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
im->mask|=VS::ARRAY_FORMAT_TANGENT;
chunk_tangent=p_tangent;
}
void RasterizerStorageGLES3::immediate_color(RID p_immediate,const Color& p_color){
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
im->mask|=VS::ARRAY_FORMAT_COLOR;
chunk_color=p_color;
}
void RasterizerStorageGLES3::immediate_uv(RID p_immediate,const Vector2& tex_uv){
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
im->mask|=VS::ARRAY_FORMAT_TEX_UV;
chunk_uv=tex_uv;
}
void RasterizerStorageGLES3::immediate_uv2(RID p_immediate,const Vector2& tex_uv){
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
im->mask|=VS::ARRAY_FORMAT_TEX_UV2;
chunk_uv2=tex_uv;
}
void RasterizerStorageGLES3::immediate_end(RID p_immediate){
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
im->building=false;
im->instance_change_notify();
}
void RasterizerStorageGLES3::immediate_clear(RID p_immediate) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(im->building);
im->chunks.clear();
im->instance_change_notify();
}
Rect3 RasterizerStorageGLES3::immediate_get_aabb(RID p_immediate) const {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND_V(!im,Rect3());
return im->aabb;
}
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;
}
/* SKELETON API */
RID RasterizerStorageGLES3::skeleton_create(){
Skeleton *skeleton = memnew( Skeleton );
return skeleton_owner.make_rid(skeleton);
}
void RasterizerStorageGLES3::skeleton_allocate(RID p_skeleton,int p_bones,bool p_2d_skeleton){
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND(!skeleton);
ERR_FAIL_COND(p_bones<0);
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);
}
}
int RasterizerStorageGLES3::skeleton_get_bone_count(RID p_skeleton) const{
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND_V(!skeleton,0);
return skeleton->size;
}
void RasterizerStorageGLES3::skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform){
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);
}
}
Transform RasterizerStorageGLES3::skeleton_bone_get_transform(RID p_skeleton,int p_bone) const{
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND_V(!skeleton,Transform());
ERR_FAIL_INDEX_V(p_bone,skeleton->size,Transform());
ERR_FAIL_COND_V(skeleton->use_2d,Transform());
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;
}
void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Transform2D& p_transform){
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND(!skeleton);
ERR_FAIL_INDEX(p_bone,skeleton->size);
ERR_FAIL_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);
}
}
Transform2D RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const{
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND_V(!skeleton,Transform2D());
ERR_FAIL_INDEX_V(p_bone,skeleton->size,Transform2D());
ERR_FAIL_COND_V(!skeleton->use_2d,Transform2D());
Transform2D mtx;
float * bones = skeleton->bones.ptr();
mtx.elements[0][0]=bones[p_bone*12+ 0];
mtx.elements[1][0]=bones[p_bone*12+ 1];
mtx.elements[2][0]=bones[p_bone*12+ 3];
mtx.elements[0][1]=bones[p_bone*12+ 4];
mtx.elements[1][1]=bones[p_bone*12+ 5];
mtx.elements[2][1]=bones[p_bone*12+ 7];
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);
}
for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) {
E->get()->base_changed();
}
skeleton_update_list.remove(skeleton_update_list.first());
}
}
/* Light API */
RID RasterizerStorageGLES3::light_create(VS::LightType p_type){
Light *light = memnew( Light );
light->type=p_type;
light->param[VS::LIGHT_PARAM_ENERGY]=1.0;
light->param[VS::LIGHT_PARAM_SPECULAR]=0.5;
light->param[VS::LIGHT_PARAM_RANGE]=1.0;
light->param[VS::LIGHT_PARAM_SPOT_ANGLE]=45;
light->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE]=45;
light->param[VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE]=0;
light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET]=0.1;
light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET]=0.3;
light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET]=0.6;
light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS]=0.1;
light->param[VS::LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE]=0.1;
light->color=Color(1,1,1,1);
light->shadow=false;
light->negative=false;
light->cull_mask=0xFFFFFFFF;
light->directional_shadow_mode=VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL;
light->omni_shadow_mode=VS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID;
light->omni_shadow_detail=VS::LIGHT_OMNI_SHADOW_DETAIL_VERTICAL;
light->directional_blend_splits=false;
light->version=0;
return light_owner.make_rid(light);
}
void RasterizerStorageGLES3::light_set_color(RID p_light,const Color& p_color){
Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
light->color=p_color;
}
void RasterizerStorageGLES3::light_set_param(RID p_light,VS::LightParam p_param,float p_value){
Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
ERR_FAIL_INDEX(p_param,VS::LIGHT_PARAM_MAX);
switch(p_param) {
case VS::LIGHT_PARAM_RANGE:
case VS::LIGHT_PARAM_SPOT_ANGLE:
case VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE:
case VS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET:
case VS::LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET:
case VS::LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET:
case VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS:
case VS::LIGHT_PARAM_SHADOW_BIAS:
case VS::LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE: {
light->version++;
light->instance_change_notify();
} break;
}
light->param[p_param]=p_value;
}
void RasterizerStorageGLES3::light_set_shadow(RID p_light,bool p_enabled){
Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
light->shadow=p_enabled;
light->version++;
light->instance_change_notify();
}
void RasterizerStorageGLES3::light_set_shadow_color(RID p_light,const Color& p_color) {
Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
light->shadow_color=p_color;
}
void RasterizerStorageGLES3::light_set_projector(RID p_light,RID p_texture){
Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
light->projector=p_texture;
}
void RasterizerStorageGLES3::light_set_negative(RID p_light,bool p_enable){
Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
light->negative=p_enable;
}
void RasterizerStorageGLES3::light_set_cull_mask(RID p_light,uint32_t p_mask){
Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
light->cull_mask=p_mask;
light->version++;
light->instance_change_notify();
}
void RasterizerStorageGLES3::light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode) {
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();
}
void RasterizerStorageGLES3::light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode){
Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
light->directional_shadow_mode=p_mode;
light->version++;
light->instance_change_notify();
}
void RasterizerStorageGLES3::light_directional_set_blend_splits(RID p_light,bool p_enable) {
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;
}
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;
}
VS::LightType RasterizerStorageGLES3::light_get_type(RID p_light) const {
const Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL);
return light->type;
}
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];
}
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;
}
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;
}
Rect3 RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
const Light * light = light_owner.getornull(p_light);
ERR_FAIL_COND_V(!light,Rect3());
switch( light->type ) {
case VS::LIGHT_SPOT: {
float len=light->param[VS::LIGHT_PARAM_RANGE];
float size=Math::tan(Math::deg2rad(light->param[VS::LIGHT_PARAM_SPOT_ANGLE]))*len;
return Rect3( Vector3( -size,-size,-len ), Vector3( size*2, size*2, len ) );
} break;
case VS::LIGHT_OMNI: {
float r = light->param[VS::LIGHT_PARAM_RANGE];
return Rect3( -Vector3(r,r,r), Vector3(r,r,r)*2 );
} break;
case VS::LIGHT_DIRECTIONAL: {
return Rect3();
} break;
default: {}
}
ERR_FAIL_V( Rect3() );
return Rect3();
}
/* PROBE API */
RID RasterizerStorageGLES3::reflection_probe_create(){
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);
}
void RasterizerStorageGLES3::reflection_probe_set_update_mode(RID p_probe, VS::ReflectionProbeUpdateMode p_mode) {
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();
}
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;
}
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();
}
void RasterizerStorageGLES3::reflection_probe_set_extents(RID p_probe, const Vector3& p_extents){
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
reflection_probe->extents=p_extents;
reflection_probe->instance_change_notify();
}
void RasterizerStorageGLES3::reflection_probe_set_origin_offset(RID p_probe, const Vector3& p_offset){
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
reflection_probe->origin_offset=p_offset;
reflection_probe->instance_change_notify();
}
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;
}
void RasterizerStorageGLES3::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable){
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
reflection_probe->box_projection=p_enable;
}
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();
}
void RasterizerStorageGLES3::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers){
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
reflection_probe->cull_mask=p_layers;
reflection_probe->instance_change_notify();
}
Rect3 RasterizerStorageGLES3::reflection_probe_get_aabb(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND_V(!reflection_probe,Rect3());
Rect3 aabb;
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;
}
/* ROOM API */
RID RasterizerStorageGLES3::room_create(){
return RID();
}
void RasterizerStorageGLES3::room_add_bounds(RID p_room, const PoolVector<Vector2>& p_convex_polygon,float p_height,const Transform& p_transform){
}
void RasterizerStorageGLES3::room_clear_bounds(RID p_room){
}
/* 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){
}
RID RasterizerStorageGLES3::gi_probe_create() {
GIProbe *gip = memnew( GIProbe );
gip->bounds=Rect3(Vector3(),Vector3(1,1,1));
gip->dynamic_range=1.0;
gip->energy=1.0;
gip->propagation=1.0;
gip->interior=false;
gip->compress=false;
gip->version=1;
gip->cell_size=1.0;
return gi_probe_owner.make_rid(gip);
}
void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe,const Rect3& p_bounds){
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
gip->bounds=p_bounds;
gip->version++;
gip->instance_change_notify();
}
Rect3 RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const{
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND_V(!gip,Rect3());
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;
}
void RasterizerStorageGLES3::gi_probe_set_dynamic_data(RID p_probe,const PoolVector<int>& p_data){
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
gip->dynamic_data=p_data;
gip->version++;
gip->instance_change_notify();
}
PoolVector<int> RasterizerStorageGLES3::gi_probe_get_dynamic_data(RID p_probe) const{
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND_V(!gip,PoolVector<int>());
return gip->dynamic_data;
}
void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe,int p_range){
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
gip->dynamic_range=p_range;
}
int RasterizerStorageGLES3::gi_probe_get_dynamic_range(RID p_probe) const{
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND_V(!gip,0);
return gip->dynamic_range;
}
void RasterizerStorageGLES3::gi_probe_set_energy(RID p_probe,float p_range){
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
gip->energy=p_range;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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) {
GIProbeData *gipd = memnew( GIProbeData );
gipd->width=p_width;
gipd->height=p_height;
gipd->depth=p_depth;
gipd->compression=p_compression;
glActiveTexture(GL_TEXTURE0);
glGenTextures(1,&gipd->tex_id);
glBindTexture(GL_TEXTURE_3D,gipd->tex_id);
int level=0;
int min_size=1;
if (gipd->compression==GI_PROBE_S3TC) {
min_size=4;
}
print_line("dyndata create");
while(true) {
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);
}
if (p_width<=min_size || p_height<=min_size || p_depth<=min_size)
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);
}
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) {
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);
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);
}
//glTexImage3D(GL_TEXTURE_3D,p_mipmap,GL_RGBA8,gipd->width>>p_mipmap,gipd->height>>p_mipmap,gipd->depth>>p_mipmap,0,GL_RGBA,GL_UNSIGNED_BYTE,p_data);
//glTexImage3D(GL_TEXTURE_3D,p_mipmap,GL_RGBA8,gipd->width>>p_mipmap,gipd->height>>p_mipmap,gipd->depth>>p_mipmap,0,GL_RGBA,GL_UNSIGNED_BYTE,data.ptr());
}
///////
RID RasterizerStorageGLES3::particles_create() {
Particles *particles = memnew( Particles );
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);
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);
}
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;
}
void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles,const Rect3& p_aabb) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
particles->custom_aabb=p_aabb;
}
void RasterizerStorageGLES3::particles_set_gravity(RID p_particles,const Vector3& p_gravity) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
particles->gravity=p_gravity;
}
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;
}
void RasterizerStorageGLES3::particles_set_emission_points(RID p_particles,const PoolVector<Vector3>& p_points) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
particles->emission_points=p_points;
}
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());
particles->draw_passes[p_pass].material=p_material;
}
void RasterizerStorageGLES3::particles_set_draw_pass_mesh(RID p_particles,int p_pass, RID p_mesh) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
ERR_FAIL_INDEX(p_pass,particles->draw_passes.size());
particles->draw_passes[p_pass].mesh=p_mesh;
}
Rect3 RasterizerStorageGLES3::particles_get_current_aabb(RID p_particles) {
const Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND_V(!particles,Rect3());
return particles->computed_aabb;
}
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);
float new_phase = Math::fmod((float)particles->phase+(frame.delta/particles->lifetime),(float)1.0);
shaders.particles.set_uniform(ParticlesShaderGLES3::SYSTEM_PHASE,new_phase);
shaders.particles.set_uniform(ParticlesShaderGLES3::PREV_SYSTEM_PHASE,particles->phase);
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);
}
}
////////
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);
}
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;
case VS::INSTANCE_MULTIMESH: {
inst = multimesh_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
case VS::INSTANCE_IMMEDIATE: {
inst = immediate_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
case VS::INSTANCE_REFLECTION_PROBE: {
inst = reflection_probe_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
case VS::INSTANCE_LIGHT: {
inst = light_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
case VS::INSTANCE_GI_PROBE: {
inst = gi_probe_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
default: {
if (!inst) {
ERR_FAIL();
}
}
}
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;
case VS::INSTANCE_MULTIMESH: {
inst = multimesh_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
case VS::INSTANCE_IMMEDIATE: {
inst = immediate_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
case VS::INSTANCE_REFLECTION_PROBE: {
inst = reflection_probe_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
case VS::INSTANCE_LIGHT: {
inst = light_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
case VS::INSTANCE_GI_PROBE: {
inst = gi_probe_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
} break;
default: {
if (!inst) {
ERR_FAIL();
}
}
}
ERR_FAIL_COND(!inst);
inst->instance_list.remove( &p_instance->dependency_item );
}
/* RENDER TARGET */
void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
if (rt->fbo) {
glDeleteFramebuffers(1,&rt->fbo);
glDeleteTextures(1,&rt->color);
rt->fbo=0;
}
if (rt->buffers.fbo) {
glDeleteFramebuffers(1,&rt->buffers.fbo);
glDeleteRenderbuffers(1,&rt->buffers.depth);
glDeleteRenderbuffers(1,&rt->buffers.diffuse);
glDeleteRenderbuffers(1,&rt->buffers.specular);
glDeleteRenderbuffers(1,&rt->buffers.normal_rough);
glDeleteRenderbuffers(1,&rt->buffers.motion_sss);
glDeleteFramebuffers(1,&rt->buffers.effect_fbo);
glDeleteTextures(1,&rt->buffers.effect);
rt->buffers.fbo=0;
}
if (rt->depth) {
glDeleteTextures(1,&rt->depth);
rt->depth=0;
}
if (rt->effects.ssao.blur_fbo[0]) {
glDeleteFramebuffers(1,&rt->effects.ssao.blur_fbo[0]);
glDeleteTextures(1,&rt->effects.ssao.blur_red[0]);
glDeleteFramebuffers(1,&rt->effects.ssao.blur_fbo[1]);
glDeleteTextures(1,&rt->effects.ssao.blur_red[1]);
for(int i=0;i<rt->effects.ssao.depth_mipmap_fbos.size();i++) {
glDeleteFramebuffers(1,&rt->effects.ssao.depth_mipmap_fbos[i]);
}
rt->effects.ssao.depth_mipmap_fbos.clear();
glDeleteTextures(1,&rt->effects.ssao.linear_depth);
rt->effects.ssao.blur_fbo[0]=0;
rt->effects.ssao.blur_fbo[1]=0;
}
if (rt->exposure.fbo) {
glDeleteFramebuffers(1,&rt->exposure.fbo);
glDeleteTextures(1,&rt->exposure.color);
rt->exposure.fbo=0;
}
Texture *tex = texture_owner.get(rt->texture);
tex->alloc_height=0;
tex->alloc_width=0;
tex->width=0;
tex->height=0;
for(int i=0;i<2;i++) {
for(int j=0;j<rt->effects.mip_maps[i].sizes.size();j++) {
glDeleteFramebuffers(1,&rt->effects.mip_maps[i].sizes[j].fbo);
}
glDeleteTextures(1,&rt->effects.mip_maps[i].color);
rt->effects.mip_maps[i].sizes.clear();
rt->effects.mip_maps[i].levels=0;
}
/*
if (rt->effects.screen_space_depth) {
glDeleteTextures(1,&rt->effects.screen_space_depth);
rt->effects.screen_space_depth=0;
}
*/
}
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;
Image::Format image_format;
if (!rt->flags[RENDER_TARGET_HDR] || rt->flags[RENDER_TARGET_NO_3D]) {
color_internal_format=GL_RGBA8;
color_format=GL_RGBA;
color_type=GL_UNSIGNED_BYTE;
image_format=Image::FORMAT_RGBA8;
} else {
color_internal_format=GL_RGBA16F;
color_format=GL_RGBA;
color_type=GL_HALF_FLOAT;
image_format=Image::FORMAT_RGBAH;
}
{
/* FRONT FBO */
glActiveTexture(GL_TEXTURE0);
glGenFramebuffers(1, &rt->fbo);
glBindFramebuffer(GL_FRAMEBUFFER, rt->fbo);
glGenTextures(1, &rt->depth);
glBindTexture(GL_TEXTURE_2D, rt->depth);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_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);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_TEXTURE_2D, rt->depth, 0);
glGenTextures(1, &rt->color);
glBindTexture(GL_TEXTURE_2D, rt->color);
glTexImage2D(GL_TEXTURE_2D, 0, color_internal_format, rt->width, rt->height, 0, color_format, color_type, NULL);
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->color, 0);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
Texture *tex = texture_owner.get(rt->texture);
tex->format=image_format;
tex->gl_format_cache=color_format;
tex->gl_type_cache=color_type;
tex->gl_internal_format_cache=color_internal_format;
tex->tex_id=rt->color;
tex->width=rt->width;
tex->alloc_width=rt->width;
tex->height=rt->height;
tex->alloc_height=rt->height;
texture_set_flags(rt->texture,tex->flags);
}
/* BACK FBO */
if (config.render_arch==RENDER_ARCH_DESKTOP && !rt->flags[RENDER_TARGET_NO_3D]) {
static const int msaa_value[]={0,2,4,8,16};
int msaa=msaa_value[rt->msaa];
//regular fbo
glGenFramebuffers(1, &rt->buffers.fbo);
glBindFramebuffer(GL_FRAMEBUFFER, rt->buffers.fbo);
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);
glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,rt->buffers.depth);
glGenRenderbuffers(1, &rt->buffers.diffuse);
glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.diffuse);
if (msaa==0)
glRenderbufferStorage(GL_RENDERBUFFER,color_internal_format,rt->width,rt->height);
else
glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA16F,rt->width,rt->height);
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);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
if (status != GL_FRAMEBUFFER_COMPLETE) {
printf("err status: %x\n",status);
_render_target_clear(rt);
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
}
glBindRenderbuffer(GL_RENDERBUFFER,0);
// effect resolver
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);
if (status != GL_FRAMEBUFFER_COMPLETE) {
printf("err status: %x\n",status);
_render_target_clear(rt);
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
}
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
if (status != GL_FRAMEBUFFER_COMPLETE) {
_render_target_clear(rt);
ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
}
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);
int level=0;
while(true) {
RenderTarget::Effects::MipMaps::Size mm;
glTexImage2D(GL_TEXTURE_2D, level, color_internal_format, w, h, 0, color_format, color_type, NULL);
mm.width=w;
mm.height=h;
rt->effects.mip_maps[i].sizes.push_back(mm);
w>>=1;
h>>=1;
if (w<2 || h<2)
break;
level++;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level);
for(int j=0;j<rt->effects.mip_maps[i].sizes.size();j++) {
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);
}
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
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);
}
///////////////// 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);
}
//////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 );
}
}
}
RID RasterizerStorageGLES3::render_target_create(){
RenderTarget *rt = memnew( RenderTarget );
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);
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());
return rt->texture;
}
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;
}
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);
}
/* 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);
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
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);
}
void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2>& p_lines) {
CanvasOccluder *co = canvas_occluder_owner.get(p_occluder);
ERR_FAIL_COND(!co);
co->lines=p_lines;
if (p_lines.size()!=co->len) {
if (co->index_id)
glDeleteBuffers(1,&co->index_id);
if (co->vertex_id)
glDeleteBuffers(1,&co->vertex_id);
co->index_id=0;
co->vertex_id=0;
co->len=0;
}
if (p_lines.size()) {
PoolVector<float> geometry;
PoolVector<uint16_t> indices;
int lc = p_lines.size();
geometry.resize(lc*6);
indices.resize(lc*3);
PoolVector<float>::Write vw=geometry.write();
PoolVector<uint16_t>::Write iw=indices.write();
PoolVector<Vector2>::Read lr=p_lines.read();
const int POLY_HEIGHT = 16384;
for(int i=0;i<lc/2;i++) {
vw[i*12+0]=lr[i*2+0].x;
vw[i*12+1]=lr[i*2+0].y;
vw[i*12+2]=POLY_HEIGHT;
vw[i*12+3]=lr[i*2+1].x;
vw[i*12+4]=lr[i*2+1].y;
vw[i*12+5]=POLY_HEIGHT;
vw[i*12+6]=lr[i*2+1].x;
vw[i*12+7]=lr[i*2+1].y;
vw[i*12+8]=-POLY_HEIGHT;
vw[i*12+9]=lr[i*2+0].x;
vw[i*12+10]=lr[i*2+0].y;
vw[i*12+11]=-POLY_HEIGHT;
iw[i*6+0]=i*4+0;
iw[i*6+1]=i*4+1;
iw[i*6+2]=i*4+2;
iw[i*6+3]=i*4+2;
iw[i*6+4]=i*4+3;
iw[i*6+5]=i*4+0;
}
//if same buffer len is being set, just use BufferSubData to avoid a pipeline flush
if (!co->vertex_id) {
glGenBuffers(1,&co->vertex_id);
glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
glBufferData(GL_ARRAY_BUFFER,lc*6*sizeof(real_t),vw.ptr(),GL_STATIC_DRAW);
} else {
glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
glBufferSubData(GL_ARRAY_BUFFER,0,lc*6*sizeof(real_t),vw.ptr());
}
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
if (!co->index_id) {
glGenBuffers(1,&co->index_id);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,co->index_id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,lc*3*sizeof(uint16_t),iw.ptr(),GL_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;
}
}
VS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const {
if (mesh_owner.owns(p_rid)) {
return VS::INSTANCE_MESH;
}
if (multimesh_owner.owns(p_rid)) {
return VS::INSTANCE_MULTIMESH;
}
if (immediate_owner.owns(p_rid)) {
return VS::INSTANCE_IMMEDIATE;
}
if (light_owner.owns(p_rid)) {
return VS::INSTANCE_LIGHT;
}
if (reflection_probe_owner.owns(p_rid)) {
return VS::INSTANCE_REFLECTION_PROBE;
}
if (gi_probe_owner.owns(p_rid)) {
return VS::INSTANCE_GI_PROBE;
}
return VS::INSTANCE_NONE;
}
bool RasterizerStorageGLES3::free(RID p_rid){
if (render_target_owner.owns(p_rid)) {
RenderTarget *rt = render_target_owner.getornull(p_rid);
_render_target_clear(rt);
Texture *t=texture_owner.get(rt->texture);
texture_owner.free(rt->texture);
memdelete(t);
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);
ERR_FAIL_COND_V(texture->render_target,true); //cant free the render target texture, dude
info.texture_mem-=texture->total_data_size;
texture_owner.free(p_rid);
memdelete(texture);
} else if (skybox_owner.owns(p_rid)) {
// delete the skybox
SkyBox *skybox = skybox_owner.get(p_rid);
skybox_set_texture(p_rid,RID(),256);
skybox_owner.free(p_rid);
memdelete(skybox);
} else if (shader_owner.owns(p_rid)) {
// delete the texture
Shader *shader = shader_owner.get(p_rid);
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);
}
//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();
}
}
}
material_owner.free(p_rid);
memdelete(material);
} 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);
}
for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) {
E->get()->skeleton=RID();
}
skeleton_allocate(p_rid,0,false);
skeleton_owner.free(p_rid);
memdelete(skeleton);
} else if (mesh_owner.owns(p_rid)) {
// delete the texture
Mesh *mesh = mesh_owner.get(p_rid);
mesh->instance_remove_deps();
mesh_clear(p_rid);
mesh_owner.free(p_rid);
memdelete(mesh);
} else if (multimesh_owner.owns(p_rid)) {
// delete the texture
MultiMesh *multimesh = multimesh_owner.get(p_rid);
multimesh->instance_remove_deps();
multimesh_allocate(p_rid,0,VS::MULTIMESH_TRANSFORM_2D,VS::MULTIMESH_COLOR_NONE); //frees multimesh
update_dirty_multimeshes();
multimesh_owner.free(p_rid);
memdelete(multimesh);
} else if (immediate_owner.owns(p_rid)) {
Immediate *immediate = immediate_owner.get(p_rid);
immediate->instance_remove_deps();
immediate_owner.free(p_rid);
memdelete(immediate);
} else if (light_owner.owns(p_rid)) {
// delete the texture
Light *light = light_owner.get(p_rid);
light->instance_remove_deps();
light_owner.free(p_rid);
memdelete(light);
} 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);
} 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);
} 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;
}
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;
}
////////////////////////////////////////////
void RasterizerStorageGLES3::initialize() {
config.render_arch=RENDER_ARCH_DESKTOP;
//config.fbo_deferred=int(Globals::get_singleton()->get("rendering/gles3/lighting_technique"));
RasterizerStorageGLES3::system_fbo=0;
//// extensions config
///
{
int max_extensions=0;
print_line("getting extensions");
glGetIntegerv(GL_NUM_EXTENSIONS,&max_extensions);
print_line("total "+itos(max_extensions));
for(int i=0;i<max_extensions;i++) {
const GLubyte *s = glGetStringi( GL_EXTENSIONS,i );
if (!s)
break;
config.extensions.insert((const char*)s);
}
}
config.shrink_textures_x2=false;
config.use_fast_texture_filter=int(GlobalConfig::get_singleton()->get("rendering/quality/use_nearest_mipmap_filter"));
config.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");
#ifdef GLES_OVER_GL
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);
config.anisotropic_level=MIN(int(GlobalConfig::get_singleton()->get("rendering/quality/anisotropic_filter_level")),config.anisotropic_level);
}
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];
for(int i=0;i<8*8*3;i++) {
blacktexdata[i]=0;
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,resources.black_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,blacktexdata);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,0);
glGenTextures(1, &resources.normal_tex);
unsigned char normaltexdata[8*8*3];
for(int i=0;i<8*8*3;i+=3) {
normaltexdata[i+0]=128;
normaltexdata[i+1]=128;
normaltexdata[i+2]=255;
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,resources.normal_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,normaltexdata);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,0);
glGenTextures(1, &resources.aniso_tex);
unsigned char anisotexdata[8*8*3];
for(int i=0;i<8*8*3;i+=3) {
anisotexdata[i+0]=255;
anisotexdata[i+1]=128;
anisotexdata[i+2]=0;
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,resources.aniso_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,anisotexdata);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,0);
}
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&config.max_texture_image_units);
glGetIntegerv(GL_MAX_TEXTURE_SIZE,&config.max_texture_size);
#ifdef GLES_OVER_GL
config.use_rgba_2d_shadows=false;
#else
config.use_rgba_2d_shadows=true;
#endif
//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);
glVertexAttribPointer(VS::ARRAY_VERTEX,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(VS::ARRAY_TEX_UV,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,((uint8_t*)NULL)+8);
glEnableVertexAttribArray(4);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
}
//generic quadie for copying without touching skybox
{
//transform feedback buffers
uint32_t xf_feedback_size = GLOBAL_DEF("rendering/buffers/blend_shape_max_buffer_size_kb",4096);
for(int i=0;i<2;i++) {
glGenBuffers(1,&resources.transform_feedback_buffers[i]);
glBindBuffer(GL_ARRAY_BUFFER,resources.transform_feedback_buffers[i]);
glBufferData(GL_ARRAY_BUFFER,xf_feedback_size*1024,NULL,GL_STREAM_DRAW);
}
shaders.blend_shapes.init();
glGenVertexArrays(1,&resources.transform_feedback_array);
}
shaders.cubemap_filter.init();
shaders.particles.init();
glEnable(_EXT_TEXTURE_CUBE_MAP_SEAMLESS);
frame.count=0;
frame.prev_tick=0;
frame.delta=0;
config.keep_original_textures=false;
}
void RasterizerStorageGLES3::finalize() {
glDeleteTextures(1, &resources.white_tex);
glDeleteTextures(1, &resources.black_tex);
glDeleteTextures(1, &resources.normal_tex);
}
RasterizerStorageGLES3::RasterizerStorageGLES3()
{
}
Reference in New Issue View Git Blame Copy Permalink