d8223ffa75
That year should bring the long-awaited OpenGL ES 3.0 compatible renderer
with state-of-the-art rendering techniques tuned to work as low as middle
end handheld devices - without compromising with the possibilities given
for higher end desktop games of course. Great times ahead for the Godot
community and the gamers that will play our games!
(cherry picked from commit c7bc44d5ad)
456 lines
10 KiB
C++
456 lines
10 KiB
C++
/*************************************************************************/
|
|
/* face3.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 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 "face3.h"
|
|
#include "geometry.h"
|
|
|
|
int Face3::split_by_plane(const Plane& p_plane,Face3 p_res[3],bool p_is_point_over[3]) const {
|
|
|
|
ERR_FAIL_COND_V(is_degenerate(),0);
|
|
|
|
|
|
Vector3 above[4];
|
|
int above_count=0;
|
|
|
|
Vector3 below[4];
|
|
int below_count=0;
|
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
if (p_plane.has_point( vertex[i], CMP_EPSILON )) { // point is in plane
|
|
|
|
ERR_FAIL_COND_V(above_count>=4,0);
|
|
above[above_count++]=vertex[i];
|
|
ERR_FAIL_COND_V(below_count>=4,0);
|
|
below[below_count++]=vertex[i];
|
|
|
|
} else {
|
|
|
|
if (p_plane.is_point_over( vertex[i])) {
|
|
//Point is over
|
|
ERR_FAIL_COND_V(above_count>=4,0);
|
|
above[above_count++]=vertex[i];
|
|
|
|
} else {
|
|
//Point is under
|
|
ERR_FAIL_COND_V(below_count>=4,0);
|
|
below[below_count++]=vertex[i];
|
|
}
|
|
|
|
/* Check for Intersection between this and the next vertex*/
|
|
|
|
Vector3 inters;
|
|
if (!p_plane.intersects_segment( vertex[i],vertex[(i+1)%3],&inters))
|
|
continue;
|
|
|
|
/* Intersection goes to both */
|
|
ERR_FAIL_COND_V(above_count>=4,0);
|
|
above[above_count++]=inters;
|
|
ERR_FAIL_COND_V(below_count>=4,0);
|
|
below[below_count++]=inters;
|
|
}
|
|
}
|
|
|
|
int polygons_created=0;
|
|
|
|
ERR_FAIL_COND_V( above_count>=4 && below_count>=4 , 0 ); //bug in the algo
|
|
|
|
if (above_count>=3) {
|
|
|
|
p_res[polygons_created]=Face3( above[0], above[1], above[2] );
|
|
p_is_point_over[polygons_created]=true;
|
|
polygons_created++;
|
|
|
|
if (above_count==4) {
|
|
|
|
p_res[polygons_created]=Face3( above[2], above[3], above[0] );
|
|
p_is_point_over[polygons_created]=true;
|
|
polygons_created++;
|
|
|
|
}
|
|
}
|
|
|
|
if (below_count>=3) {
|
|
|
|
p_res[polygons_created]=Face3( below[0], below[1], below[2] );
|
|
p_is_point_over[polygons_created]=false;
|
|
polygons_created++;
|
|
|
|
if (below_count==4) {
|
|
|
|
p_res[polygons_created]=Face3( below[2], below[3], below[0] );
|
|
p_is_point_over[polygons_created]=false;
|
|
polygons_created++;
|
|
|
|
}
|
|
}
|
|
|
|
return polygons_created;
|
|
}
|
|
|
|
|
|
|
|
bool Face3::intersects_ray(const Vector3& p_from,const Vector3& p_dir,Vector3 * p_intersection) const {
|
|
|
|
return Geometry::ray_intersects_triangle(p_from,p_dir,vertex[0],vertex[1],vertex[2],p_intersection);
|
|
|
|
}
|
|
|
|
bool Face3::intersects_segment(const Vector3& p_from,const Vector3& p_dir,Vector3 * p_intersection) const {
|
|
|
|
return Geometry::segment_intersects_triangle(p_from,p_dir,vertex[0],vertex[1],vertex[2],p_intersection);
|
|
|
|
}
|
|
|
|
|
|
bool Face3::is_degenerate() const {
|
|
|
|
Vector3 normal=vec3_cross(vertex[0]-vertex[1], vertex[0]-vertex[2]);
|
|
return (normal.length_squared() < CMP_EPSILON2);
|
|
}
|
|
|
|
|
|
Face3::Side Face3::get_side_of(const Face3& p_face,ClockDirection p_clock_dir) const {
|
|
|
|
int over=0,under=0;
|
|
|
|
Plane plane=get_plane(p_clock_dir);
|
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
const Vector3 &v=p_face.vertex[i];
|
|
|
|
if (plane.has_point(v)) //coplanar, dont bother
|
|
continue;
|
|
|
|
if (plane.is_point_over(v))
|
|
over++;
|
|
else
|
|
under++;
|
|
|
|
}
|
|
|
|
if ( over > 0 && under == 0 )
|
|
return SIDE_OVER;
|
|
else if (under > 0 && over ==0 )
|
|
return SIDE_UNDER;
|
|
else if (under ==0 && over == 0)
|
|
return SIDE_COPLANAR;
|
|
else
|
|
return SIDE_SPANNING;
|
|
|
|
}
|
|
|
|
Vector3 Face3::get_random_point_inside() const {
|
|
|
|
float a=Math::random(0,1);
|
|
float b=Math::random(0,1);
|
|
if (a>b) {
|
|
SWAP(a,b);
|
|
}
|
|
|
|
return vertex[0]*a + vertex[1]*(b-a) + vertex[2]*(1.0-b);
|
|
|
|
}
|
|
|
|
Plane Face3::get_plane(ClockDirection p_dir) const {
|
|
|
|
return Plane( vertex[0], vertex[1], vertex[2] , p_dir );
|
|
|
|
}
|
|
|
|
Vector3 Face3::get_median_point() const {
|
|
|
|
return (vertex[0] + vertex[1] + vertex[2])/3.0;
|
|
}
|
|
|
|
|
|
real_t Face3::get_area() const {
|
|
|
|
return vec3_cross(vertex[0]-vertex[1], vertex[0]-vertex[2]).length();
|
|
}
|
|
|
|
ClockDirection Face3::get_clock_dir() const {
|
|
|
|
|
|
Vector3 normal=vec3_cross(vertex[0]-vertex[1], vertex[0]-vertex[2]);
|
|
//printf("normal is %g,%g,%g x %g,%g,%g- wtfu is %g\n",tofloat(normal.x),tofloat(normal.y),tofloat(normal.z),tofloat(vertex[0].x),tofloat(vertex[0].y),tofloat(vertex[0].z),tofloat( normal.dot( vertex[0] ) ) );
|
|
return ( normal.dot( vertex[0] ) >= 0 ) ? CLOCKWISE : COUNTERCLOCKWISE;
|
|
|
|
}
|
|
|
|
|
|
bool Face3::intersects_aabb(const AABB& p_aabb) const {
|
|
|
|
/** TEST PLANE **/
|
|
if (!p_aabb.intersects_plane( get_plane() ))
|
|
return false;
|
|
|
|
/** TEST FACE AXIS */
|
|
|
|
#define TEST_AXIS(m_ax)\
|
|
{\
|
|
float aabb_min=p_aabb.pos.m_ax;\
|
|
float aabb_max=p_aabb.pos.m_ax+p_aabb.size.m_ax;\
|
|
float tri_min,tri_max;\
|
|
for (int i=0;i<3;i++) {\
|
|
if (i==0 || vertex[i].m_ax > tri_max)\
|
|
tri_max=vertex[i].m_ax;\
|
|
if (i==0 || vertex[i].m_ax < tri_min)\
|
|
tri_min=vertex[i].m_ax;\
|
|
}\
|
|
\
|
|
if (tri_max<aabb_min || aabb_max<tri_min)\
|
|
return false;\
|
|
}
|
|
|
|
TEST_AXIS(x);
|
|
TEST_AXIS(y);
|
|
TEST_AXIS(z);
|
|
|
|
/** TEST ALL EDGES **/
|
|
|
|
Vector3 edge_norms[3]={
|
|
vertex[0]-vertex[1],
|
|
vertex[1]-vertex[2],
|
|
vertex[2]-vertex[0],
|
|
};
|
|
|
|
for (int i=0;i<12;i++) {
|
|
|
|
Vector3 from,to;
|
|
p_aabb.get_edge(i,from,to);
|
|
Vector3 e1=from-to;
|
|
for (int j=0;j<3;j++) {
|
|
Vector3 e2=edge_norms[j];
|
|
|
|
Vector3 axis=vec3_cross( e1, e2 );
|
|
|
|
if (axis.length_squared()<0.0001)
|
|
continue; // coplanar
|
|
axis.normalize();
|
|
|
|
float minA,maxA,minB,maxB;
|
|
p_aabb.project_range_in_plane(Plane(axis,0),minA,maxA);
|
|
project_range(axis,Transform(),minB,maxB);
|
|
|
|
if (maxA<minB || maxB<minA)
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
|
|
}
|
|
|
|
Face3::operator String() const {
|
|
|
|
return String()+vertex[0]+", "+vertex[1]+", "+vertex[2];
|
|
}
|
|
|
|
void Face3::project_range(const Vector3& p_normal,const Transform& p_transform,float& r_min, float& r_max) const {
|
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
Vector3 v=p_transform.xform(vertex[i]);
|
|
float d=p_normal.dot(v);
|
|
|
|
if (i==0 || d > r_max)
|
|
r_max=d;
|
|
|
|
if (i==0 || d < r_min)
|
|
r_min=d;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void Face3::get_support(const Vector3& p_normal,const Transform& p_transform,Vector3 *p_vertices,int* p_count,int p_max) const {
|
|
|
|
#define _FACE_IS_VALID_SUPPORT_TRESHOLD 0.98
|
|
#define _EDGE_IS_VALID_SUPPORT_TRESHOLD 0.05
|
|
|
|
if (p_max<=0)
|
|
return;
|
|
|
|
Vector3 n=p_transform.basis.xform_inv(p_normal);
|
|
|
|
/** TEST FACE AS SUPPORT **/
|
|
if (get_plane().normal.dot(n) > _FACE_IS_VALID_SUPPORT_TRESHOLD) {
|
|
|
|
*p_count=MIN(3,p_max);
|
|
|
|
for (int i=0;i<*p_count;i++) {
|
|
|
|
p_vertices[i]=p_transform.xform(vertex[i]);
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/** FIND SUPPORT VERTEX **/
|
|
|
|
int vert_support_idx=-1;
|
|
float support_max;
|
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
float d=n.dot(vertex[i]);
|
|
|
|
if (i==0 || d > support_max) {
|
|
support_max=d;
|
|
vert_support_idx=i;
|
|
}
|
|
}
|
|
|
|
/** TEST EDGES AS SUPPORT **/
|
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
if (i!=vert_support_idx && i+1!=vert_support_idx)
|
|
continue;
|
|
|
|
// check if edge is valid as a support
|
|
float dot=(vertex[i]-vertex[(i+1)%3]).normalized().dot(n);
|
|
dot=ABS(dot);
|
|
if (dot < _EDGE_IS_VALID_SUPPORT_TRESHOLD) {
|
|
|
|
*p_count=MIN(2,p_max);
|
|
|
|
for (int j=0;j<*p_count;j++)
|
|
p_vertices[j]=p_transform.xform(vertex[(j+i)%3]);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
*p_count=1;
|
|
p_vertices[0]=p_transform.xform(vertex[vert_support_idx]);
|
|
|
|
}
|
|
|
|
|
|
Vector3 Face3::get_closest_point_to(const Vector3& p_point) const {
|
|
|
|
Vector3 edge0 = vertex[1] - vertex[0];
|
|
Vector3 edge1 = vertex[2] - vertex[0];
|
|
Vector3 v0 = vertex[0] - p_point;
|
|
|
|
float a = edge0.dot( edge0 );
|
|
float b = edge0.dot( edge1 );
|
|
float c = edge1.dot( edge1 );
|
|
float d = edge0.dot( v0 );
|
|
float e = edge1.dot( v0 );
|
|
|
|
float det = a*c - b*b;
|
|
float s = b*e - c*d;
|
|
float t = b*d - a*e;
|
|
|
|
if ( s + t < det )
|
|
{
|
|
if ( s < 0.f )
|
|
{
|
|
if ( t < 0.f )
|
|
{
|
|
if ( d < 0.f )
|
|
{
|
|
s = CLAMP( -d/a, 0.f, 1.f );
|
|
t = 0.f;
|
|
}
|
|
else
|
|
{
|
|
s = 0.f;
|
|
t = CLAMP( -e/c, 0.f, 1.f );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s = 0.f;
|
|
t = CLAMP( -e/c, 0.f, 1.f );
|
|
}
|
|
}
|
|
else if ( t < 0.f )
|
|
{
|
|
s = CLAMP( -d/a, 0.f, 1.f );
|
|
t = 0.f;
|
|
}
|
|
else
|
|
{
|
|
float invDet = 1.f / det;
|
|
s *= invDet;
|
|
t *= invDet;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( s < 0.f )
|
|
{
|
|
float tmp0 = b+d;
|
|
float tmp1 = c+e;
|
|
if ( tmp1 > tmp0 )
|
|
{
|
|
float numer = tmp1 - tmp0;
|
|
float denom = a-2*b+c;
|
|
s = CLAMP( numer/denom, 0.f, 1.f );
|
|
t = 1-s;
|
|
}
|
|
else
|
|
{
|
|
t = CLAMP( -e/c, 0.f, 1.f );
|
|
s = 0.f;
|
|
}
|
|
}
|
|
else if ( t < 0.f )
|
|
{
|
|
if ( a+d > b+e )
|
|
{
|
|
float numer = c+e-b-d;
|
|
float denom = a-2*b+c;
|
|
s = CLAMP( numer/denom, 0.f, 1.f );
|
|
t = 1-s;
|
|
}
|
|
else
|
|
{
|
|
s = CLAMP( -e/c, 0.f, 1.f );
|
|
t = 0.f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
float numer = c+e-b-d;
|
|
float denom = a-2*b+c;
|
|
s = CLAMP( numer/denom, 0.f, 1.f );
|
|
t = 1.f - s;
|
|
}
|
|
}
|
|
|
|
return vertex[0] + s * edge0 + t * edge1;
|
|
|
|
}
|