b24fe3dd20
-=-=-=-=-=-=-=-=-=-=- -Fixes to Collada Exporter (avoid crash situtions) -Fixed to Collada Importer (Fixed Animation Optimizer Bugs) -Fixes to RigidBody/RigidBody2D body_enter/body_exit, was buggy -Fixed ability for RigidBody/RigidBody2D to get contacts reported and bodyin/out in Kinematic mode. -Added proper trigger support for 3D Physics shapes -Changed proper value for Z-Offset in OmniLight -Fixed spot attenuation bug in SpotLight -Fixed some 3D and 2D spatial soudn bugs related to distance attenuation. -Fixed bugs in EventPlayer (channels were muted by default) -Fix in ButtonGroup (get nodes in group are now returned in order) -Fixed Linear->SRGB Conversion, previous algo sucked, new algo works OK -Changed SRGB->Linear conversion to use hardware if supported, improves texture quality a lot -Fixed options for Y-Fov and X-Fov in camera, should be more intuitive. -Fixed bugs related to viewports and transparency Huge Amount of New Stuff: -=-=-=-=-=-=-=-==-=-=-=- -Ability to manually advance an AnimationPlayer that is inactive (with advance() function) -More work in WinRT platform -Added XY normalmap support, imports on this format by default. Reduces normlmap size and enables much nice compression using LATC -Added Anisotropic filter support to textures, can be specified on import -Added support for Non-Square, Isometric and Hexagonal tilemaps in TileMap. -Added Isometric Dungeon demo. -Added simple hexagonal map demo. -Added Truck-Town demo. Shows how most types of joints and vehicles are used. Please somebody make a nicer town, this one is too hardcore. -Added an Object-Picking API to both RigidBody and Area! (and relevant demo)
1138 lines
24 KiB
C++
1138 lines
24 KiB
C++
/*************************************************************************/
|
|
/* geometry.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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. */
|
|
/*************************************************************************/
|
|
#include "geometry.h"
|
|
#include "print_string.h"
|
|
|
|
|
|
|
|
void Geometry::MeshData::optimize_vertices() {
|
|
|
|
Map<int,int> vtx_remap;
|
|
|
|
for(int i=0;i<faces.size();i++) {
|
|
|
|
for(int j=0;j<faces[i].indices.size();j++) {
|
|
|
|
int idx = faces[i].indices[j];
|
|
if (!vtx_remap.has(idx)) {
|
|
int ni = vtx_remap.size();
|
|
vtx_remap[idx]=ni;
|
|
|
|
|
|
}
|
|
|
|
faces[i].indices[j]=vtx_remap[idx];
|
|
}
|
|
}
|
|
|
|
for(int i=0;i<edges.size();i++) {
|
|
|
|
int a = edges[i].a;
|
|
int b = edges[i].b;
|
|
|
|
if (!vtx_remap.has(a)) {
|
|
int ni = vtx_remap.size();
|
|
vtx_remap[a]=ni;
|
|
}
|
|
if (!vtx_remap.has(b)) {
|
|
int ni = vtx_remap.size();
|
|
vtx_remap[b]=ni;
|
|
}
|
|
|
|
edges[i].a=vtx_remap[a];
|
|
edges[i].b=vtx_remap[b];
|
|
}
|
|
|
|
Vector<Vector3> new_vertices;
|
|
new_vertices.resize(vtx_remap.size());
|
|
|
|
for(int i=0;i<vertices.size();i++) {
|
|
|
|
if (vtx_remap.has(i))
|
|
new_vertices[vtx_remap[i]]=vertices[i];
|
|
}
|
|
vertices=new_vertices;
|
|
}
|
|
|
|
Vector< Vector<Vector2> > (*Geometry::_decompose_func)(const Vector<Vector2>& p_polygon)=NULL;
|
|
|
|
struct _FaceClassify {
|
|
|
|
struct _Link {
|
|
|
|
int face;
|
|
int edge;
|
|
void clear() { face=-1; edge=-1; }
|
|
_Link() { face=-1; edge=-1; }
|
|
};
|
|
bool valid;
|
|
int group;
|
|
_Link links[3];
|
|
Face3 face;
|
|
_FaceClassify() {
|
|
group=-1;
|
|
valid=false;
|
|
};
|
|
};
|
|
|
|
static bool _connect_faces(_FaceClassify *p_faces, int len, int p_group) {
|
|
/* connect faces, error will occur if an edge is shared between more than 2 faces */
|
|
/* clear connections */
|
|
|
|
bool error=false;
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
for (int j=0;j<3;j++) {
|
|
|
|
p_faces[i].links[j].clear();
|
|
}
|
|
}
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
if (p_faces[i].group!=p_group)
|
|
continue;
|
|
for (int j=i+1;j<len;j++) {
|
|
|
|
if (p_faces[j].group!=p_group)
|
|
continue;
|
|
|
|
for (int k=0;k<3;k++) {
|
|
|
|
Vector3 vi1=p_faces[i].face.vertex[k];
|
|
Vector3 vi2=p_faces[i].face.vertex[(k+1)%3];
|
|
|
|
for (int l=0;l<3;l++) {
|
|
|
|
Vector3 vj2=p_faces[j].face.vertex[l];
|
|
Vector3 vj1=p_faces[j].face.vertex[(l+1)%3];
|
|
|
|
if (vi1.distance_to(vj1)<0.00001 &&
|
|
vi2.distance_to(vj2)<0.00001
|
|
) {
|
|
if (p_faces[i].links[k].face!=-1) {
|
|
|
|
ERR_PRINT("already linked\n");
|
|
error=true;
|
|
break;
|
|
}
|
|
if (p_faces[j].links[l].face!=-1) {
|
|
|
|
ERR_PRINT("already linked\n");
|
|
error=true;
|
|
break;
|
|
}
|
|
|
|
p_faces[i].links[k].face=j;
|
|
p_faces[i].links[k].edge=l;
|
|
p_faces[j].links[l].face=i;
|
|
p_faces[j].links[l].edge=k;
|
|
}
|
|
}
|
|
if (error)
|
|
break;
|
|
|
|
}
|
|
if (error)
|
|
break;
|
|
|
|
}
|
|
if (error)
|
|
break;
|
|
}
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
p_faces[i].valid=true;
|
|
for (int j=0;j<3;j++) {
|
|
|
|
if (p_faces[i].links[j].face==-1)
|
|
p_faces[i].valid=false;
|
|
}
|
|
/*printf("face %i is valid: %i, group %i. connected to %i:%i,%i:%i,%i:%i\n",i,p_faces[i].valid,p_faces[i].group,
|
|
p_faces[i].links[0].face,
|
|
p_faces[i].links[0].edge,
|
|
p_faces[i].links[1].face,
|
|
p_faces[i].links[1].edge,
|
|
p_faces[i].links[2].face,
|
|
p_faces[i].links[2].edge);*/
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static bool _group_face(_FaceClassify *p_faces, int len, int p_index,int p_group) {
|
|
|
|
if (p_faces[p_index].group>=0)
|
|
return false;
|
|
|
|
p_faces[p_index].group=p_group;
|
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
ERR_FAIL_INDEX_V(p_faces[p_index].links[i].face,len,true);
|
|
_group_face(p_faces,len,p_faces[p_index].links[i].face,p_group);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
DVector< DVector< Face3 > > Geometry::separate_objects( DVector< Face3 > p_array ) {
|
|
|
|
DVector< DVector< Face3 > > objects;
|
|
|
|
int len = p_array.size();
|
|
|
|
DVector<Face3>::Read r=p_array.read();
|
|
|
|
const Face3* arrayptr = r.ptr();
|
|
|
|
DVector< _FaceClassify> fc;
|
|
|
|
fc.resize( len );
|
|
|
|
DVector< _FaceClassify >::Write fcw=fc.write();
|
|
|
|
_FaceClassify * _fcptr = fcw.ptr();
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
_fcptr[i].face=arrayptr[i];
|
|
}
|
|
|
|
bool error=_connect_faces(_fcptr,len,-1);
|
|
|
|
if (error) {
|
|
|
|
ERR_FAIL_COND_V(error, DVector< DVector< Face3 > >() ); // invalid geometry
|
|
}
|
|
|
|
/* group connected faces in separate objects */
|
|
|
|
int group=0;
|
|
for (int i=0;i<len;i++) {
|
|
|
|
if (!_fcptr[i].valid)
|
|
continue;
|
|
if (_group_face(_fcptr,len,i,group)) {
|
|
group++;
|
|
}
|
|
}
|
|
|
|
/* group connected faces in separate objects */
|
|
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
_fcptr[i].face=arrayptr[i];
|
|
}
|
|
|
|
if (group>=0) {
|
|
|
|
objects.resize(group);
|
|
DVector< DVector<Face3> >::Write obw=objects.write();
|
|
DVector< Face3 > *group_faces = obw.ptr();
|
|
|
|
for (int i=0;i<len;i++) {
|
|
if (!_fcptr[i].valid)
|
|
continue;
|
|
if (_fcptr[i].group>=0 && _fcptr[i].group<group) {
|
|
|
|
group_faces[_fcptr[i].group].push_back( _fcptr[i].face );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return objects;
|
|
|
|
}
|
|
|
|
/*** GEOMETRY WRAPPER ***/
|
|
|
|
enum _CellFlags {
|
|
|
|
_CELL_SOLID=1,
|
|
_CELL_EXTERIOR=2,
|
|
_CELL_STEP_MASK=0x1C,
|
|
_CELL_STEP_NONE=0<<2,
|
|
_CELL_STEP_Y_POS=1<<2,
|
|
_CELL_STEP_Y_NEG=2<<2,
|
|
_CELL_STEP_X_POS=3<<2,
|
|
_CELL_STEP_X_NEG=4<<2,
|
|
_CELL_STEP_Z_POS=5<<2,
|
|
_CELL_STEP_Z_NEG=6<<2,
|
|
_CELL_STEP_DONE=7<<2,
|
|
_CELL_PREV_MASK=0xE0,
|
|
_CELL_PREV_NONE=0<<5,
|
|
_CELL_PREV_Y_POS=1<<5,
|
|
_CELL_PREV_Y_NEG=2<<5,
|
|
_CELL_PREV_X_POS=3<<5,
|
|
_CELL_PREV_X_NEG=4<<5,
|
|
_CELL_PREV_Z_POS=5<<5,
|
|
_CELL_PREV_Z_NEG=6<<5,
|
|
_CELL_PREV_FIRST=7<<5,
|
|
|
|
};
|
|
|
|
static inline void _plot_face(uint8_t*** p_cell_status,int x,int y,int z,int len_x,int len_y,int len_z,const Vector3& voxelsize,const Face3& p_face) {
|
|
|
|
AABB aabb( Vector3(x,y,z),Vector3(len_x,len_y,len_z));
|
|
aabb.pos=aabb.pos*voxelsize;
|
|
aabb.size=aabb.size*voxelsize;
|
|
|
|
if (!p_face.intersects_aabb(aabb))
|
|
return;
|
|
|
|
if (len_x==1 && len_y==1 && len_z==1) {
|
|
|
|
p_cell_status[x][y][z]=_CELL_SOLID;
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
int div_x=len_x>1?2:1;
|
|
int div_y=len_y>1?2:1;
|
|
int div_z=len_z>1?2:1;
|
|
|
|
#define _SPLIT(m_i,m_div,m_v,m_len_v,m_new_v,m_new_len_v)\
|
|
if (m_div==1) {\
|
|
m_new_v=m_v;\
|
|
m_new_len_v=1; \
|
|
} else if (m_i==0) {\
|
|
m_new_v=m_v;\
|
|
m_new_len_v=m_len_v/2;\
|
|
} else {\
|
|
m_new_v=m_v+m_len_v/2;\
|
|
m_new_len_v=m_len_v-m_len_v/2; \
|
|
}
|
|
|
|
int new_x;
|
|
int new_len_x;
|
|
int new_y;
|
|
int new_len_y;
|
|
int new_z;
|
|
int new_len_z;
|
|
|
|
for (int i=0;i<div_x;i++) {
|
|
|
|
|
|
_SPLIT(i,div_x,x,len_x,new_x,new_len_x);
|
|
|
|
for (int j=0;j<div_y;j++) {
|
|
|
|
_SPLIT(j,div_y,y,len_y,new_y,new_len_y);
|
|
|
|
for (int k=0;k<div_z;k++) {
|
|
|
|
_SPLIT(k,div_z,z,len_z,new_z,new_len_z);
|
|
|
|
_plot_face(p_cell_status,new_x,new_y,new_z,new_len_x,new_len_y,new_len_z,voxelsize,p_face);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static inline void _mark_outside(uint8_t*** p_cell_status,int x,int y,int z,int len_x,int len_y,int len_z) {
|
|
|
|
if (p_cell_status[x][y][z]&3)
|
|
return; // nothing to do, already used and/or visited
|
|
|
|
p_cell_status[x][y][z]=_CELL_PREV_FIRST;
|
|
|
|
while(true) {
|
|
|
|
uint8_t &c = p_cell_status[x][y][z];
|
|
|
|
//printf("at %i,%i,%i\n",x,y,z);
|
|
|
|
if ( (c&_CELL_STEP_MASK)==_CELL_STEP_NONE) {
|
|
/* Haven't been in here, mark as outside */
|
|
p_cell_status[x][y][z]|=_CELL_EXTERIOR;
|
|
//printf("not marked as anything, marking exterior\n");
|
|
}
|
|
|
|
//printf("cell step is %i\n",(c&_CELL_STEP_MASK));
|
|
|
|
if ( (c&_CELL_STEP_MASK)!=_CELL_STEP_DONE) {
|
|
/* if not done, increase step */
|
|
c+=1<<2;
|
|
//printf("incrementing cell step\n");
|
|
}
|
|
|
|
if ( (c&_CELL_STEP_MASK)==_CELL_STEP_DONE) {
|
|
/* Go back */
|
|
//printf("done, going back a cell\n");
|
|
|
|
switch(c&_CELL_PREV_MASK) {
|
|
case _CELL_PREV_FIRST: {
|
|
//printf("at end, finished marking\n");
|
|
return;
|
|
} break;
|
|
case _CELL_PREV_Y_POS: {
|
|
y++;
|
|
ERR_FAIL_COND(y>=len_y);
|
|
} break;
|
|
case _CELL_PREV_Y_NEG: {
|
|
y--;
|
|
ERR_FAIL_COND(y<0);
|
|
} break;
|
|
case _CELL_PREV_X_POS: {
|
|
x++;
|
|
ERR_FAIL_COND(x>=len_x);
|
|
} break;
|
|
case _CELL_PREV_X_NEG: {
|
|
x--;
|
|
ERR_FAIL_COND(x<0);
|
|
} break;
|
|
case _CELL_PREV_Z_POS: {
|
|
z++;
|
|
ERR_FAIL_COND(z>=len_z);
|
|
} break;
|
|
case _CELL_PREV_Z_NEG: {
|
|
z--;
|
|
ERR_FAIL_COND(z<0);
|
|
} break;
|
|
default: {
|
|
ERR_FAIL();
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
//printf("attempting new cell!\n");
|
|
|
|
int next_x=x,next_y=y,next_z=z;
|
|
uint8_t prev=0;
|
|
|
|
switch(c&_CELL_STEP_MASK) {
|
|
|
|
case _CELL_STEP_Y_POS: {
|
|
|
|
next_y++;
|
|
prev=_CELL_PREV_Y_NEG;
|
|
} break;
|
|
case _CELL_STEP_Y_NEG: {
|
|
next_y--;
|
|
prev=_CELL_PREV_Y_POS;
|
|
} break;
|
|
case _CELL_STEP_X_POS: {
|
|
next_x++;
|
|
prev=_CELL_PREV_X_NEG;
|
|
} break;
|
|
case _CELL_STEP_X_NEG: {
|
|
next_x--;
|
|
prev=_CELL_PREV_X_POS;
|
|
} break;
|
|
case _CELL_STEP_Z_POS: {
|
|
next_z++;
|
|
prev=_CELL_PREV_Z_NEG;
|
|
} break;
|
|
case _CELL_STEP_Z_NEG: {
|
|
next_z--;
|
|
prev=_CELL_PREV_Z_POS;
|
|
} break;
|
|
default: ERR_FAIL();
|
|
|
|
}
|
|
|
|
//printf("testing if new cell will be ok...!\n");
|
|
|
|
if (next_x<0 || next_x>=len_x)
|
|
continue;
|
|
if (next_y<0 || next_y>=len_y)
|
|
continue;
|
|
if (next_z<0 || next_z>=len_z)
|
|
continue;
|
|
|
|
//printf("testing if new cell is traversable\n");
|
|
|
|
if (p_cell_status[next_x][next_y][next_z]&3)
|
|
continue;
|
|
|
|
//printf("move to it\n");
|
|
|
|
x=next_x;
|
|
y=next_y;
|
|
z=next_z;
|
|
p_cell_status[x][y][z]|=prev;
|
|
}
|
|
}
|
|
|
|
static inline void _build_faces(uint8_t*** p_cell_status,int x,int y,int z,int len_x,int len_y,int len_z,DVector<Face3>& p_faces) {
|
|
|
|
ERR_FAIL_INDEX(x,len_x);
|
|
ERR_FAIL_INDEX(y,len_y);
|
|
ERR_FAIL_INDEX(z,len_z);
|
|
|
|
if (p_cell_status[x][y][z]&_CELL_EXTERIOR)
|
|
return;
|
|
|
|
/* static const Vector3 vertices[8]={
|
|
Vector3(0,0,0),
|
|
Vector3(0,0,1),
|
|
Vector3(0,1,0),
|
|
Vector3(0,1,1),
|
|
Vector3(1,0,0),
|
|
Vector3(1,0,1),
|
|
Vector3(1,1,0),
|
|
Vector3(1,1,1),
|
|
};
|
|
*/
|
|
#define vert(m_idx) Vector3( (m_idx&4)>>2, (m_idx&2)>>1, m_idx&1 )
|
|
|
|
static const uint8_t indices[6][4]={
|
|
{7,6,4,5},
|
|
{7,3,2,6},
|
|
{7,5,1,3},
|
|
{0,2,3,1},
|
|
{0,1,5,4},
|
|
{0,4,6,2},
|
|
|
|
};
|
|
/*
|
|
|
|
{0,1,2,3},
|
|
{0,1,4,5},
|
|
{0,2,4,6},
|
|
{4,5,6,7},
|
|
{2,3,7,6},
|
|
{1,3,5,7},
|
|
|
|
{0,2,3,1},
|
|
{0,1,5,4},
|
|
{0,4,6,2},
|
|
{7,6,4,5},
|
|
{7,3,2,6},
|
|
{7,5,1,3},
|
|
*/
|
|
|
|
for (int i=0;i<6;i++) {
|
|
|
|
Vector3 face_points[4];
|
|
int disp_x=x+((i%3)==0?((i<3)?1:-1):0);
|
|
int disp_y=y+(((i-1)%3)==0?((i<3)?1:-1):0);
|
|
int disp_z=z+(((i-2)%3)==0?((i<3)?1:-1):0);
|
|
|
|
bool plot=false;
|
|
|
|
if (disp_x<0 || disp_x>=len_x)
|
|
plot=true;
|
|
if (disp_y<0 || disp_y>=len_y)
|
|
plot=true;
|
|
if (disp_z<0 || disp_z>=len_z)
|
|
plot=true;
|
|
|
|
if (!plot && (p_cell_status[disp_x][disp_y][disp_z]&_CELL_EXTERIOR))
|
|
plot=true;
|
|
|
|
if (!plot)
|
|
continue;
|
|
|
|
for (int j=0;j<4;j++)
|
|
face_points[j]=vert( indices[i][j] ) + Vector3(x,y,z);
|
|
|
|
p_faces.push_back(
|
|
Face3(
|
|
face_points[0],
|
|
face_points[1],
|
|
face_points[2]
|
|
)
|
|
);
|
|
|
|
p_faces.push_back(
|
|
Face3(
|
|
face_points[2],
|
|
face_points[3],
|
|
face_points[0]
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DVector< Face3 > Geometry::wrap_geometry( DVector< Face3 > p_array,float *p_error ) {
|
|
|
|
#define _MIN_SIZE 1.0
|
|
#define _MAX_LENGTH 20
|
|
|
|
int face_count=p_array.size();
|
|
DVector<Face3>::Read facesr=p_array.read();
|
|
const Face3 *faces = facesr.ptr();
|
|
|
|
AABB global_aabb;
|
|
|
|
for(int i=0;i<face_count;i++) {
|
|
|
|
if (i==0) {
|
|
|
|
global_aabb=faces[i].get_aabb();
|
|
} else {
|
|
|
|
global_aabb.merge_with( faces[i].get_aabb() );
|
|
}
|
|
}
|
|
|
|
global_aabb.grow_by(0.01); // avoid numerical error
|
|
|
|
// determine amount of cells in grid axis
|
|
int div_x,div_y,div_z;
|
|
|
|
if (global_aabb.size.x/_MIN_SIZE<_MAX_LENGTH)
|
|
div_x=(int)(global_aabb.size.x/_MIN_SIZE)+1;
|
|
else
|
|
div_x=_MAX_LENGTH;
|
|
|
|
if (global_aabb.size.y/_MIN_SIZE<_MAX_LENGTH)
|
|
div_y=(int)(global_aabb.size.y/_MIN_SIZE)+1;
|
|
else
|
|
div_y=_MAX_LENGTH;
|
|
|
|
if (global_aabb.size.z/_MIN_SIZE<_MAX_LENGTH)
|
|
div_z=(int)(global_aabb.size.z/_MIN_SIZE)+1;
|
|
else
|
|
div_z=_MAX_LENGTH;
|
|
|
|
Vector3 voxelsize=global_aabb.size;
|
|
voxelsize.x/=div_x;
|
|
voxelsize.y/=div_y;
|
|
voxelsize.z/=div_z;
|
|
|
|
|
|
// create and initialize cells to zero
|
|
print_line("Wrapper: Initializing Cells");
|
|
|
|
uint8_t ***cell_status=memnew_arr(uint8_t**,div_x);
|
|
for(int i=0;i<div_x;i++) {
|
|
|
|
cell_status[i]=memnew_arr(uint8_t*,div_y);
|
|
|
|
for(int j=0;j<div_y;j++) {
|
|
|
|
cell_status[i][j]=memnew_arr(uint8_t,div_z);
|
|
|
|
for(int k=0;k<div_z;k++) {
|
|
|
|
cell_status[i][j][k]=0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// plot faces into cells
|
|
print_line("Wrapper (1/6): Plotting Faces");
|
|
|
|
for (int i=0;i<face_count;i++) {
|
|
|
|
Face3 f=faces[i];
|
|
for (int j=0;j<3;j++) {
|
|
|
|
f.vertex[j]-=global_aabb.pos;
|
|
}
|
|
_plot_face(cell_status,0,0,0,div_x,div_y,div_z,voxelsize,f);
|
|
}
|
|
|
|
|
|
// determine which cells connect to the outside by traversing the outside and recursively flood-fill marking
|
|
|
|
print_line("Wrapper (2/6) Flood Filling");
|
|
|
|
for (int i=0;i<div_x;i++) {
|
|
|
|
for (int j=0;j<div_y;j++) {
|
|
|
|
_mark_outside(cell_status,i,j,0,div_x,div_y,div_z);
|
|
_mark_outside(cell_status,i,j,div_z-1,div_x,div_y,div_z);
|
|
}
|
|
}
|
|
|
|
for (int i=0;i<div_z;i++) {
|
|
|
|
for (int j=0;j<div_y;j++) {
|
|
|
|
_mark_outside(cell_status,0,j,i,div_x,div_y,div_z);
|
|
_mark_outside(cell_status,div_x-1,j,i,div_x,div_y,div_z);
|
|
}
|
|
}
|
|
|
|
for (int i=0;i<div_x;i++) {
|
|
|
|
for (int j=0;j<div_z;j++) {
|
|
|
|
_mark_outside(cell_status,i,0,j,div_x,div_y,div_z);
|
|
_mark_outside(cell_status,i,div_y-1,j,div_x,div_y,div_z);
|
|
}
|
|
}
|
|
|
|
// build faces for the inside-outside cell divisors
|
|
|
|
print_line("Wrapper (3/6): Building Faces");
|
|
|
|
DVector<Face3> wrapped_faces;
|
|
|
|
for (int i=0;i<div_x;i++) {
|
|
|
|
for (int j=0;j<div_y;j++) {
|
|
|
|
for (int k=0;k<div_z;k++) {
|
|
|
|
_build_faces(cell_status,i,j,k,div_x,div_y,div_z,wrapped_faces);
|
|
}
|
|
}
|
|
}
|
|
|
|
print_line("Wrapper (4/6): Transforming Back Vertices");
|
|
|
|
// transform face vertices to global coords
|
|
|
|
int wrapped_faces_count=wrapped_faces.size();
|
|
DVector<Face3>::Write wrapped_facesw=wrapped_faces.write();
|
|
Face3* wrapped_faces_ptr=wrapped_facesw.ptr();
|
|
|
|
for(int i=0;i<wrapped_faces_count;i++) {
|
|
|
|
for(int j=0;j<3;j++) {
|
|
|
|
Vector3& v = wrapped_faces_ptr[i].vertex[j];
|
|
v=v*voxelsize;
|
|
v+=global_aabb.pos;
|
|
}
|
|
}
|
|
|
|
// clean up grid
|
|
print_line("Wrapper (5/6): Grid Cleanup");
|
|
|
|
for(int i=0;i<div_x;i++) {
|
|
|
|
for(int j=0;j<div_y;j++) {
|
|
|
|
memdelete_arr( cell_status[i][j] );
|
|
}
|
|
|
|
memdelete_arr( cell_status[i] );
|
|
}
|
|
|
|
memdelete_arr(cell_status);
|
|
if (p_error)
|
|
*p_error=voxelsize.length();
|
|
|
|
print_line("Wrapper (6/6): Finished.");
|
|
return wrapped_faces;
|
|
}
|
|
|
|
Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) {
|
|
|
|
MeshData mesh;
|
|
|
|
|
|
#define SUBPLANE_SIZE 1024.0
|
|
|
|
float subplane_size = 1024.0; // should compute this from the actual plane
|
|
for (int i=0;i<p_planes.size();i++) {
|
|
|
|
Plane p =p_planes[i];
|
|
|
|
Vector3 ref=Vector3(0.0,1.0,0.0);
|
|
|
|
if (ABS(p.normal.dot(ref))>0.95)
|
|
ref=Vector3(0.0,0.0,1.0); // change axis
|
|
|
|
Vector3 right = p.normal.cross(ref).normalized();
|
|
Vector3 up = p.normal.cross( right ).normalized();
|
|
|
|
Vector< Vector3 > vertices;
|
|
|
|
Vector3 center = p.get_any_point();
|
|
// make a quad clockwise
|
|
vertices.push_back( center - up * subplane_size + right * subplane_size );
|
|
vertices.push_back( center - up * subplane_size - right * subplane_size );
|
|
vertices.push_back( center + up * subplane_size - right * subplane_size );
|
|
vertices.push_back( center + up * subplane_size + right * subplane_size );
|
|
|
|
for (int j=0;j<p_planes.size();j++) {
|
|
|
|
if (j==i)
|
|
continue;
|
|
|
|
|
|
Vector< Vector3 > new_vertices;
|
|
Plane clip=p_planes[j];
|
|
|
|
if (clip.normal.dot(p.normal)>0.95)
|
|
continue;
|
|
|
|
if (vertices.size()<3)
|
|
break;
|
|
|
|
for(int k=0;k<vertices.size();k++) {
|
|
|
|
int k_n=(k+1)%vertices.size();
|
|
|
|
Vector3 edge0_A=vertices[k];
|
|
Vector3 edge1_A=vertices[k_n];
|
|
|
|
real_t dist0 = clip.distance_to(edge0_A);
|
|
real_t dist1 = clip.distance_to(edge1_A);
|
|
|
|
|
|
if ( dist0 <= 0 ) { // behind plane
|
|
|
|
new_vertices.push_back(vertices[k]);
|
|
}
|
|
|
|
|
|
// check for different sides and non coplanar
|
|
if ( (dist0*dist1) < 0) {
|
|
|
|
// calculate intersection
|
|
Vector3 rel = edge1_A - edge0_A;
|
|
|
|
real_t den=clip.normal.dot( rel );
|
|
if (Math::abs(den)<CMP_EPSILON)
|
|
continue; // point too short
|
|
|
|
real_t dist=-(clip.normal.dot( edge0_A )-clip.d)/den;
|
|
Vector3 inters = edge0_A+rel*dist;
|
|
new_vertices.push_back(inters);
|
|
}
|
|
}
|
|
|
|
vertices=new_vertices;
|
|
}
|
|
|
|
if (vertices.size()<3)
|
|
continue;
|
|
|
|
|
|
//result is a clockwise face
|
|
|
|
MeshData::Face face;
|
|
|
|
// add face indices
|
|
for (int j=0;j<vertices.size();j++) {
|
|
|
|
|
|
int idx=-1;
|
|
for (int k=0;k<mesh.vertices.size();k++) {
|
|
|
|
if (mesh.vertices[k].distance_to(vertices[j])<0.001) {
|
|
|
|
idx=k;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (idx==-1) {
|
|
|
|
idx=mesh.vertices.size();
|
|
mesh.vertices.push_back(vertices[j]);
|
|
}
|
|
|
|
face.indices.push_back(idx);
|
|
}
|
|
face.plane=p;
|
|
mesh.faces.push_back(face);
|
|
|
|
//add edge
|
|
|
|
for(int j=0;j<face.indices.size();j++) {
|
|
|
|
int a=face.indices[j];
|
|
int b=face.indices[(j+1)%face.indices.size()];
|
|
|
|
bool found=false;
|
|
for(int k=0;k<mesh.edges.size();k++) {
|
|
|
|
if (mesh.edges[k].a==a && mesh.edges[k].b==b) {
|
|
found=true;
|
|
break;
|
|
}
|
|
if (mesh.edges[k].b==a && mesh.edges[k].a==b) {
|
|
found=true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
continue;
|
|
MeshData::Edge edge;
|
|
edge.a=a;
|
|
edge.b=b;
|
|
mesh.edges.push_back(edge);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
return mesh;
|
|
}
|
|
|
|
|
|
DVector<Plane> Geometry::build_box_planes(const Vector3& p_extents) {
|
|
|
|
DVector<Plane> planes;
|
|
|
|
planes.push_back( Plane( Vector3(1,0,0), p_extents.x ) );
|
|
planes.push_back( Plane( Vector3(-1,0,0), p_extents.x ) );
|
|
planes.push_back( Plane( Vector3(0,1,0), p_extents.y ) );
|
|
planes.push_back( Plane( Vector3(0,-1,0), p_extents.y ) );
|
|
planes.push_back( Plane( Vector3(0,0,1), p_extents.z ) );
|
|
planes.push_back( Plane( Vector3(0,0,-1), p_extents.z ) );
|
|
|
|
return planes;
|
|
}
|
|
|
|
DVector<Plane> Geometry::build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis) {
|
|
|
|
DVector<Plane> planes;
|
|
|
|
for (int i=0;i<p_sides;i++) {
|
|
|
|
Vector3 normal;
|
|
normal[(p_axis+1)%3]=Math::cos(i*(2.0*Math_PI)/p_sides);
|
|
normal[(p_axis+2)%3]=Math::sin(i*(2.0*Math_PI)/p_sides);
|
|
|
|
planes.push_back( Plane( normal, p_radius ) );
|
|
}
|
|
|
|
Vector3 axis;
|
|
axis[p_axis]=1.0;
|
|
|
|
planes.push_back( Plane( axis, p_height*0.5 ) );
|
|
planes.push_back( Plane( -axis, p_height*0.5 ) );
|
|
|
|
return planes;
|
|
|
|
}
|
|
|
|
DVector<Plane> Geometry::build_sphere_planes(float p_radius, int p_lats,int p_lons, Vector3::Axis p_axis) {
|
|
|
|
|
|
DVector<Plane> planes;
|
|
|
|
Vector3 axis;
|
|
axis[p_axis]=1.0;
|
|
|
|
Vector3 axis_neg;
|
|
axis_neg[(p_axis+1)%3]=1.0;
|
|
axis_neg[(p_axis+2)%3]=1.0;
|
|
axis_neg[p_axis]=-1.0;
|
|
|
|
for (int i=0;i<p_lons;i++) {
|
|
|
|
Vector3 normal;
|
|
normal[(p_axis+1)%3]=Math::cos(i*(2.0*Math_PI)/p_lons);
|
|
normal[(p_axis+2)%3]=Math::sin(i*(2.0*Math_PI)/p_lons);
|
|
|
|
planes.push_back( Plane( normal, p_radius ) );
|
|
|
|
for (int j=1;j<=p_lats;j++) {
|
|
|
|
//todo this is stupid, fix
|
|
Vector3 angle = normal.linear_interpolate(axis,j/(float)p_lats).normalized();
|
|
Vector3 pos = angle*p_radius;
|
|
planes.push_back( Plane( pos, angle ) );
|
|
planes.push_back( Plane( pos * axis_neg, angle * axis_neg) );
|
|
|
|
}
|
|
}
|
|
|
|
return planes;
|
|
|
|
}
|
|
|
|
DVector<Plane> Geometry::build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis) {
|
|
|
|
DVector<Plane> planes;
|
|
|
|
Vector3 axis;
|
|
axis[p_axis]=1.0;
|
|
|
|
Vector3 axis_neg;
|
|
axis_neg[(p_axis+1)%3]=1.0;
|
|
axis_neg[(p_axis+2)%3]=1.0;
|
|
axis_neg[p_axis]=-1.0;
|
|
|
|
for (int i=0;i<p_sides;i++) {
|
|
|
|
Vector3 normal;
|
|
normal[(p_axis+1)%3]=Math::cos(i*(2.0*Math_PI)/p_sides);
|
|
normal[(p_axis+2)%3]=Math::sin(i*(2.0*Math_PI)/p_sides);
|
|
|
|
planes.push_back( Plane( normal, p_radius ) );
|
|
|
|
for (int j=1;j<=p_lats;j++) {
|
|
|
|
Vector3 angle = normal.linear_interpolate(axis,j/(float)p_lats).normalized();
|
|
Vector3 pos = axis*p_height*0.5 + angle*p_radius;
|
|
planes.push_back( Plane( pos, angle ) );
|
|
planes.push_back( Plane( pos * axis_neg, angle * axis_neg) );
|
|
|
|
}
|
|
}
|
|
|
|
|
|
return planes;
|
|
|
|
}
|
|
|
|
|
|
struct _AtlasWorkRect {
|
|
|
|
Size2i s;
|
|
Point2i p;
|
|
int idx;
|
|
_FORCE_INLINE_ bool operator<(const _AtlasWorkRect& p_r) const { return s.width > p_r.s.width; };
|
|
};
|
|
|
|
struct _AtlasWorkRectResult {
|
|
|
|
Vector<_AtlasWorkRect> result;
|
|
int max_w;
|
|
int max_h;
|
|
};
|
|
|
|
void Geometry::make_atlas(const Vector<Size2i>& p_rects,Vector<Point2i>& r_result, Size2i& r_size) {
|
|
|
|
//super simple, almost brute force scanline stacking fitter
|
|
//it's pretty basic for now, but it tries to make sure that the aspect ratio of the
|
|
//resulting atlas is somehow square. This is necesary because video cards have limits
|
|
//on texture size (usually 2048 or 4096), so the more square a texture, the more chances
|
|
//it will work in every hardware.
|
|
// for example, it will prioritize a 1024x1024 atlas (works everywhere) instead of a
|
|
// 256x8192 atlas (won't work anywhere).
|
|
|
|
ERR_FAIL_COND(p_rects.size()==0);
|
|
|
|
Vector<_AtlasWorkRect> wrects;
|
|
wrects.resize(p_rects.size());
|
|
for(int i=0;i<p_rects.size();i++) {
|
|
wrects[i].s=p_rects[i];
|
|
wrects[i].idx=i;
|
|
}
|
|
wrects.sort();
|
|
int widest = wrects[0].s.width;
|
|
|
|
Vector<_AtlasWorkRectResult> results;
|
|
|
|
for(int i=0;i<=12;i++) {
|
|
|
|
int w = 1<<i;
|
|
int max_h=0;
|
|
int max_w=0;
|
|
if ( w < widest )
|
|
continue;
|
|
|
|
Vector<int> hmax;
|
|
hmax.resize(w);
|
|
for(int j=0;j<w;j++)
|
|
hmax[j]=0;
|
|
|
|
//place them
|
|
int ofs=0;
|
|
int limit_h=0;
|
|
for(int j=0;j<wrects.size();j++) {
|
|
|
|
|
|
if (ofs+wrects[j].s.width > w) {
|
|
|
|
ofs=0;
|
|
}
|
|
|
|
int from_y=0;
|
|
for(int k=0;k<wrects[j].s.width;k++) {
|
|
|
|
if (hmax[ofs+k] > from_y)
|
|
from_y=hmax[ofs+k];
|
|
}
|
|
|
|
wrects[j].p.x=ofs;
|
|
wrects[j].p.y=from_y;
|
|
int end_h = from_y+wrects[j].s.height;
|
|
int end_w = ofs+wrects[j].s.width;
|
|
if (ofs==0)
|
|
limit_h=end_h;
|
|
|
|
for(int k=0;k<wrects[j].s.width;k++) {
|
|
|
|
hmax[ofs+k]=end_h;
|
|
}
|
|
|
|
if (end_h > max_h)
|
|
max_h=end_h;
|
|
|
|
if (end_w > max_w)
|
|
max_w=end_w;
|
|
|
|
if (ofs==0 || end_h>limit_h ) //while h limit not reched, keep stacking
|
|
ofs+=wrects[j].s.width;
|
|
|
|
}
|
|
|
|
_AtlasWorkRectResult result;
|
|
result.result=wrects;
|
|
result.max_h=max_h;
|
|
result.max_w=max_w;
|
|
results.push_back(result);
|
|
|
|
}
|
|
|
|
//find the result with the best aspect ratio
|
|
|
|
int best=-1;
|
|
float best_aspect=1e20;
|
|
|
|
for(int i=0;i<results.size();i++) {
|
|
|
|
float h = nearest_power_of_2(results[i].max_h);
|
|
float w = nearest_power_of_2(results[i].max_w);
|
|
float aspect = h>w ? h/w : w/h;
|
|
if (aspect < best_aspect) {
|
|
best=i;
|
|
best_aspect=aspect;
|
|
}
|
|
}
|
|
|
|
r_result.resize(p_rects.size());
|
|
|
|
for(int i=0;i<p_rects.size();i++) {
|
|
|
|
r_result[ results[best].result[i].idx ]=results[best].result[i].p;
|
|
}
|
|
|
|
r_size=Size2(results[best].max_w,results[best].max_h );
|
|
|
|
}
|
|
|
|
|
|
|
|
|