From d27428406922697382348ca1b769805db20a5310 Mon Sep 17 00:00:00 2001 From: Omar El Sheikh Date: Mon, 8 Mar 2021 12:58:13 -0500 Subject: [PATCH] Octahedral Normal/Tangent Compression Implement Octahedral Compression for normal/tangent vectors *Oct32 for uncompressed vectors *Oct16 for compressed vectors Reduces vertex size for each attribute by *Uncompressed: 12 bytes, vec4 -> vec2 *Compressed: 2 bytes, vec4 -> vec2 Binormal sign is encoded in the y coordinate of the encoded tangent Added conversion functions to go from octahedral mapping to cartesian for normal and tangent vectors sprite_3d and soft_body meshes write to their vertex buffer memory directly and need to convert their normals and tangents to the new oct format before writing Created a new mesh flag to specify whether a mesh is using octahedral compression or not Updated documentation to discuss new flag/defaults Created shader flags to specify whether octahedral or cartesian vectors are being used Updated importers to use octahedral representation as the default format for importing meshes Updated ShaderGLES2 to support 64 bit version codes as we hit the limit of the 32-bit integer that was previously used as a bitset to store enabled/disabled flags --- doc/classes/ArrayMesh.xml | 2 +- doc/classes/Mesh.xml | 7 +- doc/classes/SurfaceTool.xml | 4 +- doc/classes/VisualServer.xml | 9 +- drivers/gles2/rasterizer_scene_gles2.cpp | 10 + drivers/gles2/rasterizer_storage_gles2.cpp | 96 ++++-- drivers/gles2/shader_gles2.cpp | 8 +- drivers/gles2/shader_gles2.h | 22 +- drivers/gles2/shaders/scene.glsl | 26 ++ drivers/gles3/rasterizer_scene_gles3.cpp | 9 + drivers/gles3/rasterizer_storage_gles3.cpp | 56 +++- drivers/gles3/shaders/scene.glsl | 27 +- editor/import/editor_import_collada.cpp | 2 +- editor/import/resource_importer_obj.cpp | 2 +- modules/fbx/data/fbx_mesh_data.cpp | 2 +- scene/3d/soft_body.cpp | 7 +- scene/3d/sprite_3d.cpp | 44 ++- scene/resources/mesh.cpp | 1 + scene/resources/mesh.h | 3 +- servers/visual_server.cpp | 353 ++++++++++++++++----- servers/visual_server.h | 7 +- 21 files changed, 529 insertions(+), 168 deletions(-) diff --git a/doc/classes/ArrayMesh.xml b/doc/classes/ArrayMesh.xml index 03123097490b..9461fe90a2c4 100644 --- a/doc/classes/ArrayMesh.xml +++ b/doc/classes/ArrayMesh.xml @@ -47,7 +47,7 @@ - + Creates a new surface. diff --git a/doc/classes/Mesh.xml b/doc/classes/Mesh.xml index 78bd3106ece4..fbf0233074ce 100644 --- a/doc/classes/Mesh.xml +++ b/doc/classes/Mesh.xml @@ -207,8 +207,11 @@ Flag used to mark that the array uses 16-bit bones instead of 8-bit. - - Used to set flags [constant ARRAY_COMPRESS_VERTEX], [constant ARRAY_COMPRESS_NORMAL], [constant ARRAY_COMPRESS_TANGENT], [constant ARRAY_COMPRESS_COLOR], [constant ARRAY_COMPRESS_TEX_UV], [constant ARRAY_COMPRESS_TEX_UV2] and [constant ARRAY_COMPRESS_WEIGHTS] quickly. + + Flag used to mark that the array uses an octahedral representation of normal and tangent vectors rather than cartesian. + + + Used to set flags [constant ARRAY_COMPRESS_VERTEX], [constant ARRAY_COMPRESS_NORMAL], [constant ARRAY_COMPRESS_TANGENT], [constant ARRAY_COMPRESS_COLOR], [constant ARRAY_COMPRESS_TEX_UV], [constant ARRAY_COMPRESS_TEX_UV2], [constant ARRAY_COMPRESS_WEIGHTS], and [constant ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION] quickly. Array of vertices. diff --git a/doc/classes/SurfaceTool.xml b/doc/classes/SurfaceTool.xml index 77afc403013f..02f5fc9c5262 100644 --- a/doc/classes/SurfaceTool.xml +++ b/doc/classes/SurfaceTool.xml @@ -167,11 +167,11 @@ - + Returns a constructed [ArrayMesh] from current information passed in. If an existing [ArrayMesh] is passed in as an argument, will add an extra surface to the existing [ArrayMesh]. - Default flag is [constant Mesh.ARRAY_COMPRESS_DEFAULT]. See [code]ARRAY_COMPRESS_*[/code] constants in [enum Mesh.ArrayFormat] for other flags. + Default flag is [constant Mesh.ARRAY_COMPRESS_DEFAULT] if compression is enabled. If compression is disabled the default flag is [constant Mesh.ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION]. See [code]ARRAY_COMPRESS_*[/code] constants in [enum Mesh.ArrayFormat] for other flags. diff --git a/doc/classes/VisualServer.xml b/doc/classes/VisualServer.xml index 8ec4baf8f101..34528ef47a8e 100644 --- a/doc/classes/VisualServer.xml +++ b/doc/classes/VisualServer.xml @@ -2518,7 +2518,7 @@ - + Adds a surface generated from the Arrays to a mesh. See [enum PrimitiveType] constants for types. @@ -4489,8 +4489,11 @@ Flag used to mark that the array uses 16-bit bones instead of 8-bit. - - Used to set flags [constant ARRAY_COMPRESS_NORMAL], [constant ARRAY_COMPRESS_TANGENT], [constant ARRAY_COMPRESS_COLOR], [constant ARRAY_COMPRESS_TEX_UV], [constant ARRAY_COMPRESS_TEX_UV2] and [constant ARRAY_COMPRESS_WEIGHTS] quickly. + + Flag used to mark that the array uses an octahedral representation of normal and tangent vectors rather than cartesian. + + + Used to set flags [constant ARRAY_COMPRESS_NORMAL], [constant ARRAY_COMPRESS_TANGENT], [constant ARRAY_COMPRESS_COLOR], [constant ARRAY_COMPRESS_TEX_UV], [constant ARRAY_COMPRESS_TEX_UV2], [constant ARRAY_COMPRESS_WEIGHTS], and [constant ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION] quickly. Primitive to draw consists of points. diff --git a/drivers/gles2/rasterizer_scene_gles2.cpp b/drivers/gles2/rasterizer_scene_gles2.cpp index f6d12371aa51..9574d8f2809e 100644 --- a/drivers/gles2/rasterizer_scene_gles2.cpp +++ b/drivers/gles2/rasterizer_scene_gles2.cpp @@ -2417,6 +2417,8 @@ void RasterizerSceneGLES2::_render_render_list(RenderList::Element **p_elements, RasterizerStorageGLES2::Skeleton *prev_skeleton = nullptr; RasterizerStorageGLES2::GeometryOwner *prev_owner = nullptr; + bool prev_octahedral_compression = false; + Transform view_transform_inverse = p_view_transform.inverse(); CameraMatrix projection_inverse = p_projection.inverse(); @@ -2666,6 +2668,12 @@ void RasterizerSceneGLES2::_render_render_list(RenderList::Element **p_elements, storage->info.render.surface_switch_count++; } + bool octahedral_compression = ((RasterizerStorageGLES2::Surface *)e->geometry)->format & VisualServer::ArrayFormat::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION; + if (octahedral_compression != prev_octahedral_compression) { + state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_OCTAHEDRAL_COMPRESSION, octahedral_compression); + rebind = true; + } + bool shader_rebind = false; if (rebind || material != prev_material) { storage->info.render.material_switch_count++; @@ -2783,6 +2791,7 @@ void RasterizerSceneGLES2::_render_render_list(RenderList::Element **p_elements, prev_material = material; prev_skeleton = skeleton; prev_instancing = instancing; + prev_octahedral_compression = octahedral_compression; prev_light = light; prev_refprobe_1 = refprobe_1; prev_refprobe_2 = refprobe_2; @@ -2791,6 +2800,7 @@ void RasterizerSceneGLES2::_render_render_list(RenderList::Element **p_elements, } _setup_light_type(nullptr, nullptr); //clear light stuff + state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_OCTAHEDRAL_COMPRESSION, false); state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON, false); state.scene_shader.set_conditional(SceneShaderGLES2::SHADELESS, false); state.scene_shader.set_conditional(SceneShaderGLES2::BASE_PASS, false); diff --git a/drivers/gles2/rasterizer_storage_gles2.cpp b/drivers/gles2/rasterizer_storage_gles2.cpp index 17a59c0fdabf..42aea361800c 100644 --- a/drivers/gles2/rasterizer_storage_gles2.cpp +++ b/drivers/gles2/rasterizer_storage_gles2.cpp @@ -2098,22 +2098,42 @@ static PoolVector _unpack_half_floats(const PoolVector &array, } break; case VS::ARRAY_NORMAL: { - if (p_format & VS::ARRAY_COMPRESS_NORMAL) { - src_size[i] = 4; - dst_size[i] = 4; + if (p_format & VS::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_format & VS::ARRAY_COMPRESS_NORMAL) { + src_size[i] = 2; + dst_size[i] = 2; + } else { + src_size[i] = 4; + dst_size[i] = 4; + } } else { - src_size[i] = 12; - dst_size[i] = 12; + if (p_format & VS::ARRAY_COMPRESS_NORMAL) { + src_size[i] = 4; + dst_size[i] = 4; + } else { + src_size[i] = 12; + dst_size[i] = 12; + } } } break; case VS::ARRAY_TANGENT: { - if (p_format & VS::ARRAY_COMPRESS_TANGENT) { - src_size[i] = 4; - dst_size[i] = 4; + if (p_format & VS::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_format & VS::ARRAY_COMPRESS_TANGENT) { + src_size[i] = 2; + dst_size[i] = 2; + } else { + src_size[i] = 4; + dst_size[i] = 4; + } } else { - src_size[i] = 16; - dst_size[i] = 16; + if (p_format & VS::ARRAY_COMPRESS_TANGENT) { + src_size[i] = 4; + dst_size[i] = 4; + } else { + src_size[i] = 16; + dst_size[i] = 16; + } } } break; @@ -2288,30 +2308,54 @@ void RasterizerStorageGLES2::mesh_add_surface(RID p_mesh, uint32_t p_format, VS: } break; case VS::ARRAY_NORMAL: { - attribs[i].size = 3; - - if (p_format & VS::ARRAY_COMPRESS_NORMAL) { - attribs[i].type = GL_BYTE; - attributes_stride += 4; //pad extra byte + if (p_format & VS::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { attribs[i].normalized = GL_TRUE; + attribs[i].size = 2; + if (p_format & VS::ARRAY_COMPRESS_NORMAL) { + attribs[i].type = GL_BYTE; + attributes_stride += 2; + } else { + attribs[i].type = GL_SHORT; + attributes_stride += 4; + } } else { - attribs[i].type = GL_FLOAT; - attributes_stride += 12; - attribs[i].normalized = GL_FALSE; + attribs[i].size = 3; + + if (p_format & VS::ARRAY_COMPRESS_NORMAL) { + attribs[i].type = GL_BYTE; + attributes_stride += 4; //pad extra byte + attribs[i].normalized = GL_TRUE; + } else { + attribs[i].type = GL_FLOAT; + attributes_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; - attributes_stride += 4; + if (p_format & VS::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { attribs[i].normalized = GL_TRUE; + attribs[i].size = 2; + if (p_format & VS::ARRAY_COMPRESS_TANGENT) { + attribs[i].type = GL_BYTE; + attributes_stride += 2; + } else { + attribs[i].type = GL_SHORT; + attributes_stride += 4; + } } else { - attribs[i].type = GL_FLOAT; - attributes_stride += 16; - attribs[i].normalized = GL_FALSE; + attribs[i].size = 4; + + if (p_format & VS::ARRAY_COMPRESS_TANGENT) { + attribs[i].type = GL_BYTE; + attributes_stride += 4; + attribs[i].normalized = GL_TRUE; + } else { + attribs[i].type = GL_FLOAT; + attributes_stride += 16; + attribs[i].normalized = GL_FALSE; + } } } break; diff --git a/drivers/gles2/shader_gles2.cpp b/drivers/gles2/shader_gles2.cpp index 845a1d5e0bc2..09ccfcc47375 100644 --- a/drivers/gles2/shader_gles2.cpp +++ b/drivers/gles2/shader_gles2.cpp @@ -195,7 +195,7 @@ ShaderGLES2::Version *ShaderGLES2::get_current_version() { } for (int j = 0; j < conditional_count; j++) { - bool enable = (conditional_version.version & (1 << j)) > 0; + bool enable = (conditional_version.version & (uint64_t(1) << j)) > 0; if (enable) { strings.push_back(conditional_defines[j]); @@ -488,8 +488,8 @@ void ShaderGLES2::setup( int p_fragment_code_start) { ERR_FAIL_COND(version); - conditional_version.key = 0; - new_conditional_version.key = 0; + memset(conditional_version.key, 0, sizeof(conditional_version.key)); + memset(new_conditional_version.key, 0, sizeof(new_conditional_version.key)); uniform_count = p_uniform_count; conditional_count = p_conditional_count; conditional_defines = p_conditional_defines; @@ -634,7 +634,7 @@ void ShaderGLES2::free_custom_shader(uint32_t p_code_id) { VersionKey key; key.code_version = p_code_id; - for (Set::Element *E = custom_code_map[p_code_id].versions.front(); E; E = E->next()) { + for (Set::Element *E = custom_code_map[p_code_id].versions.front(); E; E = E->next()) { key.version = E->get(); ERR_CONTINUE(!version_map.has(key)); Version &v = version_map[key]; diff --git a/drivers/gles2/shader_gles2.h b/drivers/gles2/shader_gles2.h index a74f5531f034..0300e8b70318 100644 --- a/drivers/gles2/shader_gles2.h +++ b/drivers/gles2/shader_gles2.h @@ -99,7 +99,7 @@ class ShaderGLES2 { Vector texture_uniforms; Vector custom_uniforms; Vector custom_defines; - Set versions; + Set versions; }; struct Version { @@ -125,16 +125,16 @@ class ShaderGLES2 { union VersionKey { struct { - uint32_t version; + uint64_t version; uint32_t code_version; }; - uint64_t key; - bool operator==(const VersionKey &p_key) const { return key == p_key.key; } - bool operator<(const VersionKey &p_key) const { return key < p_key.key; } + unsigned char key[12]; + bool operator==(const VersionKey &p_key) const { return version == p_key.version && code_version == p_key.code_version; } + bool operator<(const VersionKey &p_key) const { return version < p_key.version || (version == p_key.version && code_version < p_key.code_version); } }; struct VersionKeyHash { - static _FORCE_INLINE_ uint32_t hash(const VersionKey &p_key) { return HashMapHasherDefault::hash(p_key.key); } + static _FORCE_INLINE_ uint32_t hash(const VersionKey &p_key) { return hash_djb2_buffer(p_key.key, sizeof(p_key.key)); } }; //this should use a way more cachefriendly version.. @@ -222,13 +222,13 @@ class ShaderGLES2 { void set_custom_shader(uint32_t p_code_id); void free_custom_shader(uint32_t p_code_id); - uint32_t get_version_key() const { return conditional_version.version; } + uint64_t get_version_key() const { return conditional_version.version; } // this void* is actually a RasterizerStorageGLES2::Material, but C++ doesn't // like forward declared nested classes. void use_material(void *p_material); - _FORCE_INLINE_ uint32_t get_version() const { return new_conditional_version.version; } + _FORCE_INLINE_ uint64_t get_version() const { return new_conditional_version.version; } _FORCE_INLINE_ bool is_version_valid() const { return version && version->ok; } virtual void init() = 0; @@ -261,10 +261,12 @@ int ShaderGLES2::_get_uniform(int p_which) const { void ShaderGLES2::_set_conditional(int p_which, bool p_value) { ERR_FAIL_INDEX(p_which, conditional_count); + ERR_FAIL_INDEX(static_cast(p_which), sizeof(new_conditional_version.version) * 8) + if (p_value) { - new_conditional_version.version |= (1 << p_which); + new_conditional_version.version |= (uint64_t(1) << p_which); } else { - new_conditional_version.version &= ~(1 << p_which); + new_conditional_version.version &= ~(uint64_t(1) << p_which); } } diff --git a/drivers/gles2/shaders/scene.glsl b/drivers/gles2/shaders/scene.glsl index 9f8d1cbf5a87..12a6bbb55ace 100644 --- a/drivers/gles2/shaders/scene.glsl +++ b/drivers/gles2/shaders/scene.glsl @@ -31,11 +31,19 @@ precision highp int; attribute highp vec4 vertex_attrib; // attrib:0 /* clang-format on */ +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION +attribute vec2 normal_attrib; // attrib:1 +#else attribute vec3 normal_attrib; // attrib:1 +#endif #if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION +attribute vec2 tangent_attrib; // attrib:2 +#else attribute vec4 tangent_attrib; // attrib:2 #endif +#endif #if defined(ENABLE_COLOR_INTERP) attribute vec4 color_attrib; // attrib:3 @@ -102,6 +110,15 @@ uniform float light_normal_bias; uniform highp int view_index; +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION +vec3 oct_to_vec3(vec2 e) { + vec3 v = vec3(e.xy, 1.0 - abs(e.x) - abs(e.y)); + float t = max(-v.z, 0.0); + v.xy += t * -sign(v.xy); + return v; +} +#endif + // // varyings // @@ -341,11 +358,20 @@ void main() { #endif +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION + vec3 normal = oct_to_vec3(normal_attrib); +#else vec3 normal = normal_attrib; +#endif #if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION + vec3 tangent = oct_to_vec3(vec2(tangent_attrib.x, abs(tangent_attrib.y) * 2.0 - 1.0)); + float binormalf = sign(tangent_attrib.y); +#else vec3 tangent = tangent_attrib.xyz; float binormalf = tangent_attrib.a; +#endif vec3 binormal = normalize(cross(normal, tangent) * binormalf); #endif diff --git a/drivers/gles3/rasterizer_scene_gles3.cpp b/drivers/gles3/rasterizer_scene_gles3.cpp index 43db3a133131..c91f92c0762e 100644 --- a/drivers/gles3/rasterizer_scene_gles3.cpp +++ b/drivers/gles3/rasterizer_scene_gles3.cpp @@ -1944,6 +1944,7 @@ void RasterizerSceneGLES3::_render_list(RenderList::Element **p_elements, int p_ bool first = true; bool prev_use_instancing = false; + bool prev_octahedral_compression = false; storage->info.render.draw_call_count += p_element_count; bool prev_opaque_prepass = false; @@ -2108,6 +2109,12 @@ void RasterizerSceneGLES3::_render_list(RenderList::Element **p_elements, int p_ } } + bool octahedral_compression = ((RasterizerStorageGLES3::Surface *)e->geometry)->format & VisualServer::ArrayFormat::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION; + if (octahedral_compression != prev_octahedral_compression) { + state.scene_shader.set_conditional(SceneShaderGLES3::ENABLE_OCTAHEDRAL_COMPRESSION, octahedral_compression); + rebind = true; + } + if (material != prev_material || rebind) { storage->info.render.material_switch_count++; @@ -2140,12 +2147,14 @@ void RasterizerSceneGLES3::_render_list(RenderList::Element **p_elements, int p_ prev_shading = shading; prev_skeleton = skeleton; prev_use_instancing = use_instancing; + prev_octahedral_compression = octahedral_compression; prev_opaque_prepass = use_opaque_prepass; first = false; } glBindVertexArray(0); + state.scene_shader.remove_custom_define("#define ENABLE_OCTAHEDRAL_COMPRESSION\n"); state.scene_shader.set_conditional(SceneShaderGLES3::USE_INSTANCING, false); state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON, false); state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP, false); diff --git a/drivers/gles3/rasterizer_storage_gles3.cpp b/drivers/gles3/rasterizer_storage_gles3.cpp index d6233db3572c..802af73017ea 100644 --- a/drivers/gles3/rasterizer_storage_gles3.cpp +++ b/drivers/gles3/rasterizer_storage_gles3.cpp @@ -3396,30 +3396,54 @@ void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh, uint32_t p_format, VS: } break; case VS::ARRAY_NORMAL: { - attribs[i].size = 3; - - if (p_format & VS::ARRAY_COMPRESS_NORMAL) { - attribs[i].type = GL_BYTE; - attributes_stride += 4; //pad extra byte + if (p_format & VS::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { attribs[i].normalized = GL_TRUE; + attribs[i].size = 2; + if (p_format & VS::ARRAY_COMPRESS_NORMAL) { + attribs[i].type = GL_BYTE; + attributes_stride += 2; + } else { + attribs[i].type = GL_SHORT; + attributes_stride += 4; + } } else { - attribs[i].type = GL_FLOAT; - attributes_stride += 12; - attribs[i].normalized = GL_FALSE; + attribs[i].size = 3; + + if (p_format & VS::ARRAY_COMPRESS_NORMAL) { + attribs[i].type = GL_BYTE; + attributes_stride += 4; //pad extra byte + attribs[i].normalized = GL_TRUE; + } else { + attribs[i].type = GL_FLOAT; + attributes_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; - attributes_stride += 4; + if (p_format & VS::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { attribs[i].normalized = GL_TRUE; + attribs[i].size = 2; + if (p_format & VS::ARRAY_COMPRESS_TANGENT) { + attribs[i].type = GL_BYTE; + attributes_stride += 2; + } else { + attribs[i].type = GL_SHORT; + attributes_stride += 4; + } } else { - attribs[i].type = GL_FLOAT; - attributes_stride += 16; - attribs[i].normalized = GL_FALSE; + attribs[i].size = 4; + + if (p_format & VS::ARRAY_COMPRESS_TANGENT) { + attribs[i].type = GL_BYTE; + attributes_stride += 4; + attribs[i].normalized = GL_TRUE; + } else { + attribs[i].type = GL_FLOAT; + attributes_stride += 16; + attribs[i].normalized = GL_FALSE; + } } } break; diff --git a/drivers/gles3/shaders/scene.glsl b/drivers/gles3/shaders/scene.glsl index e894beb159f7..8de8b478b7da 100644 --- a/drivers/gles3/shaders/scene.glsl +++ b/drivers/gles3/shaders/scene.glsl @@ -25,10 +25,18 @@ ARRAY_INDEX=8, layout(location = 0) in highp vec4 vertex_attrib; /* clang-format on */ +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION +layout(location = 1) in vec2 normal_attrib; +#else layout(location = 1) in vec3 normal_attrib; +#endif #if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY) +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION +layout(location = 2) in vec2 tangent_attrib; +#else layout(location = 2) in vec4 tangent_attrib; #endif +#endif #if defined(ENABLE_COLOR_INTERP) layout(location = 3) in vec4 color_attrib; @@ -251,6 +259,15 @@ void light_process_spot(int idx, vec3 vertex, vec3 eye_vec, vec3 normal, float r #endif +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION +vec3 oct_to_vec3(vec2 e) { + vec3 v = vec3(e.xy, 1.0 - abs(e.x) - abs(e.y)); + float t = max(-v.z, 0.0); + v.xy += t * -sign(v.xy); + return v; +} +#endif + /* Varyings */ out highp vec3 vertex_interp; @@ -322,12 +339,21 @@ void main() { } #endif +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION + vec3 normal = oct_to_vec3(normal_attrib); +#else vec3 normal = normal_attrib; +#endif #if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY) +#ifdef ENABLE_OCTAHEDRAL_COMPRESSION + vec3 tangent = oct_to_vec3(vec2(tangent_attrib.x, abs(tangent_attrib.y) * 2.0 - 1.0)); + float binormalf = sign(tangent_attrib.y); +#else vec3 tangent = tangent_attrib.xyz; float binormalf = tangent_attrib.a; #endif +#endif #if defined(ENABLE_COLOR_INTERP) color_interp = color_attrib; @@ -338,7 +364,6 @@ void main() { #endif #if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY) - vec3 binormal = normalize(cross(normal, tangent) * binormalf); #endif diff --git a/editor/import/editor_import_collada.cpp b/editor/import/editor_import_collada.cpp index 13802974ab75..cdf6c6a807cf 100644 --- a/editor/import/editor_import_collada.cpp +++ b/editor/import/editor_import_collada.cpp @@ -928,7 +928,7 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize, Ref &p_me mr.push_back(a); } - p_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, d, mr, p_use_compression ? Mesh::ARRAY_COMPRESS_DEFAULT : 0); + p_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, d, mr, p_use_compression ? Mesh::ARRAY_COMPRESS_DEFAULT : Mesh::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION); if (material.is_valid()) { if (p_use_mesh_material) { diff --git a/editor/import/resource_importer_obj.cpp b/editor/import/resource_importer_obj.cpp index b6d86f10801e..882d43f79b8f 100644 --- a/editor/import/resource_importer_obj.cpp +++ b/editor/import/resource_importer_obj.cpp @@ -210,7 +210,7 @@ static Error _parse_obj(const String &p_path, List> &r_meshes, bool p_ bool generate_tangents = p_generate_tangents; Vector3 scale_mesh = p_scale_mesh; Vector3 offset_mesh = p_offset_mesh; - int mesh_flags = p_optimize ? Mesh::ARRAY_COMPRESS_DEFAULT : 0; + int mesh_flags = p_optimize ? Mesh::ARRAY_COMPRESS_DEFAULT : Mesh::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION; Vector vertices; Vector normals; diff --git a/modules/fbx/data/fbx_mesh_data.cpp b/modules/fbx/data/fbx_mesh_data.cpp index bae75edd0fb7..75c28bf4f44f 100644 --- a/modules/fbx/data/fbx_mesh_data.cpp +++ b/modules/fbx/data/fbx_mesh_data.cpp @@ -386,7 +386,7 @@ MeshInstance *FBXMeshData::create_fbx_mesh(const ImportState &state, const FBXDo Mesh::PRIMITIVE_TRIANGLES, surface->surface_tool->commit_to_arrays(), surface->morphs, - use_compression ? Mesh::ARRAY_COMPRESS_DEFAULT : 0); + use_compression ? Mesh::ARRAY_COMPRESS_DEFAULT : Mesh::ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION); if (surface->material.is_valid()) { mesh->surface_set_name(in_mesh_surface_id, surface->material->get_name()); diff --git a/scene/3d/soft_body.cpp b/scene/3d/soft_body.cpp index 389d581be901..ede29ecad0dc 100644 --- a/scene/3d/soft_body.cpp +++ b/scene/3d/soft_body.cpp @@ -84,7 +84,12 @@ void SoftBodyVisualServerHandler::set_vertex(int p_vertex_id, const void *p_vect } void SoftBodyVisualServerHandler::set_normal(int p_vertex_id, const void *p_vector3) { - memcpy(&write_buffer[p_vertex_id * stride + offset_normal], p_vector3, sizeof(float) * 3); + Vector2 normal_oct = VisualServer::get_singleton()->norm_to_oct(*(Vector3 *)p_vector3); + int16_t v_normal[2] = { + (int16_t)CLAMP(normal_oct.x * 32767, -32768, 32767), + (int16_t)CLAMP(normal_oct.y * 32767, -32768, 32767), + }; + memcpy(&write_buffer[p_vertex_id * stride + offset_normal], v_normal, sizeof(uint16_t) * 2); } void SoftBodyVisualServerHandler::set_aabb(const AABB &p_aabb) { diff --git a/scene/3d/sprite_3d.cpp b/scene/3d/sprite_3d.cpp index 21fd0e0fe00b..6f2eeae8afef 100644 --- a/scene/3d/sprite_3d.cpp +++ b/scene/3d/sprite_3d.cpp @@ -534,18 +534,16 @@ void Sprite3D::_draw() { // Everything except position and UV is compressed PoolVector::Write write_buffer = mesh_buffer.write(); - int8_t v_normal[4] = { - (int8_t)CLAMP(normal.x * 127, -128, 127), - (int8_t)CLAMP(normal.y * 127, -128, 127), - (int8_t)CLAMP(normal.z * 127, -128, 127), - 0, + Vector2 normal_oct = VisualServer::get_singleton()->norm_to_oct(normal); + int8_t v_normal[2] = { + (int8_t)CLAMP(normal_oct.x * 127, -128, 127), + (int8_t)CLAMP(normal_oct.y * 127, -128, 127), }; - int8_t v_tangent[4] = { - (int8_t)CLAMP(tangent.normal.x * 127, -128, 127), - (int8_t)CLAMP(tangent.normal.y * 127, -128, 127), - (int8_t)CLAMP(tangent.normal.z * 127, -128, 127), - (int8_t)CLAMP(tangent.d * 127, -128, 127) + Vector2 tangent_oct = VisualServer::get_singleton()->tangent_to_oct(tangent.normal, tangent.d, false); + int8_t v_tangent[2] = { + (int8_t)CLAMP(tangent_oct.x * 127, -128, 127), + (int8_t)CLAMP(tangent_oct.y * 127, -128, 127), }; uint8_t v_color[4] = { @@ -571,8 +569,8 @@ void Sprite3D::_draw() { float v_vertex[3] = { vtx.x, vtx.y, vtx.z }; memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_VERTEX]], &v_vertex, sizeof(float) * 3); - memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_NORMAL]], v_normal, 4); - memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_TANGENT]], v_tangent, 4); + memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_NORMAL]], v_normal, 2); + memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_TANGENT]], v_tangent, 2); memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_COLOR]], v_color, 4); } @@ -888,18 +886,16 @@ void AnimatedSprite3D::_draw() { // Everything except position and UV is compressed PoolVector::Write write_buffer = mesh_buffer.write(); - int8_t v_normal[4] = { - (int8_t)CLAMP(normal.x * 127, -128, 127), - (int8_t)CLAMP(normal.y * 127, -128, 127), - (int8_t)CLAMP(normal.z * 127, -128, 127), - 0, + Vector2 normal_oct = VisualServer::get_singleton()->norm_to_oct(normal); + int8_t v_normal[2] = { + (int8_t)CLAMP(normal_oct.x * 127, -128, 127), + (int8_t)CLAMP(normal_oct.y * 127, -128, 127), }; - int8_t v_tangent[4] = { - (int8_t)CLAMP(tangent.normal.x * 127, -128, 127), - (int8_t)CLAMP(tangent.normal.y * 127, -128, 127), - (int8_t)CLAMP(tangent.normal.z * 127, -128, 127), - (int8_t)CLAMP(tangent.d * 127, -128, 127) + Vector2 tangent_oct = VisualServer::get_singleton()->tangent_to_oct(tangent.normal, tangent.d, false); + int8_t v_tangent[2] = { + (int8_t)CLAMP(tangent_oct.x * 127, -128, 127), + (int8_t)CLAMP(tangent_oct.y * 127, -128, 127), }; uint8_t v_color[4] = { @@ -925,8 +921,8 @@ void AnimatedSprite3D::_draw() { float v_vertex[3] = { vtx.x, vtx.y, vtx.z }; memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_VERTEX]], &v_vertex, sizeof(float) * 3); - memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_NORMAL]], v_normal, 4); - memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_TANGENT]], v_tangent, 4); + memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_NORMAL]], v_normal, 2); + memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_TANGENT]], v_tangent, 2); memcpy(&write_buffer[i * mesh_stride + mesh_surface_offsets[VS::ARRAY_COLOR]], v_color, 4); } diff --git a/scene/resources/mesh.cpp b/scene/resources/mesh.cpp index 628601ec7063..7bb1e7136d37 100644 --- a/scene/resources/mesh.cpp +++ b/scene/resources/mesh.cpp @@ -546,6 +546,7 @@ void Mesh::_bind_methods() { BIND_ENUM_CONSTANT(ARRAY_FLAG_USE_2D_VERTICES); BIND_ENUM_CONSTANT(ARRAY_FLAG_USE_16_BIT_BONES); + BIND_ENUM_CONSTANT(ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION); BIND_ENUM_CONSTANT(ARRAY_COMPRESS_DEFAULT); diff --git a/scene/resources/mesh.h b/scene/resources/mesh.h index 0d05fd85bb37..a5249e94d825 100644 --- a/scene/resources/mesh.h +++ b/scene/resources/mesh.h @@ -96,8 +96,9 @@ class Mesh : public Resource { ARRAY_FLAG_USE_2D_VERTICES = ARRAY_COMPRESS_INDEX << 1, ARRAY_FLAG_USE_16_BIT_BONES = ARRAY_COMPRESS_INDEX << 2, ARRAY_FLAG_USE_DYNAMIC_UPDATE = ARRAY_COMPRESS_INDEX << 3, + ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION = ARRAY_COMPRESS_INDEX << 4, - ARRAY_COMPRESS_DEFAULT = ARRAY_COMPRESS_NORMAL | ARRAY_COMPRESS_TANGENT | ARRAY_COMPRESS_COLOR | ARRAY_COMPRESS_TEX_UV | ARRAY_COMPRESS_TEX_UV2 | ARRAY_COMPRESS_WEIGHTS + ARRAY_COMPRESS_DEFAULT = ARRAY_COMPRESS_NORMAL | ARRAY_COMPRESS_TANGENT | ARRAY_COMPRESS_COLOR | ARRAY_COMPRESS_TEX_UV | ARRAY_COMPRESS_TEX_UV2 | ARRAY_COMPRESS_WEIGHTS | ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION }; diff --git a/servers/visual_server.cpp b/servers/visual_server.cpp index fac03115916a..424e7ce05851 100644 --- a/servers/visual_server.cpp +++ b/servers/visual_server.cpp @@ -329,6 +329,59 @@ RID VisualServer::get_white_texture() { #define SMALL_VEC2 Vector2(0.00001, 0.00001) #define SMALL_VEC3 Vector3(0.00001, 0.00001, 0.00001) +// Maps normalized vector to an octohedron projected onto the cartesian plane +// Resulting 2D vector in range [-1, 1] +// See http://jcgt.org/published/0003/02/01/ for details +Vector2 VisualServer::norm_to_oct(const Vector3 v) { + const float invL1Norm = (1.0f) / (Math::absf(v.x) + Math::absf(v.y) + Math::absf(v.z)); + + Vector2 res; + + if (v.z < 0.0f) { + res.x = (1.0f - Math::absf(v.y * invL1Norm)) * SGN(v.x); + res.y = (1.0f - Math::absf(v.x * invL1Norm)) * SGN(v.y); + } else { + res.x = v.x * invL1Norm; + res.y = v.y * invL1Norm; + } + + return res; +} + +// Maps normalized tangent vector to an octahedron projected onto the cartesian plane +// Encodes the tangent vector sign in the second componenet of the returned Vector2 for use in shaders +// high_precision specifies whether the encoding will be 32 bit (true) or 16 bit (false) +// Resulting 2D vector in range [-1, 1] +// See http://jcgt.org/published/0003/02/01/ for details +Vector2 VisualServer::tangent_to_oct(const Vector3 v, const float sign, const bool high_precision) { + float bias = high_precision ? 1.0f / 32767 : 1.0f / 127; + Vector2 res = norm_to_oct(v); + res.y = res.y * 0.5f + 0.5f; + res.y = MAX(res.y, bias) * SGN(sign); + return res; +} + +// Convert Octohedron-mapped normalized vector back to Cartesian +// Assumes normalized format (elements of v within range [-1, 1]) +Vector3 VisualServer::oct_to_norm(const Vector2 v) { + Vector3 res(v.x, v.y, 1 - (Math::absf(v.x) + Math::absf(v.y))); + float t = MAX(-res.z, 0.0f); + res.x += t * -SGN(res.x); + res.y += t * -SGN(res.y); + return res; +} + +// Convert Octohedron-mapped normalized tangent vector back to Cartesian +// out_sign provides the direction for the original cartesian tangent +// Assumes normalized format (elements of v within range [-1, 1]) +Vector3 VisualServer::oct_to_tangent(const Vector2 v, float *out_sign) { + Vector2 v_decompressed = v; + v_decompressed.y = Math::absf(v_decompressed.y) * 2 - 1; + Vector3 res = oct_to_norm(v_decompressed); + *out_sign = SGN(v[1]); + return res; +} + Error VisualServer::_surface_set_data(Array p_arrays, uint32_t p_format, uint32_t *p_offsets, uint32_t *p_stride, PoolVector &r_vertex_array, int p_vertex_array_len, PoolVector &r_index_array, int p_index_array_len, AABB &r_aabb, Vector &r_bone_aabb) { PoolVector::Write vw = r_vertex_array.write(); @@ -437,22 +490,47 @@ Error VisualServer::_surface_set_data(Array p_arrays, uint32_t p_format, uint32_ // setting vertices means regenerating the AABB - if (p_format & ARRAY_COMPRESS_NORMAL) { - for (int i = 0; i < p_vertex_array_len; i++) { - int8_t vector[4] = { - (int8_t)CLAMP(src[i].x * 127, -128, 127), - (int8_t)CLAMP(src[i].y * 127, -128, 127), - (int8_t)CLAMP(src[i].z * 127, -128, 127), - 0, - }; - - memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], vector, 4); - } + if (p_format & ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_format & ARRAY_COMPRESS_NORMAL) { + for (int i = 0; i < p_vertex_array_len; i++) { + Vector2 res = norm_to_oct(src[i]); + int8_t vector[2] = { + (int8_t)CLAMP(res.x * 127, -128, 127), + (int8_t)CLAMP(res.y * 127, -128, 127), + }; + memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], vector, 2); + } + + } else { + for (int i = 0; i < p_vertex_array_len; i++) { + Vector2 res = norm_to_oct(src[i]); + int16_t vector[2] = { + (int16_t)CLAMP(res.x * 32767, -32768, 32767), + (int16_t)CLAMP(res.y * 32767, -32768, 32767), + }; + + memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], vector, 4); + } + } } else { - for (int i = 0; i < p_vertex_array_len; i++) { - float vector[3] = { src[i].x, src[i].y, src[i].z }; - memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], vector, 3 * 4); + if (p_format & ARRAY_COMPRESS_NORMAL) { + for (int i = 0; i < p_vertex_array_len; i++) { + int8_t vector[4] = { + (int8_t)CLAMP(src[i].x * 127, -128, 127), + (int8_t)CLAMP(src[i].y * 127, -128, 127), + (int8_t)CLAMP(src[i].z * 127, -128, 127), + 0, + }; + + memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], vector, 4); + } + + } else { + for (int i = 0; i < p_vertex_array_len; i++) { + float vector[3] = { src[i].x, src[i].y, src[i].z }; + memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], vector, 3 * 4); + } } } @@ -468,28 +546,57 @@ Error VisualServer::_surface_set_data(Array p_arrays, uint32_t p_format, uint32_ PoolVector::Read read = array.read(); const real_t *src = read.ptr(); - if (p_format & ARRAY_COMPRESS_TANGENT) { - for (int i = 0; i < p_vertex_array_len; i++) { - int8_t xyzw[4] = { - (int8_t)CLAMP(src[i * 4 + 0] * 127, -128, 127), - (int8_t)CLAMP(src[i * 4 + 1] * 127, -128, 127), - (int8_t)CLAMP(src[i * 4 + 2] * 127, -128, 127), - (int8_t)CLAMP(src[i * 4 + 3] * 127, -128, 127) - }; - - memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], xyzw, 4); - } + if (p_format & ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_format & ARRAY_COMPRESS_TANGENT) { + for (int i = 0; i < p_vertex_array_len; i++) { + Vector3 source(src[i * 4 + 0], src[i * 4 + 1], src[i * 4 + 2]); + Vector2 res = tangent_to_oct(source, src[i * 4 + 3], false); + + int8_t vector[2] = { + (int8_t)CLAMP(res.x * 127, -128, 127), + (int8_t)CLAMP(res.y * 127, -128, 127) + }; + + memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], vector, 2); + } + + } else { + for (int i = 0; i < p_vertex_array_len; i++) { + Vector3 source(src[i * 4 + 0], src[i * 4 + 1], src[i * 4 + 2]); + Vector2 res = tangent_to_oct(source, src[i * 4 + 3], true); + int16_t vector[2] = { + (int16_t)CLAMP(res.x * 32767, -32768, 32767), + (int16_t)CLAMP(res.y * 32767, -32768, 32767) + }; + + memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], vector, 4); + } + } } else { - for (int i = 0; i < p_vertex_array_len; i++) { - float xyzw[4] = { - src[i * 4 + 0], - src[i * 4 + 1], - src[i * 4 + 2], - src[i * 4 + 3] - }; - - memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], xyzw, 4 * 4); + if (p_format & ARRAY_COMPRESS_TANGENT) { + for (int i = 0; i < p_vertex_array_len; i++) { + int8_t xyzw[4] = { + (int8_t)CLAMP(src[i * 4 + 0] * 127, -128, 127), + (int8_t)CLAMP(src[i * 4 + 1] * 127, -128, 127), + (int8_t)CLAMP(src[i * 4 + 2] * 127, -128, 127), + (int8_t)CLAMP(src[i * 4 + 3] * 127, -128, 127) + }; + + memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], xyzw, 4); + } + + } else { + for (int i = 0; i < p_vertex_array_len; i++) { + float xyzw[4] = { + src[i * 4 + 0], + src[i * 4 + 1], + src[i * 4 + 2], + src[i * 4 + 3] + }; + + memcpy(&vw[p_offsets[ai] + i * p_stride[ai]], xyzw, 4 * 4); + } } } @@ -770,19 +877,35 @@ uint32_t VisualServer::mesh_surface_make_offsets_from_format(uint32_t p_format, } break; case VS::ARRAY_NORMAL: { - if (p_format & ARRAY_COMPRESS_NORMAL) { - elem_size = sizeof(uint32_t); + if (p_format & ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_format & ARRAY_COMPRESS_NORMAL) { + elem_size = sizeof(uint8_t) * 2; + } else { + elem_size = sizeof(uint16_t) * 2; + } } else { - elem_size = sizeof(float) * 3; + if (p_format & ARRAY_COMPRESS_NORMAL) { + elem_size = sizeof(uint32_t); + } else { + elem_size = sizeof(float) * 3; + } } } break; case VS::ARRAY_TANGENT: { - if (p_format & ARRAY_COMPRESS_TANGENT) { - elem_size = sizeof(uint32_t); + if (p_format & ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_format & ARRAY_COMPRESS_TANGENT) { + elem_size = sizeof(uint8_t) * 2; + } else { + elem_size = sizeof(uint16_t) * 2; + } } else { - elem_size = sizeof(float) * 4; + if (p_format & ARRAY_COMPRESS_TANGENT) { + elem_size = sizeof(uint32_t); + } else { + elem_size = sizeof(float) * 4; + } } } break; @@ -959,10 +1082,18 @@ void VisualServer::mesh_add_surface_from_arrays(RID p_mesh, PrimitiveType p_prim } break; case VS::ARRAY_NORMAL: { - if (p_compress_format & ARRAY_COMPRESS_NORMAL) { - elem_size = sizeof(uint32_t); + if (p_compress_format & ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_compress_format & ARRAY_COMPRESS_NORMAL) { + elem_size = sizeof(uint8_t) * 2; + } else { + elem_size = sizeof(uint16_t) * 2; + } } else { - elem_size = sizeof(float) * 3; + if (p_compress_format & ARRAY_COMPRESS_NORMAL) { + elem_size = sizeof(uint32_t); + } else { + elem_size = sizeof(float) * 3; + } } offsets[i] = attributes_base_offset + attributes_stride; attributes_stride += elem_size; @@ -970,10 +1101,18 @@ void VisualServer::mesh_add_surface_from_arrays(RID p_mesh, PrimitiveType p_prim } break; case VS::ARRAY_TANGENT: { - if (p_compress_format & ARRAY_COMPRESS_TANGENT) { - elem_size = sizeof(uint32_t); + if (p_compress_format & ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_compress_format & ARRAY_COMPRESS_TANGENT) { + elem_size = sizeof(uint8_t) * 2; + } else { + elem_size = sizeof(uint16_t) * 2; + } } else { - elem_size = sizeof(float) * 4; + if (p_compress_format & ARRAY_COMPRESS_TANGENT) { + elem_size = sizeof(uint32_t); + } else { + elem_size = sizeof(float) * 4; + } } offsets[i] = attributes_base_offset + attributes_stride; attributes_stride += elem_size; @@ -1146,19 +1285,35 @@ Array VisualServer::_get_array_from_surface(uint32_t p_format, PoolVector arr; arr.resize(p_vertex_len); - if (p_format & ARRAY_COMPRESS_NORMAL) { - PoolVector::Write w = arr.write(); - const float multiplier = 1.f / 127.f; + if (p_format & ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_format & ARRAY_COMPRESS_NORMAL) { + PoolVector::Write w = arr.write(); - for (int j = 0; j < p_vertex_len; j++) { - const int8_t *v = (const int8_t *)&r[j * total_elem_size + offsets[i]]; - w[j] = Vector3(float(v[0]) * multiplier, float(v[1]) * multiplier, float(v[2]) * multiplier); + for (int j = 0; j < p_vertex_len; j++) { + const int8_t *n = (const int8_t *)&r[j * total_elem_size + offsets[i]]; + Vector2 enc(n[0] / 127.0f, n[1] / 127.0f); + + w[j] = oct_to_norm(enc); + } + } else { + PoolVector::Write w = arr.write(); + + for (int j = 0; j < p_vertex_len; j++) { + const int16_t *n = (const int16_t *)&r[j * total_elem_size + offsets[i]]; + Vector2 enc(n[0] / 32767.0f, n[1] / 32767.0f); + + w[j] = oct_to_norm(enc); + } } } else { - PoolVector::Write w = arr.write(); + if (p_format & ARRAY_COMPRESS_NORMAL) { + PoolVector::Write w = arr.write(); + const float multiplier = 1.f / 127.f; - for (int j = 0; j < p_vertex_len; j++) { - const float *v = (const float *)&r[j * total_elem_size + offsets[i]]; - w[j] = Vector3(v[0], v[1], v[2]); + for (int j = 0; j < p_vertex_len; j++) { + const int8_t *v = (const int8_t *)&r[j * total_elem_size + offsets[i]]; + w[j] = Vector3(float(v[0]) * multiplier, float(v[1]) * multiplier, float(v[2]) * multiplier); + } + } else { + PoolVector::Write w = arr.write(); + + for (int j = 0; j < p_vertex_len; j++) { + const float *v = (const float *)&r[j * total_elem_size + offsets[i]]; + w[j] = Vector3(v[0], v[1], v[2]); + } } } @@ -1311,22 +1488,51 @@ Array VisualServer::_get_array_from_surface(uint32_t p_format, PoolVector arr; arr.resize(p_vertex_len * 4); - if (p_format & ARRAY_COMPRESS_TANGENT) { - PoolVector::Write w = arr.write(); - for (int j = 0; j < p_vertex_len; j++) { - const int8_t *v = (const int8_t *)&r[j * total_elem_size + offsets[i]]; - for (int k = 0; k < 4; k++) { - w[j * 4 + k] = float(v[k] / 127.0); + if (p_format & ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION) { + if (p_format & ARRAY_COMPRESS_TANGENT) { + PoolVector::Write w = arr.write(); + + for (int j = 0; j < p_vertex_len; j++) { + const int8_t *t = (const int8_t *)&r[j * total_elem_size + offsets[i]]; + Vector2 enc(t[0] / 127.0f, t[1] / 127.0f); + Vector3 dec = oct_to_tangent(enc, &w[j * 3 + 2]); + + w[j * 3 + 0] = dec.x; + w[j * 3 + 1] = dec.y; + w[j * 3 + 2] = dec.z; + } + } else { + PoolVector::Write w = arr.write(); + + for (int j = 0; j < p_vertex_len; j++) { + const int16_t *t = (const int16_t *)&r[j * total_elem_size + offsets[i]]; + Vector2 enc(t[0] / 32767.0f, t[1] / 32767.0f); + Vector3 dec = oct_to_tangent(enc, &w[j * 3 + 2]); + + w[j * 3 + 0] = dec.x; + w[j * 3 + 1] = dec.y; + w[j * 3 + 2] = dec.z; } } } else { - PoolVector::Write w = arr.write(); + if (p_format & ARRAY_COMPRESS_TANGENT) { + PoolVector::Write w = arr.write(); - for (int j = 0; j < p_vertex_len; j++) { - const float *v = (const float *)&r[j * total_elem_size + offsets[i]]; - for (int k = 0; k < 4; k++) { - w[j * 4 + k] = v[k]; + for (int j = 0; j < p_vertex_len; j++) { + const int8_t *v = (const int8_t *)&r[j * total_elem_size + offsets[i]]; + for (int k = 0; k < 4; k++) { + w[j * 4 + k] = float(v[k] / 127.0); + } + } + } else { + PoolVector::Write w = arr.write(); + + for (int j = 0; j < p_vertex_len; j++) { + const float *v = (const float *)&r[j * total_elem_size + offsets[i]]; + for (int k = 0; k < 4; k++) { + w[j * 4 + k] = v[k]; + } } } } @@ -2019,6 +2225,7 @@ void VisualServer::_bind_methods() { BIND_ENUM_CONSTANT(ARRAY_COMPRESS_INDEX); BIND_ENUM_CONSTANT(ARRAY_FLAG_USE_2D_VERTICES); BIND_ENUM_CONSTANT(ARRAY_FLAG_USE_16_BIT_BONES); + BIND_ENUM_CONSTANT(ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION); BIND_ENUM_CONSTANT(ARRAY_COMPRESS_DEFAULT); BIND_ENUM_CONSTANT(PRIMITIVE_POINTS); diff --git a/servers/visual_server.h b/servers/visual_server.h index a9ea43835bee..8596255fc296 100644 --- a/servers/visual_server.h +++ b/servers/visual_server.h @@ -68,6 +68,10 @@ class VisualServer : public Object { public: static VisualServer *get_singleton(); static VisualServer *create(); + static Vector2 norm_to_oct(const Vector3 v); + static Vector2 tangent_to_oct(const Vector3 v, const float sign, const bool high_precision); + static Vector3 oct_to_norm(const Vector2 v); + static Vector3 oct_to_tangent(const Vector2 v, float *out_sign); enum { @@ -263,8 +267,9 @@ class VisualServer : public Object { ARRAY_FLAG_USE_2D_VERTICES = ARRAY_COMPRESS_INDEX << 1, ARRAY_FLAG_USE_16_BIT_BONES = ARRAY_COMPRESS_INDEX << 2, ARRAY_FLAG_USE_DYNAMIC_UPDATE = ARRAY_COMPRESS_INDEX << 3, + ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION = ARRAY_COMPRESS_INDEX << 4, - ARRAY_COMPRESS_DEFAULT = ARRAY_COMPRESS_NORMAL | ARRAY_COMPRESS_TANGENT | ARRAY_COMPRESS_COLOR | ARRAY_COMPRESS_TEX_UV | ARRAY_COMPRESS_TEX_UV2 | ARRAY_COMPRESS_WEIGHTS + ARRAY_COMPRESS_DEFAULT = ARRAY_COMPRESS_NORMAL | ARRAY_COMPRESS_TANGENT | ARRAY_COMPRESS_COLOR | ARRAY_COMPRESS_TEX_UV | ARRAY_COMPRESS_TEX_UV2 | ARRAY_COMPRESS_WEIGHTS | ARRAY_FLAG_USE_OCTAHEDRAL_COMPRESSION };