2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* surface_tool.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
2014-02-10 01:10:30 +00:00
/*************************************************************************/
2020-01-01 10:16:22 +00:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
2014-02-10 01:10:30 +00:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2018-01-04 23:50:27 +00:00
2014-02-10 01:10:30 +00:00
# include "surface_tool.h"
2018-09-11 16:13:45 +00:00
2014-02-10 01:10:30 +00:00
# define _VERTEX_SNAP 0.0001
# define EQ_VERTEX_DIST 0.00001
2017-08-11 19:10:05 +00:00
bool SurfaceTool : : Vertex : : operator = = ( const Vertex & p_vertex ) const {
2020-05-14 14:41:43 +00:00
if ( vertex ! = p_vertex . vertex ) {
2014-02-10 01:10:30 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
2020-05-14 14:41:43 +00:00
if ( uv ! = p_vertex . uv ) {
2014-05-14 04:22:15 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
2020-05-14 14:41:43 +00:00
if ( uv2 ! = p_vertex . uv2 ) {
2014-05-14 04:22:15 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
2020-05-14 14:41:43 +00:00
if ( normal ! = p_vertex . normal ) {
2014-05-14 04:22:15 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
2020-05-14 14:41:43 +00:00
if ( binormal ! = p_vertex . binormal ) {
2014-05-14 04:22:15 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
2020-05-14 14:41:43 +00:00
if ( color ! = p_vertex . color ) {
2014-05-14 04:22:15 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
2020-05-14 14:41:43 +00:00
if ( bones . size ( ) ! = p_vertex . bones . size ( ) ) {
2014-05-14 04:22:15 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-05-14 04:22:15 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < bones . size ( ) ; i + + ) {
2020-05-14 14:41:43 +00:00
if ( bones [ i ] ! = p_vertex . bones [ i ] ) {
2014-02-10 01:10:30 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < weights . size ( ) ; i + + ) {
2020-05-14 14:41:43 +00:00
if ( weights [ i ] ! = p_vertex . weights [ i ] ) {
2014-02-10 01:10:30 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
}
2020-12-02 01:40:47 +00:00
for ( int i = 0 ; i < RS : : ARRAY_CUSTOM_MAX ; i + + ) {
if ( custom [ i ] ! = p_vertex . custom [ i ] ) {
return false ;
}
}
2014-05-14 04:22:15 +00:00
return true ;
}
2014-02-10 01:10:30 +00:00
2014-05-14 04:22:15 +00:00
uint32_t SurfaceTool : : VertexHasher : : hash ( const Vertex & p_vtx ) {
2017-03-05 15:44:50 +00:00
uint32_t h = hash_djb2_buffer ( ( const uint8_t * ) & p_vtx . vertex , sizeof ( real_t ) * 3 ) ;
h = hash_djb2_buffer ( ( const uint8_t * ) & p_vtx . normal , sizeof ( real_t ) * 3 , h ) ;
h = hash_djb2_buffer ( ( const uint8_t * ) & p_vtx . binormal , sizeof ( real_t ) * 3 , h ) ;
h = hash_djb2_buffer ( ( const uint8_t * ) & p_vtx . tangent , sizeof ( real_t ) * 3 , h ) ;
h = hash_djb2_buffer ( ( const uint8_t * ) & p_vtx . uv , sizeof ( real_t ) * 2 , h ) ;
h = hash_djb2_buffer ( ( const uint8_t * ) & p_vtx . uv2 , sizeof ( real_t ) * 2 , h ) ;
h = hash_djb2_buffer ( ( const uint8_t * ) & p_vtx . color , sizeof ( real_t ) * 4 , h ) ;
h = hash_djb2_buffer ( ( const uint8_t * ) p_vtx . bones . ptr ( ) , p_vtx . bones . size ( ) * sizeof ( int ) , h ) ;
h = hash_djb2_buffer ( ( const uint8_t * ) p_vtx . weights . ptr ( ) , p_vtx . weights . size ( ) * sizeof ( float ) , h ) ;
2020-12-02 01:40:47 +00:00
h = hash_djb2_buffer ( ( const uint8_t * ) & p_vtx . custom [ 0 ] , sizeof ( Color ) * RS : : ARRAY_CUSTOM_COUNT , h ) ;
2014-05-14 04:22:15 +00:00
return h ;
2014-02-10 01:10:30 +00:00
}
void SurfaceTool : : begin ( Mesh : : PrimitiveType p_primitive ) {
clear ( ) ;
2017-03-05 15:44:50 +00:00
primitive = p_primitive ;
begun = true ;
first = true ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
void SurfaceTool : : add_vertex ( const Vector3 & p_vertex ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
Vertex vtx ;
2017-03-05 15:44:50 +00:00
vtx . vertex = p_vertex ;
vtx . color = last_color ;
vtx . normal = last_normal ;
vtx . uv = last_uv ;
2017-12-09 17:11:26 +00:00
vtx . uv2 = last_uv2 ;
2017-03-05 15:44:50 +00:00
vtx . weights = last_weights ;
vtx . bones = last_bones ;
vtx . tangent = last_tangent . normal ;
2020-05-10 14:47:11 +00:00
vtx . binormal = last_normal . cross ( last_tangent . normal ) . normalized ( ) * last_tangent . d ;
2020-12-02 01:40:47 +00:00
for ( int i = 0 ; i < RS : : ARRAY_CUSTOM_COUNT ; i + + ) {
vtx . custom [ i ] = last_custom [ i ] ;
}
2019-04-13 18:19:26 +00:00
2020-12-02 01:40:47 +00:00
const int expected_vertices = skin_weights = = SKIN_8_WEIGHTS ? 8 : 4 ;
2019-04-13 18:19:26 +00:00
if ( ( format & Mesh : : ARRAY_FORMAT_WEIGHTS | | format & Mesh : : ARRAY_FORMAT_BONES ) & & ( vtx . weights . size ( ) ! = expected_vertices | | vtx . bones . size ( ) ! = expected_vertices ) ) {
//ensure vertices are the expected amount
ERR_FAIL_COND ( vtx . weights . size ( ) ! = vtx . bones . size ( ) ) ;
if ( vtx . weights . size ( ) < expected_vertices ) {
2019-05-19 10:34:40 +00:00
//less than required, fill
2019-04-13 18:19:26 +00:00
for ( int i = vtx . weights . size ( ) ; i < expected_vertices ; i + + ) {
vtx . weights . push_back ( 0 ) ;
vtx . bones . push_back ( 0 ) ;
}
} else if ( vtx . weights . size ( ) > expected_vertices ) {
//more than required, sort, cap and normalize.
Vector < WeightSort > weights ;
for ( int i = 0 ; i < vtx . weights . size ( ) ; i + + ) {
WeightSort ws ;
ws . index = vtx . bones [ i ] ;
ws . weight = vtx . weights [ i ] ;
weights . push_back ( ws ) ;
}
//sort
weights . sort ( ) ;
//cap
weights . resize ( expected_vertices ) ;
//renormalize
float total = 0 ;
for ( int i = 0 ; i < expected_vertices ; i + + ) {
total + = weights [ i ] . weight ;
}
vtx . weights . resize ( expected_vertices ) ;
vtx . bones . resize ( expected_vertices ) ;
for ( int i = 0 ; i < expected_vertices ; i + + ) {
if ( total > 0 ) {
vtx . weights . write [ i ] = weights [ i ] . weight / total ;
} else {
vtx . weights . write [ i ] = 0 ;
}
vtx . bones . write [ i ] = weights [ i ] . index ;
}
}
}
2014-02-10 01:10:30 +00:00
vertex_array . push_back ( vtx ) ;
2017-03-05 15:44:50 +00:00
first = false ;
2019-04-13 18:19:26 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_VERTEX ;
2014-02-10 01:10:30 +00:00
}
2020-05-14 12:29:06 +00:00
2020-12-02 01:40:47 +00:00
void SurfaceTool : : set_color ( Color p_color ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! first & & ! ( format & Mesh : : ARRAY_FORMAT_COLOR ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_COLOR ;
last_color = p_color ;
2014-02-10 01:10:30 +00:00
}
2020-05-14 12:29:06 +00:00
2020-12-02 01:40:47 +00:00
void SurfaceTool : : set_normal ( const Vector3 & p_normal ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! first & & ! ( format & Mesh : : ARRAY_FORMAT_NORMAL ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_NORMAL ;
last_normal = p_normal ;
2014-02-10 01:10:30 +00:00
}
2020-12-02 01:40:47 +00:00
void SurfaceTool : : set_tangent ( const Plane & p_tangent ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! first & & ! ( format & Mesh : : ARRAY_FORMAT_TANGENT ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_TANGENT ;
last_tangent = p_tangent ;
2014-02-10 01:10:30 +00:00
}
2020-12-02 01:40:47 +00:00
void SurfaceTool : : set_uv ( const Vector2 & p_uv ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! first & & ! ( format & Mesh : : ARRAY_FORMAT_TEX_UV ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_TEX_UV ;
last_uv = p_uv ;
2014-02-10 01:10:30 +00:00
}
2020-12-02 01:40:47 +00:00
void SurfaceTool : : set_uv2 ( const Vector2 & p_uv2 ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! first & & ! ( format & Mesh : : ARRAY_FORMAT_TEX_UV2 ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_TEX_UV2 ;
last_uv2 = p_uv2 ;
2014-02-10 01:10:30 +00:00
}
2020-12-02 01:40:47 +00:00
void SurfaceTool : : set_custom ( int p_index , const Color & p_custom ) {
ERR_FAIL_INDEX ( p_index , RS : : ARRAY_CUSTOM_COUNT ) ;
ERR_FAIL_COND ( ! begun ) ;
ERR_FAIL_COND ( last_custom_format [ p_index ] = = CUSTOM_MAX ) ;
static const uint32_t mask [ RS : : ARRAY_CUSTOM_COUNT ] = { Mesh : : ARRAY_FORMAT_CUSTOM0 , Mesh : : ARRAY_FORMAT_CUSTOM1 , Mesh : : ARRAY_FORMAT_CUSTOM2 , Mesh : : ARRAY_FORMAT_CUSTOM3 } ;
static const uint32_t shift [ RS : : ARRAY_CUSTOM_COUNT ] = { Mesh : : ARRAY_FORMAT_CUSTOM0_SHIFT , Mesh : : ARRAY_FORMAT_CUSTOM1_SHIFT , Mesh : : ARRAY_FORMAT_CUSTOM2_SHIFT , Mesh : : ARRAY_FORMAT_CUSTOM3_SHIFT } ;
ERR_FAIL_COND ( ! first & & ! ( format & mask [ p_index ] ) ) ;
if ( first ) {
format | = mask [ p_index ] ;
format | = last_custom_format [ p_index ] < < shift [ p_index ] ;
}
last_custom [ p_index ] = p_custom ;
}
void SurfaceTool : : set_bones ( const Vector < int > & p_bones ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! first & & ! ( format & Mesh : : ARRAY_FORMAT_BONES ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_BONES ;
2020-12-02 01:40:47 +00:00
if ( skin_weights = = SKIN_8_WEIGHTS ) {
format | = Mesh : : ARRAY_FLAG_USE_8_BONE_WEIGHTS ;
}
2017-03-05 15:44:50 +00:00
last_bones = p_bones ;
2014-02-10 01:10:30 +00:00
}
2020-12-02 01:40:47 +00:00
void SurfaceTool : : set_weights ( const Vector < float > & p_weights ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! first & & ! ( format & Mesh : : ARRAY_FORMAT_WEIGHTS ) ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_WEIGHTS ;
2020-12-02 01:40:47 +00:00
if ( skin_weights = = SKIN_8_WEIGHTS ) {
format | = Mesh : : ARRAY_FLAG_USE_8_BONE_WEIGHTS ;
}
2017-03-05 15:44:50 +00:00
last_weights = p_weights ;
2014-02-10 01:10:30 +00:00
}
2014-05-14 04:22:15 +00:00
void SurfaceTool : : add_smooth_group ( bool p_smooth ) {
ERR_FAIL_COND ( ! begun ) ;
if ( index_array . size ( ) ) {
2017-03-05 15:44:50 +00:00
smooth_groups [ index_array . size ( ) ] = p_smooth ;
2014-05-14 04:22:15 +00:00
} else {
2017-03-05 15:44:50 +00:00
smooth_groups [ vertex_array . size ( ) ] = p_smooth ;
2014-05-14 04:22:15 +00:00
}
}
2019-02-13 08:23:29 +00:00
void SurfaceTool : : add_triangle_fan ( const Vector < Vector3 > & p_vertices , const Vector < Vector2 > & p_uvs , const Vector < Color > & p_colors , const Vector < Vector2 > & p_uv2s , const Vector < Vector3 > & p_normals , const Vector < Plane > & p_tangents ) {
2016-04-18 17:33:54 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( primitive ! = Mesh : : PRIMITIVE_TRIANGLES ) ;
2019-02-13 08:23:29 +00:00
ERR_FAIL_COND ( p_vertices . size ( ) < 3 ) ;
2017-03-05 15:44:50 +00:00
# define ADD_POINT(n) \
{ \
if ( p_colors . size ( ) > n ) \
2020-12-02 01:40:47 +00:00
set_color ( p_colors [ n ] ) ; \
2017-03-05 15:44:50 +00:00
if ( p_uvs . size ( ) > n ) \
2020-12-02 01:40:47 +00:00
set_uv ( p_uvs [ n ] ) ; \
2017-03-05 15:44:50 +00:00
if ( p_uv2s . size ( ) > n ) \
2020-12-02 01:40:47 +00:00
set_uv2 ( p_uv2s [ n ] ) ; \
2017-03-05 15:44:50 +00:00
if ( p_normals . size ( ) > n ) \
2020-12-02 01:40:47 +00:00
set_normal ( p_normals [ n ] ) ; \
2017-03-05 15:44:50 +00:00
if ( p_tangents . size ( ) > n ) \
2020-12-02 01:40:47 +00:00
set_tangent ( p_tangents [ n ] ) ; \
2019-02-13 08:23:29 +00:00
add_vertex ( p_vertices [ n ] ) ; \
2016-04-18 17:33:54 +00:00
}
2019-02-13 08:23:29 +00:00
for ( int i = 0 ; i < p_vertices . size ( ) - 2 ; i + + ) {
2016-04-18 17:33:54 +00:00
ADD_POINT ( 0 ) ;
2017-03-05 15:44:50 +00:00
ADD_POINT ( i + 1 ) ;
ADD_POINT ( i + 2 ) ;
2016-04-18 17:33:54 +00:00
}
# undef ADD_POINT
}
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
void SurfaceTool : : add_index ( int p_index ) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND ( ! begun ) ;
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_INDEX ;
2014-02-10 01:10:30 +00:00
index_array . push_back ( p_index ) ;
}
2017-08-02 18:34:55 +00:00
Array SurfaceTool : : commit_to_arrays ( ) {
2017-03-05 15:44:50 +00:00
int varr_len = vertex_array . size ( ) ;
2014-02-10 01:10:30 +00:00
Array a ;
a . resize ( Mesh : : ARRAY_MAX ) ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < Mesh : : ARRAY_MAX ; i + + ) {
2020-05-14 14:41:43 +00:00
if ( ! ( format & ( 1 < < i ) ) ) {
2017-08-02 18:34:55 +00:00
continue ; //not in format
2020-05-14 14:41:43 +00:00
}
2017-08-02 18:34:55 +00:00
switch ( i ) {
case Mesh : : ARRAY_VERTEX :
case Mesh : : ARRAY_NORMAL : {
2020-02-17 21:06:54 +00:00
Vector < Vector3 > array ;
2014-02-10 01:10:30 +00:00
array . resize ( varr_len ) ;
2020-02-17 21:06:54 +00:00
Vector3 * w = array . ptrw ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
switch ( i ) {
2014-02-10 01:10:30 +00:00
case Mesh : : ARRAY_VERTEX : {
2017-03-05 15:44:50 +00:00
w [ idx ] = v . vertex ;
2014-02-10 01:10:30 +00:00
} break ;
case Mesh : : ARRAY_NORMAL : {
2017-03-05 15:44:50 +00:00
w [ idx ] = v . normal ;
2014-02-10 01:10:30 +00:00
} break ;
}
}
2017-03-05 15:44:50 +00:00
a [ i ] = array ;
2014-02-10 01:10:30 +00:00
} break ;
2017-08-02 18:34:55 +00:00
case Mesh : : ARRAY_TEX_UV :
case Mesh : : ARRAY_TEX_UV2 : {
2020-02-17 21:06:54 +00:00
Vector < Vector2 > array ;
2014-02-10 01:10:30 +00:00
array . resize ( varr_len ) ;
2020-02-17 21:06:54 +00:00
Vector2 * w = array . ptrw ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
switch ( i ) {
2014-02-10 01:10:30 +00:00
case Mesh : : ARRAY_TEX_UV : {
2017-03-05 15:44:50 +00:00
w [ idx ] = v . uv ;
2014-02-10 01:10:30 +00:00
} break ;
case Mesh : : ARRAY_TEX_UV2 : {
2017-03-05 15:44:50 +00:00
w [ idx ] = v . uv2 ;
2014-02-10 01:10:30 +00:00
} break ;
}
}
2017-03-05 15:44:50 +00:00
a [ i ] = array ;
2014-02-10 01:10:30 +00:00
} break ;
2017-08-02 18:34:55 +00:00
case Mesh : : ARRAY_TANGENT : {
2020-02-17 21:06:54 +00:00
Vector < float > array ;
2017-03-05 15:44:50 +00:00
array . resize ( varr_len * 4 ) ;
2020-02-17 21:06:54 +00:00
float * w = array . ptrw ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + = 4 ) {
const Vertex & v = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
w [ idx + 0 ] = v . tangent . x ;
w [ idx + 1 ] = v . tangent . y ;
w [ idx + 2 ] = v . tangent . z ;
2014-10-14 04:01:25 +00:00
//float d = v.tangent.dot(v.binormal,v.normal);
2017-03-05 15:44:50 +00:00
float d = v . binormal . dot ( v . normal . cross ( v . tangent ) ) ;
w [ idx + 3 ] = d < 0 ? - 1 : 1 ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
a [ i ] = array ;
2014-02-10 01:10:30 +00:00
} break ;
2017-08-02 18:34:55 +00:00
case Mesh : : ARRAY_COLOR : {
2020-02-17 21:06:54 +00:00
Vector < Color > array ;
2014-02-10 01:10:30 +00:00
array . resize ( varr_len ) ;
2020-02-17 21:06:54 +00:00
Color * w = array . ptrw ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
w [ idx ] = v . color ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
a [ i ] = array ;
2016-03-08 23:00:52 +00:00
} break ;
2020-12-02 01:40:47 +00:00
case Mesh : : ARRAY_CUSTOM0 :
case Mesh : : ARRAY_CUSTOM1 :
case Mesh : : ARRAY_CUSTOM2 :
case Mesh : : ARRAY_CUSTOM3 : {
int fmt = i - Mesh : : ARRAY_CUSTOM0 ;
switch ( last_custom_format [ fmt ] ) {
case CUSTOM_RGBA8_UNORM : {
Vector < uint8_t > array ;
array . resize ( varr_len * 4 ) ;
uint8_t * w = array . ptrw ( ) ;
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
const Color & c = v . custom [ idx ] ;
w [ idx * 4 + 0 ] = CLAMP ( int32_t ( c . r * 255.0 ) , 0 , 255 ) ;
w [ idx * 4 + 1 ] = CLAMP ( int32_t ( c . g * 255.0 ) , 0 , 255 ) ;
w [ idx * 4 + 2 ] = CLAMP ( int32_t ( c . b * 255.0 ) , 0 , 255 ) ;
w [ idx * 4 + 3 ] = CLAMP ( int32_t ( c . a * 255.0 ) , 0 , 255 ) ;
}
a [ i ] = array ;
} break ;
case CUSTOM_RGBA8_SNORM : {
Vector < uint8_t > array ;
array . resize ( varr_len * 4 ) ;
uint8_t * w = array . ptrw ( ) ;
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
const Color & c = v . custom [ idx ] ;
w [ idx * 4 + 0 ] = uint8_t ( int8_t ( CLAMP ( int32_t ( c . r * 127.0 ) , - 128 , 127 ) ) ) ;
w [ idx * 4 + 1 ] = uint8_t ( int8_t ( CLAMP ( int32_t ( c . g * 127.0 ) , - 128 , 127 ) ) ) ;
w [ idx * 4 + 2 ] = uint8_t ( int8_t ( CLAMP ( int32_t ( c . b * 127.0 ) , - 128 , 127 ) ) ) ;
w [ idx * 4 + 3 ] = uint8_t ( int8_t ( CLAMP ( int32_t ( c . a * 127.0 ) , - 128 , 127 ) ) ) ;
}
a [ i ] = array ;
} break ;
case CUSTOM_RG_HALF : {
Vector < uint8_t > array ;
array . resize ( varr_len * 4 ) ;
uint16_t * w = ( uint16_t * ) array . ptrw ( ) ;
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
const Color & c = v . custom [ idx ] ;
w [ idx * 2 + 0 ] = Math : : make_half_float ( c . r ) ;
w [ idx * 2 + 1 ] = Math : : make_half_float ( c . g ) ;
}
a [ i ] = array ;
} break ;
case CUSTOM_RGBA_HALF : {
Vector < uint8_t > array ;
array . resize ( varr_len * 8 ) ;
uint16_t * w = ( uint16_t * ) array . ptrw ( ) ;
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
const Color & c = v . custom [ idx ] ;
w [ idx * 4 + 0 ] = Math : : make_half_float ( c . r ) ;
w [ idx * 4 + 1 ] = Math : : make_half_float ( c . g ) ;
w [ idx * 4 + 2 ] = Math : : make_half_float ( c . b ) ;
w [ idx * 4 + 3 ] = Math : : make_half_float ( c . a ) ;
}
a [ i ] = array ;
} break ;
case CUSTOM_R_FLOAT : {
Vector < float > array ;
array . resize ( varr_len ) ;
float * w = ( float * ) array . ptrw ( ) ;
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
const Color & c = v . custom [ idx ] ;
w [ idx ] = c . r ;
}
a [ i ] = array ;
} break ;
case CUSTOM_RG_FLOAT : {
Vector < float > array ;
array . resize ( varr_len * 2 ) ;
float * w = ( float * ) array . ptrw ( ) ;
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
const Color & c = v . custom [ idx ] ;
w [ idx * 2 + 0 ] = c . r ;
w [ idx * 2 + 1 ] = c . g ;
}
a [ i ] = array ;
} break ;
case CUSTOM_RGB_FLOAT : {
Vector < float > array ;
array . resize ( varr_len * 3 ) ;
float * w = ( float * ) array . ptrw ( ) ;
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
const Color & c = v . custom [ idx ] ;
w [ idx * 3 + 0 ] = c . r ;
w [ idx * 3 + 1 ] = c . g ;
w [ idx * 3 + 2 ] = c . b ;
}
a [ i ] = array ;
} break ;
case CUSTOM_RGBA_FLOAT : {
Vector < float > array ;
array . resize ( varr_len * 4 ) ;
float * w = ( float * ) array . ptrw ( ) ;
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
const Vertex & v = E - > get ( ) ;
const Color & c = v . custom [ idx ] ;
w [ idx * 4 + 0 ] = c . r ;
w [ idx * 4 + 1 ] = c . g ;
w [ idx * 4 + 2 ] = c . b ;
w [ idx * 4 + 3 ] = c . a ;
}
a [ i ] = array ;
} break ;
default : {
} //unreachable but compiler warning anyway
}
} break ;
2017-08-02 18:34:55 +00:00
case Mesh : : ARRAY_BONES : {
2020-12-02 01:40:47 +00:00
int count = skin_weights = = SKIN_8_WEIGHTS ? 8 : 4 ;
2020-02-17 21:06:54 +00:00
Vector < int > array ;
2020-12-02 01:40:47 +00:00
array . resize ( varr_len * count ) ;
2020-02-17 21:06:54 +00:00
int * w = array . ptrw ( ) ;
2016-11-24 23:46:55 +00:00
2017-03-05 15:44:50 +00:00
int idx = 0 ;
2020-12-02 01:40:47 +00:00
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + = count ) {
2017-03-05 15:44:50 +00:00
const Vertex & v = E - > get ( ) ;
2016-11-24 23:46:55 +00:00
2020-12-02 01:40:47 +00:00
ERR_CONTINUE ( v . bones . size ( ) ! = count ) ;
2016-11-24 23:46:55 +00:00
2020-12-02 01:40:47 +00:00
for ( int j = 0 ; j < count ; j + + ) {
2017-03-05 15:44:50 +00:00
w [ idx + j ] = v . bones [ j ] ;
2016-11-24 23:46:55 +00:00
}
}
2017-03-05 15:44:50 +00:00
a [ i ] = array ;
2016-11-24 23:46:55 +00:00
} break ;
2017-08-02 18:34:55 +00:00
case Mesh : : ARRAY_WEIGHTS : {
2020-02-17 21:06:54 +00:00
Vector < float > array ;
2020-12-02 01:40:47 +00:00
int count = skin_weights = = SKIN_8_WEIGHTS ? 8 : 4 ;
array . resize ( varr_len * count ) ;
2020-02-17 21:06:54 +00:00
float * w = array . ptrw ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
int idx = 0 ;
2020-12-02 01:40:47 +00:00
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) , idx + = count ) {
2017-03-05 15:44:50 +00:00
const Vertex & v = E - > get ( ) ;
2020-12-02 01:40:47 +00:00
ERR_CONTINUE ( v . weights . size ( ) ! = count ) ;
2014-02-10 01:10:30 +00:00
2020-12-02 01:40:47 +00:00
for ( int j = 0 ; j < count ; j + + ) {
2017-03-05 15:44:50 +00:00
w [ idx + j ] = v . weights [ j ] ;
2014-02-10 01:10:30 +00:00
}
}
2017-03-05 15:44:50 +00:00
a [ i ] = array ;
2014-02-10 01:10:30 +00:00
} break ;
2017-08-02 18:34:55 +00:00
case Mesh : : ARRAY_INDEX : {
2017-03-05 15:44:50 +00:00
ERR_CONTINUE ( index_array . size ( ) = = 0 ) ;
2014-02-10 01:10:30 +00:00
2020-02-17 21:06:54 +00:00
Vector < int > array ;
2014-02-10 01:10:30 +00:00
array . resize ( index_array . size ( ) ) ;
2020-02-17 21:06:54 +00:00
int * w = array . ptrw ( ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
int idx = 0 ;
for ( List < int > : : Element * E = index_array . front ( ) ; E ; E = E - > next ( ) , idx + + ) {
w [ idx ] = E - > get ( ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
a [ i ] = array ;
2014-02-10 01:10:30 +00:00
} break ;
2019-04-09 15:08:36 +00:00
default : {
}
2014-02-10 01:10:30 +00:00
}
}
2017-08-02 18:34:55 +00:00
return a ;
}
2017-12-09 17:11:26 +00:00
Ref < ArrayMesh > SurfaceTool : : commit ( const Ref < ArrayMesh > & p_existing , uint32_t p_flags ) {
2017-08-02 18:34:55 +00:00
Ref < ArrayMesh > mesh ;
2020-05-14 14:41:43 +00:00
if ( p_existing . is_valid ( ) ) {
2017-08-02 18:34:55 +00:00
mesh = p_existing ;
2020-05-14 14:41:43 +00:00
} else {
2017-08-02 18:34:55 +00:00
mesh . instance ( ) ;
2020-05-14 14:41:43 +00:00
}
2017-08-02 18:34:55 +00:00
int varr_len = vertex_array . size ( ) ;
2020-05-14 14:41:43 +00:00
if ( varr_len = = 0 ) {
2017-08-02 18:34:55 +00:00
return mesh ;
2020-05-14 14:41:43 +00:00
}
2017-08-02 18:34:55 +00:00
int surface = mesh - > get_surface_count ( ) ;
Array a = commit_to_arrays ( ) ;
2019-08-18 22:40:52 +00:00
mesh - > add_surface_from_arrays ( primitive , a , Array ( ) , Dictionary ( ) , p_flags ) ;
2017-11-21 00:36:32 +00:00
2020-05-14 14:41:43 +00:00
if ( material . is_valid ( ) ) {
2017-03-05 15:44:50 +00:00
mesh - > surface_set_material ( surface , material ) ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
return mesh ;
}
void SurfaceTool : : index ( ) {
2020-05-14 14:41:43 +00:00
if ( index_array . size ( ) ) {
2014-05-14 04:22:15 +00:00
return ; //already indexed
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
HashMap < Vertex , int , VertexHasher > indices ;
2014-05-14 04:22:15 +00:00
List < Vertex > new_vertices ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) ) {
int * idxptr = indices . getptr ( E - > get ( ) ) ;
2014-05-14 04:22:15 +00:00
int idx ;
if ( ! idxptr ) {
2017-03-05 15:44:50 +00:00
idx = indices . size ( ) ;
2014-05-14 04:22:15 +00:00
new_vertices . push_back ( E - > get ( ) ) ;
2017-03-05 15:44:50 +00:00
indices [ E - > get ( ) ] = idx ;
2014-02-10 01:10:30 +00:00
} else {
2017-03-05 15:44:50 +00:00
idx = * idxptr ;
2014-02-10 01:10:30 +00:00
}
2014-05-14 04:22:15 +00:00
index_array . push_back ( idx ) ;
2014-02-10 01:10:30 +00:00
}
2014-05-14 04:22:15 +00:00
vertex_array . clear ( ) ;
2017-03-05 15:44:50 +00:00
vertex_array = new_vertices ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_INDEX ;
2014-02-10 01:10:30 +00:00
}
void SurfaceTool : : deindex ( ) {
2020-05-14 14:41:43 +00:00
if ( index_array . size ( ) = = 0 ) {
2014-05-14 04:22:15 +00:00
return ; //nothing to deindex
2020-05-14 14:41:43 +00:00
}
2017-03-05 15:44:50 +00:00
Vector < Vertex > varr ;
2014-05-14 04:22:15 +00:00
varr . resize ( vertex_array . size ( ) ) ;
2017-03-05 15:44:50 +00:00
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) ) {
2018-07-25 01:11:03 +00:00
varr . write [ idx + + ] = E - > get ( ) ;
2014-05-14 04:22:15 +00:00
}
vertex_array . clear ( ) ;
2017-03-05 15:44:50 +00:00
for ( List < int > : : Element * E = index_array . front ( ) ; E ; E = E - > next ( ) ) {
ERR_FAIL_INDEX ( E - > get ( ) , varr . size ( ) ) ;
2014-05-14 04:22:15 +00:00
vertex_array . push_back ( varr [ E - > get ( ) ] ) ;
}
2017-03-05 15:44:50 +00:00
format & = ~ Mesh : : ARRAY_FORMAT_INDEX ;
2017-08-02 18:34:55 +00:00
index_array . clear ( ) ;
2014-02-10 01:10:30 +00:00
}
2020-12-02 01:40:47 +00:00
void SurfaceTool : : _create_list ( const Ref < Mesh > & p_existing , int p_surface , List < Vertex > * r_vertex , List < int > * r_index , uint32_t & lformat ) {
2014-02-10 01:10:30 +00:00
Array arr = p_existing - > surface_get_arrays ( p_surface ) ;
2020-03-27 18:21:27 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = RS : : ARRAY_MAX ) ;
2017-08-02 18:34:55 +00:00
_create_list_from_arrays ( arr , r_vertex , r_index , lformat ) ;
}
2020-12-02 01:40:47 +00:00
Vector < SurfaceTool : : Vertex > SurfaceTool : : create_vertex_array_from_triangle_arrays ( const Array & p_arrays , uint32_t * r_format ) {
2017-12-09 17:11:26 +00:00
Vector < SurfaceTool : : Vertex > ret ;
2020-03-27 18:21:27 +00:00
Vector < Vector3 > varr = p_arrays [ RS : : ARRAY_VERTEX ] ;
Vector < Vector3 > narr = p_arrays [ RS : : ARRAY_NORMAL ] ;
Vector < float > tarr = p_arrays [ RS : : ARRAY_TANGENT ] ;
Vector < Color > carr = p_arrays [ RS : : ARRAY_COLOR ] ;
Vector < Vector2 > uvarr = p_arrays [ RS : : ARRAY_TEX_UV ] ;
Vector < Vector2 > uv2arr = p_arrays [ RS : : ARRAY_TEX_UV2 ] ;
Vector < int > barr = p_arrays [ RS : : ARRAY_BONES ] ;
Vector < float > warr = p_arrays [ RS : : ARRAY_WEIGHTS ] ;
2020-12-02 01:40:47 +00:00
Vector < float > custom_float [ RS : : ARRAY_CUSTOM_COUNT ] ;
2017-12-09 17:11:26 +00:00
int vc = varr . size ( ) ;
2020-05-14 14:41:43 +00:00
if ( vc = = 0 ) {
2020-12-02 01:40:47 +00:00
if ( r_format ) {
* r_format = 0 ;
}
2017-12-09 17:11:26 +00:00
return ret ;
2020-05-14 14:41:43 +00:00
}
2017-12-09 17:11:26 +00:00
2020-02-18 13:57:11 +00:00
int lformat = 0 ;
2017-12-09 17:11:26 +00:00
if ( varr . size ( ) ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_VERTEX ;
2017-12-09 17:11:26 +00:00
}
if ( narr . size ( ) ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_NORMAL ;
2017-12-09 17:11:26 +00:00
}
if ( tarr . size ( ) ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_TANGENT ;
2017-12-09 17:11:26 +00:00
}
if ( carr . size ( ) ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_COLOR ;
2017-12-09 17:11:26 +00:00
}
if ( uvarr . size ( ) ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_TEX_UV ;
2017-12-09 17:11:26 +00:00
}
if ( uv2arr . size ( ) ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_TEX_UV2 ;
2017-12-09 17:11:26 +00:00
}
2020-12-02 01:40:47 +00:00
int wcount = 0 ;
if ( barr . size ( ) & & warr . size ( ) ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_BONES ;
2020-12-02 01:40:47 +00:00
lformat | = RS : : ARRAY_FORMAT_WEIGHTS ;
wcount = barr . size ( ) / varr . size ( ) ;
if ( wcount = = 8 ) {
lformat | = RS : : ARRAY_FLAG_USE_8_BONE_WEIGHTS ;
}
2017-12-09 17:11:26 +00:00
}
2020-12-02 01:40:47 +00:00
2017-12-09 17:11:26 +00:00
if ( warr . size ( ) ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_WEIGHTS ;
2017-12-09 17:11:26 +00:00
}
2020-12-02 01:40:47 +00:00
static const uint32_t custom_mask [ RS : : ARRAY_CUSTOM_COUNT ] = { Mesh : : ARRAY_FORMAT_CUSTOM0 , Mesh : : ARRAY_FORMAT_CUSTOM1 , Mesh : : ARRAY_FORMAT_CUSTOM2 , Mesh : : ARRAY_FORMAT_CUSTOM3 } ;
static const uint32_t custom_shift [ RS : : ARRAY_CUSTOM_COUNT ] = { Mesh : : ARRAY_FORMAT_CUSTOM0_SHIFT , Mesh : : ARRAY_FORMAT_CUSTOM1_SHIFT , Mesh : : ARRAY_FORMAT_CUSTOM2_SHIFT , Mesh : : ARRAY_FORMAT_CUSTOM3_SHIFT } ;
for ( int i = 0 ; i < RS : : ARRAY_CUSTOM_COUNT ; i + + ) {
ERR_CONTINUE_MSG ( p_arrays [ RS : : ARRAY_CUSTOM0 + i ] . get_type ( ) = = Variant : : PACKED_BYTE_ARRAY , " Extracting Byte/Half formats is not supported " ) ;
if ( p_arrays [ RS : : ARRAY_CUSTOM0 + i ] . get_type ( ) = = Variant : : PACKED_FLOAT32_ARRAY ) {
lformat | = custom_mask [ i ] ;
custom_float [ i ] = p_arrays [ RS : : ARRAY_CUSTOM0 + i ] ;
int fmt = custom_float [ i ] . size ( ) / varr . size ( ) ;
if ( fmt = = 1 ) {
lformat | = CUSTOM_R_FLOAT < < custom_shift [ i ] ;
} else if ( fmt = = 2 ) {
lformat | = CUSTOM_RG_FLOAT < < custom_shift [ i ] ;
} else if ( fmt = = 3 ) {
lformat | = CUSTOM_RGB_FLOAT < < custom_shift [ i ] ;
} else if ( fmt = = 4 ) {
lformat | = CUSTOM_RGBA_FLOAT < < custom_shift [ i ] ;
}
}
}
2017-12-09 17:11:26 +00:00
for ( int i = 0 ; i < vc ; i + + ) {
Vertex v ;
2020-05-14 14:41:43 +00:00
if ( lformat & RS : : ARRAY_FORMAT_VERTEX ) {
2017-12-09 17:11:26 +00:00
v . vertex = varr [ i ] ;
2020-05-14 14:41:43 +00:00
}
if ( lformat & RS : : ARRAY_FORMAT_NORMAL ) {
2017-12-09 17:11:26 +00:00
v . normal = narr [ i ] ;
2020-05-14 14:41:43 +00:00
}
2020-03-27 18:21:27 +00:00
if ( lformat & RS : : ARRAY_FORMAT_TANGENT ) {
2017-12-09 17:11:26 +00:00
Plane p ( tarr [ i * 4 + 0 ] , tarr [ i * 4 + 1 ] , tarr [ i * 4 + 2 ] , tarr [ i * 4 + 3 ] ) ;
v . tangent = p . normal ;
2020-05-10 14:47:11 +00:00
v . binormal = p . normal . cross ( v . tangent ) . normalized ( ) * p . d ;
2017-12-09 17:11:26 +00:00
}
2020-05-14 14:41:43 +00:00
if ( lformat & RS : : ARRAY_FORMAT_COLOR ) {
2017-12-09 17:11:26 +00:00
v . color = carr [ i ] ;
2020-05-14 14:41:43 +00:00
}
if ( lformat & RS : : ARRAY_FORMAT_TEX_UV ) {
2017-12-09 17:11:26 +00:00
v . uv = uvarr [ i ] ;
2020-05-14 14:41:43 +00:00
}
if ( lformat & RS : : ARRAY_FORMAT_TEX_UV2 ) {
2017-12-09 17:11:26 +00:00
v . uv2 = uv2arr [ i ] ;
2020-05-14 14:41:43 +00:00
}
2020-03-27 18:21:27 +00:00
if ( lformat & RS : : ARRAY_FORMAT_BONES ) {
2017-12-09 17:11:26 +00:00
Vector < int > b ;
2020-12-02 01:40:47 +00:00
b . resize ( wcount ) ;
for ( int j = 0 ; j < wcount ; j + + ) {
b . write [ j ] = barr [ i * wcount + j ] ;
}
2017-12-09 17:11:26 +00:00
v . bones = b ;
}
2020-03-27 18:21:27 +00:00
if ( lformat & RS : : ARRAY_FORMAT_WEIGHTS ) {
2017-12-09 17:11:26 +00:00
Vector < float > w ;
2020-12-02 01:40:47 +00:00
w . resize ( wcount ) ;
for ( int j = 0 ; j < wcount ; j + + ) {
w . write [ j ] = warr [ i * wcount + j ] ;
}
2017-12-09 17:11:26 +00:00
v . weights = w ;
}
2020-12-02 01:40:47 +00:00
for ( int j = 0 ; j < RS : : ARRAY_CUSTOM_COUNT ; j + + ) {
if ( lformat & custom_mask [ j ] ) {
int cc = custom_float [ j ] . size ( ) / varr . size ( ) ;
for ( int k = 0 ; k < cc ; k + + ) {
v . custom [ j ] [ k ] = custom_float [ j ] [ i * cc + k ] ;
}
}
}
2017-12-09 17:11:26 +00:00
ret . push_back ( v ) ;
}
2020-12-02 01:40:47 +00:00
if ( r_format ) {
* r_format = lformat ;
2020-05-14 14:41:43 +00:00
}
2014-02-10 01:10:30 +00:00
2020-12-02 01:40:47 +00:00
return ret ;
}
2014-02-10 01:10:30 +00:00
2020-12-02 01:40:47 +00:00
void SurfaceTool : : _create_list_from_arrays ( Array arr , List < Vertex > * r_vertex , List < int > * r_index , uint32_t & lformat ) {
Vector < Vertex > arrays = create_vertex_array_from_triangle_arrays ( arr , & lformat ) ;
ERR_FAIL_COND ( arrays . size ( ) = = 0 ) ;
2014-02-10 01:10:30 +00:00
2020-12-02 01:40:47 +00:00
for ( int i = 0 ; i < arrays . size ( ) ; i + + ) {
r_vertex - > push_back ( arrays [ i ] ) ;
2014-02-10 01:10:30 +00:00
}
//indices
2020-03-27 18:21:27 +00:00
Vector < int > idx = arr [ RS : : ARRAY_INDEX ] ;
2014-02-10 01:10:30 +00:00
int is = idx . size ( ) ;
if ( is ) {
2020-03-27 18:21:27 +00:00
lformat | = RS : : ARRAY_FORMAT_INDEX ;
2020-02-17 21:06:54 +00:00
const int * iarr = idx . ptr ( ) ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < is ; i + + ) {
2014-02-10 01:10:30 +00:00
r_index - > push_back ( iarr [ i ] ) ;
}
}
}
2017-08-02 18:34:55 +00:00
void SurfaceTool : : create_from_triangle_arrays ( const Array & p_arrays ) {
clear ( ) ;
primitive = Mesh : : PRIMITIVE_TRIANGLES ;
_create_list_from_arrays ( p_arrays , & vertex_array , & index_array , format ) ;
}
2017-03-05 15:44:50 +00:00
void SurfaceTool : : create_from ( const Ref < Mesh > & p_existing , int p_surface ) {
2014-02-10 01:10:30 +00:00
clear ( ) ;
2017-03-05 15:44:50 +00:00
primitive = p_existing - > surface_get_primitive_type ( p_surface ) ;
_create_list ( p_existing , p_surface , & vertex_array , & index_array , format ) ;
material = p_existing - > surface_get_material ( p_surface ) ;
2014-02-10 01:10:30 +00:00
}
2019-07-10 09:54:12 +00:00
void SurfaceTool : : create_from_blend_shape ( const Ref < Mesh > & p_existing , int p_surface , const String & p_blend_shape_name ) {
2019-02-27 14:51:04 +00:00
clear ( ) ;
primitive = p_existing - > surface_get_primitive_type ( p_surface ) ;
Array arr = p_existing - > surface_get_blend_shape_arrays ( p_surface ) ;
Array blend_shape_names ;
int32_t shape_idx = - 1 ;
for ( int32_t i = 0 ; i < p_existing - > get_blend_shape_count ( ) ; i + + ) {
String name = p_existing - > get_blend_shape_name ( i ) ;
if ( name = = p_blend_shape_name ) {
shape_idx = i ;
break ;
}
}
ERR_FAIL_COND ( shape_idx = = - 1 ) ;
ERR_FAIL_COND ( shape_idx > = arr . size ( ) ) ;
Array mesh = arr [ shape_idx ] ;
2020-03-27 18:21:27 +00:00
ERR_FAIL_COND ( mesh . size ( ) ! = RS : : ARRAY_MAX ) ;
2019-02-27 14:51:04 +00:00
_create_list_from_arrays ( arr [ shape_idx ] , & vertex_array , & index_array , format ) ;
}
2017-03-05 15:44:50 +00:00
void SurfaceTool : : append_from ( const Ref < Mesh > & p_existing , int p_surface , const Transform & p_xform ) {
if ( vertex_array . size ( ) = = 0 ) {
primitive = p_existing - > surface_get_primitive_type ( p_surface ) ;
format = 0 ;
2014-02-10 01:10:30 +00:00
}
2020-12-02 01:40:47 +00:00
uint32_t nformat ;
2014-02-10 01:10:30 +00:00
List < Vertex > nvertices ;
List < int > nindices ;
2017-03-05 15:44:50 +00:00
_create_list ( p_existing , p_surface , & nvertices , & nindices , nformat ) ;
format | = nformat ;
2014-02-10 01:10:30 +00:00
int vfrom = vertex_array . size ( ) ;
2017-03-05 15:44:50 +00:00
for ( List < Vertex > : : Element * E = nvertices . front ( ) ; E ; E = E - > next ( ) ) {
Vertex v = E - > get ( ) ;
v . vertex = p_xform . xform ( v . vertex ) ;
2020-03-27 18:21:27 +00:00
if ( nformat & RS : : ARRAY_FORMAT_NORMAL ) {
2017-03-05 15:44:50 +00:00
v . normal = p_xform . basis . xform ( v . normal ) ;
2014-02-10 01:10:30 +00:00
}
2020-03-27 18:21:27 +00:00
if ( nformat & RS : : ARRAY_FORMAT_TANGENT ) {
2017-03-05 15:44:50 +00:00
v . tangent = p_xform . basis . xform ( v . tangent ) ;
v . binormal = p_xform . basis . xform ( v . binormal ) ;
2014-02-10 01:10:30 +00:00
}
vertex_array . push_back ( v ) ;
}
2017-03-05 15:44:50 +00:00
for ( List < int > : : Element * E = nindices . front ( ) ; E ; E = E - > next ( ) ) {
int dst_index = E - > get ( ) + vfrom ;
2014-02-10 01:10:30 +00:00
index_array . push_back ( dst_index ) ;
}
2018-08-24 07:35:07 +00:00
if ( index_array . size ( ) % 3 ) {
WARN_PRINT ( " SurfaceTool: Index array not a multiple of 3. " ) ;
}
2014-02-10 01:10:30 +00:00
}
2014-10-14 04:01:25 +00:00
//mikktspace callbacks
2018-11-26 15:09:52 +00:00
namespace {
struct TangentGenerationContextUserData {
Vector < List < SurfaceTool : : Vertex > : : Element * > vertices ;
Vector < List < int > : : Element * > indices ;
} ;
} // namespace
2017-03-05 15:44:50 +00:00
int SurfaceTool : : mikktGetNumFaces ( const SMikkTSpaceContext * pContext ) {
2018-11-26 15:09:52 +00:00
TangentGenerationContextUserData & triangle_data = * reinterpret_cast < TangentGenerationContextUserData * > ( pContext - > m_pUserData ) ;
if ( triangle_data . indices . size ( ) > 0 ) {
return triangle_data . indices . size ( ) / 3 ;
} else {
return triangle_data . vertices . size ( ) / 3 ;
}
2014-10-14 04:01:25 +00:00
}
2020-05-14 12:29:06 +00:00
2017-03-05 15:44:50 +00:00
int SurfaceTool : : mikktGetNumVerticesOfFace ( const SMikkTSpaceContext * pContext , const int iFace ) {
2014-10-14 04:01:25 +00:00
return 3 ; //always 3
}
2020-05-14 12:29:06 +00:00
2017-03-05 15:44:50 +00:00
void SurfaceTool : : mikktGetPosition ( const SMikkTSpaceContext * pContext , float fvPosOut [ ] , const int iFace , const int iVert ) {
2018-11-26 15:09:52 +00:00
TangentGenerationContextUserData & triangle_data = * reinterpret_cast < TangentGenerationContextUserData * > ( pContext - > m_pUserData ) ;
Vector3 v ;
if ( triangle_data . indices . size ( ) > 0 ) {
int index = triangle_data . indices [ iFace * 3 + iVert ] - > get ( ) ;
if ( index < triangle_data . vertices . size ( ) ) {
v = triangle_data . vertices [ index ] - > get ( ) . vertex ;
}
} else {
v = triangle_data . vertices [ iFace * 3 + iVert ] - > get ( ) . vertex ;
}
2017-03-05 15:44:50 +00:00
fvPosOut [ 0 ] = v . x ;
fvPosOut [ 1 ] = v . y ;
fvPosOut [ 2 ] = v . z ;
2014-10-14 04:01:25 +00:00
}
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
void SurfaceTool : : mikktGetNormal ( const SMikkTSpaceContext * pContext , float fvNormOut [ ] , const int iFace , const int iVert ) {
2018-11-26 15:09:52 +00:00
TangentGenerationContextUserData & triangle_data = * reinterpret_cast < TangentGenerationContextUserData * > ( pContext - > m_pUserData ) ;
Vector3 v ;
if ( triangle_data . indices . size ( ) > 0 ) {
int index = triangle_data . indices [ iFace * 3 + iVert ] - > get ( ) ;
if ( index < triangle_data . vertices . size ( ) ) {
v = triangle_data . vertices [ index ] - > get ( ) . normal ;
}
} else {
v = triangle_data . vertices [ iFace * 3 + iVert ] - > get ( ) . normal ;
}
2017-03-05 15:44:50 +00:00
fvNormOut [ 0 ] = v . x ;
fvNormOut [ 1 ] = v . y ;
fvNormOut [ 2 ] = v . z ;
2014-10-14 04:01:25 +00:00
}
2020-05-14 12:29:06 +00:00
2017-03-05 15:44:50 +00:00
void SurfaceTool : : mikktGetTexCoord ( const SMikkTSpaceContext * pContext , float fvTexcOut [ ] , const int iFace , const int iVert ) {
2018-11-26 15:09:52 +00:00
TangentGenerationContextUserData & triangle_data = * reinterpret_cast < TangentGenerationContextUserData * > ( pContext - > m_pUserData ) ;
Vector2 v ;
if ( triangle_data . indices . size ( ) > 0 ) {
int index = triangle_data . indices [ iFace * 3 + iVert ] - > get ( ) ;
if ( index < triangle_data . vertices . size ( ) ) {
v = triangle_data . vertices [ index ] - > get ( ) . uv ;
}
} else {
v = triangle_data . vertices [ iFace * 3 + iVert ] - > get ( ) . uv ;
}
2017-03-05 15:44:50 +00:00
fvTexcOut [ 0 ] = v . x ;
fvTexcOut [ 1 ] = v . y ;
2014-10-14 04:01:25 +00:00
}
2017-08-29 11:47:29 +00:00
void SurfaceTool : : mikktSetTSpaceDefault ( const SMikkTSpaceContext * pContext , const float fvTangent [ ] , const float fvBiTangent [ ] , const float fMagS , const float fMagT ,
const tbool bIsOrientationPreserving , const int iFace , const int iVert ) {
2018-11-26 15:09:52 +00:00
TangentGenerationContextUserData & triangle_data = * reinterpret_cast < TangentGenerationContextUserData * > ( pContext - > m_pUserData ) ;
2020-04-01 23:20:12 +00:00
Vertex * vtx = nullptr ;
2018-11-26 15:09:52 +00:00
if ( triangle_data . indices . size ( ) > 0 ) {
int index = triangle_data . indices [ iFace * 3 + iVert ] - > get ( ) ;
if ( index < triangle_data . vertices . size ( ) ) {
vtx = & triangle_data . vertices [ index ] - > get ( ) ;
}
} else {
vtx = & triangle_data . vertices [ iFace * 3 + iVert ] - > get ( ) ;
}
2014-05-14 04:22:15 +00:00
2020-04-01 23:20:12 +00:00
if ( vtx ! = nullptr ) {
2018-11-26 15:09:52 +00:00
vtx - > tangent = Vector3 ( fvTangent [ 0 ] , fvTangent [ 1 ] , fvTangent [ 2 ] ) ;
2018-12-08 02:43:46 +00:00
vtx - > binormal = Vector3 ( - fvBiTangent [ 0 ] , - fvBiTangent [ 1 ] , - fvBiTangent [ 2 ] ) ; // for some reason these are reversed, something with the coordinate system in Godot
2018-11-26 15:09:52 +00:00
}
2014-10-14 04:01:25 +00:00
}
2014-05-14 04:22:15 +00:00
2014-10-14 04:01:25 +00:00
void SurfaceTool : : generate_tangents ( ) {
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! ( format & Mesh : : ARRAY_FORMAT_TEX_UV ) ) ;
ERR_FAIL_COND ( ! ( format & Mesh : : ARRAY_FORMAT_NORMAL ) ) ;
2014-05-14 04:22:15 +00:00
2014-10-14 04:01:25 +00:00
SMikkTSpaceInterface mkif ;
2017-03-05 15:44:50 +00:00
mkif . m_getNormal = mikktGetNormal ;
mkif . m_getNumFaces = mikktGetNumFaces ;
mkif . m_getNumVerticesOfFace = mikktGetNumVerticesOfFace ;
mkif . m_getPosition = mikktGetPosition ;
mkif . m_getTexCoord = mikktGetTexCoord ;
2017-08-29 11:47:29 +00:00
mkif . m_setTSpace = mikktSetTSpaceDefault ;
2020-04-01 23:20:12 +00:00
mkif . m_setTSpaceBasic = nullptr ;
2014-05-14 04:22:15 +00:00
2014-10-14 04:01:25 +00:00
SMikkTSpaceContext msc ;
2017-03-05 15:44:50 +00:00
msc . m_pInterface = & mkif ;
2014-05-14 04:22:15 +00:00
2018-11-26 15:09:52 +00:00
TangentGenerationContextUserData triangle_data ;
triangle_data . vertices . resize ( vertex_array . size ( ) ) ;
2017-03-05 15:44:50 +00:00
int idx = 0 ;
for ( List < Vertex > : : Element * E = vertex_array . front ( ) ; E ; E = E - > next ( ) ) {
2018-11-26 15:09:52 +00:00
triangle_data . vertices . write [ idx + + ] = E ;
2017-03-05 15:44:50 +00:00
E - > get ( ) . binormal = Vector3 ( ) ;
E - > get ( ) . tangent = Vector3 ( ) ;
2014-10-14 04:01:25 +00:00
}
2018-11-26 15:09:52 +00:00
triangle_data . indices . resize ( index_array . size ( ) ) ;
idx = 0 ;
for ( List < int > : : Element * E = index_array . front ( ) ; E ; E = E - > next ( ) ) {
triangle_data . indices . write [ idx + + ] = E ;
}
msc . m_pUserData = & triangle_data ;
2014-05-14 04:22:15 +00:00
2014-10-14 04:01:25 +00:00
bool res = genTangSpaceDefault ( & msc ) ;
2014-05-14 04:22:15 +00:00
2014-10-14 04:01:25 +00:00
ERR_FAIL_COND ( ! res ) ;
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_TANGENT ;
2014-02-10 01:10:30 +00:00
}
2018-02-14 19:14:23 +00:00
void SurfaceTool : : generate_normals ( bool p_flip ) {
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( primitive ! = Mesh : : PRIMITIVE_TRIANGLES ) ;
2014-05-14 04:22:15 +00:00
2017-03-05 15:44:50 +00:00
bool was_indexed = index_array . size ( ) ;
2014-05-14 04:22:15 +00:00
deindex ( ) ;
2017-03-05 15:44:50 +00:00
HashMap < Vertex , Vector3 , VertexHasher > vertex_hash ;
2014-05-14 04:22:15 +00:00
2017-03-05 15:44:50 +00:00
int count = 0 ;
bool smooth = false ;
2020-05-14 14:41:43 +00:00
if ( smooth_groups . has ( 0 ) ) {
2017-03-05 15:44:50 +00:00
smooth = smooth_groups [ 0 ] ;
2020-05-14 14:41:43 +00:00
}
2014-05-14 04:22:15 +00:00
2017-03-05 15:44:50 +00:00
List < Vertex > : : Element * B = vertex_array . front ( ) ;
for ( List < Vertex > : : Element * E = B ; E ; ) {
List < Vertex > : : Element * v [ 3 ] ;
v [ 0 ] = E ;
v [ 1 ] = v [ 0 ] - > next ( ) ;
2014-05-14 04:22:15 +00:00
ERR_FAIL_COND ( ! v [ 1 ] ) ;
2017-03-05 15:44:50 +00:00
v [ 2 ] = v [ 1 ] - > next ( ) ;
2014-05-14 04:22:15 +00:00
ERR_FAIL_COND ( ! v [ 2 ] ) ;
2017-03-05 15:44:50 +00:00
E = v [ 2 ] - > next ( ) ;
2014-05-14 04:22:15 +00:00
2018-02-14 19:14:23 +00:00
Vector3 normal ;
2020-05-14 14:41:43 +00:00
if ( ! p_flip ) {
2018-02-14 19:14:23 +00:00
normal = Plane ( v [ 0 ] - > get ( ) . vertex , v [ 1 ] - > get ( ) . vertex , v [ 2 ] - > get ( ) . vertex ) . normal ;
2020-05-14 14:41:43 +00:00
} else {
2018-02-14 19:14:23 +00:00
normal = Plane ( v [ 2 ] - > get ( ) . vertex , v [ 1 ] - > get ( ) . vertex , v [ 0 ] - > get ( ) . vertex ) . normal ;
2020-05-14 14:41:43 +00:00
}
2014-05-14 04:22:15 +00:00
if ( smooth ) {
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < 3 ; i + + ) {
Vector3 * lv = vertex_hash . getptr ( v [ i ] - > get ( ) ) ;
2014-05-14 04:22:15 +00:00
if ( ! lv ) {
2017-03-05 15:44:50 +00:00
vertex_hash . set ( v [ i ] - > get ( ) , normal ) ;
2014-05-14 04:22:15 +00:00
} else {
2017-03-05 15:44:50 +00:00
( * lv ) + = normal ;
2014-05-14 04:22:15 +00:00
}
}
} else {
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < 3 ; i + + ) {
v [ i ] - > get ( ) . normal = normal ;
2014-05-14 04:22:15 +00:00
}
}
2017-03-05 15:44:50 +00:00
count + = 3 ;
2014-05-14 04:22:15 +00:00
if ( smooth_groups . has ( count ) | | ! E ) {
if ( vertex_hash . size ( ) ) {
2017-03-05 15:44:50 +00:00
while ( B ! = E ) {
Vector3 * lv = vertex_hash . getptr ( B - > get ( ) ) ;
2014-05-14 04:22:15 +00:00
if ( lv ) {
2017-03-05 15:44:50 +00:00
B - > get ( ) . normal = lv - > normalized ( ) ;
2014-05-14 04:22:15 +00:00
}
2017-03-05 15:44:50 +00:00
B = B - > next ( ) ;
2014-05-14 04:22:15 +00:00
}
} else {
2017-03-05 15:44:50 +00:00
B = E ;
2014-05-14 04:22:15 +00:00
}
vertex_hash . clear ( ) ;
if ( E ) {
2017-03-05 15:44:50 +00:00
smooth = smooth_groups [ count ] ;
2014-05-14 04:22:15 +00:00
}
}
}
2017-03-05 15:44:50 +00:00
format | = Mesh : : ARRAY_FORMAT_NORMAL ;
2014-05-14 04:22:15 +00:00
if ( was_indexed ) {
index ( ) ;
smooth_groups . clear ( ) ;
}
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
void SurfaceTool : : set_material ( const Ref < Material > & p_material ) {
material = p_material ;
2014-02-10 01:10:30 +00:00
}
void SurfaceTool : : clear ( ) {
2017-03-05 15:44:50 +00:00
begun = false ;
primitive = Mesh : : PRIMITIVE_LINES ;
format = 0 ;
2017-01-14 17:03:38 +00:00
last_bones . clear ( ) ;
2014-02-10 01:10:30 +00:00
last_weights . clear ( ) ;
index_array . clear ( ) ;
vertex_array . clear ( ) ;
2014-05-14 04:22:15 +00:00
smooth_groups . clear ( ) ;
2017-07-18 00:05:38 +00:00
material . unref ( ) ;
2020-12-02 01:40:47 +00:00
for ( int i = 0 ; i < RS : : ARRAY_CUSTOM_COUNT ; i + + ) {
last_custom_format [ i ] = CUSTOM_MAX ;
}
skin_weights = SKIN_4_WEIGHTS ;
}
void SurfaceTool : : set_skin_weight_count ( SkinWeightCount p_weights ) {
ERR_FAIL_COND ( begun ) ;
skin_weights = p_weights ;
}
SurfaceTool : : SkinWeightCount SurfaceTool : : get_skin_weight_count ( ) const {
return skin_weights ;
}
void SurfaceTool : : set_custom_format ( int p_index , CustomFormat p_format ) {
ERR_FAIL_INDEX ( p_index , RS : : ARRAY_CUSTOM_COUNT ) ;
ERR_FAIL_COND ( begun ) ;
last_custom_format [ p_index ] = p_format ;
}
SurfaceTool : : CustomFormat SurfaceTool : : get_custom_format ( int p_index ) const {
ERR_FAIL_INDEX_V ( p_index , RS : : ARRAY_CUSTOM_COUNT , CUSTOM_MAX ) ;
return last_custom_format [ p_index ] ;
2014-02-10 01:10:30 +00:00
}
void SurfaceTool : : _bind_methods ( ) {
2020-12-02 01:40:47 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_skin_weight_count " , " count " ) , & SurfaceTool : : set_skin_weight_count ) ;
ClassDB : : bind_method ( D_METHOD ( " get_skin_weight_count " ) , & SurfaceTool : : get_skin_weight_count ) ;
ClassDB : : bind_method ( D_METHOD ( " set_custom_format " , " index " , " format " ) , & SurfaceTool : : set_custom_format ) ;
ClassDB : : bind_method ( D_METHOD ( " get_custom_format " , " index " ) , & SurfaceTool : : get_custom_format ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " begin " , " primitive " ) , & SurfaceTool : : begin ) ;
2017-07-31 09:10:41 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " add_vertex " , " vertex " ) , & SurfaceTool : : add_vertex ) ;
2020-12-02 01:40:47 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_color " , " color " ) , & SurfaceTool : : set_color ) ;
ClassDB : : bind_method ( D_METHOD ( " set_normal " , " normal " ) , & SurfaceTool : : set_normal ) ;
ClassDB : : bind_method ( D_METHOD ( " set_tangent " , " tangent " ) , & SurfaceTool : : set_tangent ) ;
ClassDB : : bind_method ( D_METHOD ( " set_uv " , " uv " ) , & SurfaceTool : : set_uv ) ;
ClassDB : : bind_method ( D_METHOD ( " set_uv2 " , " uv2 " ) , & SurfaceTool : : set_uv2 ) ;
ClassDB : : bind_method ( D_METHOD ( " set_bones " , " bones " ) , & SurfaceTool : : set_bones ) ;
ClassDB : : bind_method ( D_METHOD ( " set_weights " , " weights " ) , & SurfaceTool : : set_weights ) ;
ClassDB : : bind_method ( D_METHOD ( " set_custom " , " index " , " custom " ) , & SurfaceTool : : set_custom ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " add_smooth_group " , " smooth " ) , & SurfaceTool : : add_smooth_group ) ;
2017-07-31 09:10:41 +00:00
2019-02-13 08:23:29 +00:00
ClassDB : : bind_method ( D_METHOD ( " add_triangle_fan " , " vertices " , " uvs " , " colors " , " uv2s " , " normals " , " tangents " ) , & SurfaceTool : : add_triangle_fan , DEFVAL ( Vector < Vector2 > ( ) ) , DEFVAL ( Vector < Color > ( ) ) , DEFVAL ( Vector < Vector2 > ( ) ) , DEFVAL ( Vector < Vector3 > ( ) ) , DEFVAL ( Vector < Plane > ( ) ) ) ;
2017-07-31 09:10:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " add_index " , " index " ) , & SurfaceTool : : add_index ) ;
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " index " ) , & SurfaceTool : : index ) ;
ClassDB : : bind_method ( D_METHOD ( " deindex " ) , & SurfaceTool : : deindex ) ;
2018-02-14 19:14:23 +00:00
ClassDB : : bind_method ( D_METHOD ( " generate_normals " , " flip " ) , & SurfaceTool : : generate_normals , DEFVAL ( false ) ) ;
2017-07-31 09:10:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " generate_tangents " ) , & SurfaceTool : : generate_tangents ) ;
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_material " , " material " ) , & SurfaceTool : : set_material ) ;
2017-07-31 09:10:41 +00:00
2017-03-05 15:44:50 +00:00
ClassDB : : bind_method ( D_METHOD ( " clear " ) , & SurfaceTool : : clear ) ;
2017-07-31 09:10:41 +00:00
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " create_from " , " existing " , " surface " ) , & SurfaceTool : : create_from ) ;
2019-02-27 14:51:04 +00:00
ClassDB : : bind_method ( D_METHOD ( " create_from_blend_shape " , " existing " , " surface " , " blend_shape " ) , & SurfaceTool : : create_from_blend_shape ) ;
2017-08-09 11:19:41 +00:00
ClassDB : : bind_method ( D_METHOD ( " append_from " , " existing " , " surface " , " transform " ) , & SurfaceTool : : append_from ) ;
2020-12-02 01:40:47 +00:00
ClassDB : : bind_method ( D_METHOD ( " commit " , " existing " , " flags " ) , & SurfaceTool : : commit , DEFVAL ( Variant ( ) ) , DEFVAL ( 0 ) ) ;
2019-02-27 14:51:04 +00:00
ClassDB : : bind_method ( D_METHOD ( " commit_to_arrays " ) , & SurfaceTool : : commit_to_arrays ) ;
2020-12-02 01:40:47 +00:00
BIND_ENUM_CONSTANT ( CUSTOM_RGBA8_UNORM ) ;
BIND_ENUM_CONSTANT ( CUSTOM_RGBA8_SNORM ) ;
BIND_ENUM_CONSTANT ( CUSTOM_RG_HALF ) ;
BIND_ENUM_CONSTANT ( CUSTOM_RGBA_HALF ) ;
BIND_ENUM_CONSTANT ( CUSTOM_R_FLOAT ) ;
BIND_ENUM_CONSTANT ( CUSTOM_RG_FLOAT ) ;
BIND_ENUM_CONSTANT ( CUSTOM_RGB_FLOAT ) ;
BIND_ENUM_CONSTANT ( CUSTOM_RGBA_FLOAT ) ;
BIND_ENUM_CONSTANT ( CUSTOM_MAX ) ;
BIND_ENUM_CONSTANT ( SKIN_4_WEIGHTS ) ;
BIND_ENUM_CONSTANT ( SKIN_8_WEIGHTS ) ;
2014-02-10 01:10:30 +00:00
}
SurfaceTool : : SurfaceTool ( ) {
2017-03-05 15:44:50 +00:00
first = false ;
begun = false ;
2020-12-02 01:40:47 +00:00
for ( int i = 0 ; i < RS : : ARRAY_CUSTOM_COUNT ; i + + ) {
last_custom_format [ i ] = CUSTOM_MAX ;
}
2017-03-05 15:44:50 +00:00
primitive = Mesh : : PRIMITIVE_LINES ;
2020-12-02 01:40:47 +00:00
skin_weights = SKIN_4_WEIGHTS ;
2017-03-05 15:44:50 +00:00
format = 0 ;
2014-02-10 01:10:30 +00:00
}