2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
|
|
|
/* curve.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 14:11:45 +02:00
|
|
|
/* https://godotengine.org */
|
2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
2017-01-01 22:01:57 +01:00
|
|
|
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
2017-04-08 00:45:00 +02:00
|
|
|
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
|
2014-02-10 02:10:30 +01: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. */
|
|
|
|
/*************************************************************************/
|
|
|
|
#include "curve.h"
|
|
|
|
#include "core_string_names.h"
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
template <class T>
|
2014-02-10 02:10:30 +01:00
|
|
|
static _FORCE_INLINE_ T _bezier_interp(real_t t, T start, T control_1, T control_2, T end) {
|
2017-03-19 00:36:26 +01:00
|
|
|
/* Formula from Wikipedia article on Bezier curves. */
|
2014-02-10 02:10:30 +01:00
|
|
|
real_t omt = (1.0 - t);
|
2017-03-19 00:36:26 +01:00
|
|
|
real_t omt2 = omt * omt;
|
|
|
|
real_t omt3 = omt2 * omt;
|
|
|
|
real_t t2 = t * t;
|
|
|
|
real_t t3 = t2 * t;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
return start * omt3 + control_1 * omt2 * t * 3.0 + control_2 * omt * t2 * 3.0 + end * t3;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
#if 0
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
int Curve2D::get_point_count() const {
|
|
|
|
|
|
|
|
return points.size();
|
|
|
|
}
|
|
|
|
void Curve2D::add_point(const Vector2& p_pos, const Vector2& p_in, const Vector2& p_out) {
|
|
|
|
|
|
|
|
Point n;
|
|
|
|
n.pos=p_pos;
|
|
|
|
n.in=p_in;
|
|
|
|
n.out=p_out;
|
|
|
|
points.push_back(n);
|
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
void Curve2D::set_point_pos(int p_index, const Vector2& p_pos) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_index,points.size());
|
|
|
|
|
|
|
|
points[p_index].pos=p_pos;
|
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
|
|
|
|
}
|
|
|
|
Vector2 Curve2D::get_point_pos(int p_index) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_index,points.size(),Vector2());
|
|
|
|
return points[p_index].pos;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Curve2D::set_point_in(int p_index, const Vector2& p_in) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_index,points.size());
|
|
|
|
|
|
|
|
points[p_index].in=p_in;
|
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
|
|
|
|
}
|
|
|
|
Vector2 Curve2D::get_point_in(int p_index) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_index,points.size(),Vector2());
|
|
|
|
return points[p_index].in;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curve2D::set_point_out(int p_index, const Vector2& p_out) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_index,points.size());
|
|
|
|
|
|
|
|
points[p_index].out=p_out;
|
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector2 Curve2D::get_point_out(int p_index) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_index,points.size(),Vector2());
|
|
|
|
return points[p_index].out;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Curve2D::remove_point(int p_index) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_index,points.size());
|
|
|
|
points.remove(p_index);
|
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector2 Curve2D::interpolate(int p_index, float p_offset) const {
|
|
|
|
|
|
|
|
int pc = points.size();
|
|
|
|
ERR_FAIL_COND_V(pc==0,Vector2());
|
|
|
|
|
|
|
|
if (p_index >= pc-1)
|
|
|
|
return points[pc-1].pos;
|
|
|
|
else if (p_index<0)
|
|
|
|
return points[0].pos;
|
|
|
|
|
|
|
|
Vector2 p0 = points[p_index].pos;
|
|
|
|
Vector2 p1 = p0+points[p_index].out;
|
|
|
|
Vector2 p3 = points[p_index+1].pos;
|
|
|
|
Vector2 p2 = p3+points[p_index+1].in;
|
|
|
|
|
|
|
|
return _bezier_interp(p_offset,p0,p1,p2,p3);
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector2 Curve2D::interpolatef(real_t p_findex) const {
|
|
|
|
|
|
|
|
|
2015-01-06 15:31:41 +01:00
|
|
|
if (p_findex<0)
|
2014-02-10 02:10:30 +01:00
|
|
|
p_findex=0;
|
|
|
|
else if (p_findex>=points.size())
|
|
|
|
p_findex=points.size();
|
|
|
|
|
|
|
|
return interpolate((int)p_findex,Math::fmod(p_findex,1.0));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
DVector<Point2> Curve2D::bake(int p_subdivs) const {
|
|
|
|
|
|
|
|
int pc = points.size();
|
|
|
|
|
|
|
|
DVector<Point2> ret;
|
|
|
|
if (pc<2)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret.resize((pc-1)*p_subdivs+1);
|
|
|
|
|
|
|
|
DVector<Point2>::Write w = ret.write();
|
|
|
|
const Point *r = points.ptr();
|
|
|
|
|
|
|
|
for(int i=0;i<pc;i++) {
|
|
|
|
|
|
|
|
int ofs = pc*p_subdivs;
|
|
|
|
|
|
|
|
int limit=(i==pc-1)?p_subdivs+1:p_subdivs;
|
|
|
|
|
|
|
|
for(int j=0;j<limit;j++) {
|
|
|
|
|
|
|
|
Vector2 p0 = r[i].pos;
|
|
|
|
Vector2 p1 = p0+r[i].out;
|
|
|
|
Vector2 p3 = r[i].pos;
|
|
|
|
Vector2 p2 = p3+r[i].in;
|
|
|
|
real_t t = j/(real_t)p_subdivs;
|
|
|
|
|
|
|
|
w[ofs+j]=_bezier_interp(t,p0,p1,p2,p3);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
w = DVector<Point2>::Write();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curve2D::advance(real_t p_distance,int &r_index, real_t &r_pos) const {
|
|
|
|
|
|
|
|
int pc = points.size();
|
|
|
|
ERR_FAIL_COND(pc<2);
|
|
|
|
if (r_index<0 || r_index>=(pc-1))
|
|
|
|
return;
|
|
|
|
|
|
|
|
Vector2 pos = interpolate(r_index,r_pos);
|
|
|
|
|
|
|
|
float sign=p_distance<0 ? -1 : 1;
|
|
|
|
p_distance=Math::abs(p_distance);
|
|
|
|
|
|
|
|
real_t base = r_index+r_pos;
|
|
|
|
real_t top = 0.1; //a tenth is in theory representative
|
|
|
|
int iterations=32;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for(int i=0;i<iterations;i++) {
|
|
|
|
|
|
|
|
|
|
|
|
real_t o=base+top*sign;
|
|
|
|
if (sign>0 && o >=pc) {
|
|
|
|
top=pc-base;
|
|
|
|
break;
|
|
|
|
} else if (sign<0 && o <0) {
|
|
|
|
top=-base;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector2 new_d = interpolatef(o);
|
|
|
|
|
|
|
|
if (new_d.distance_to(pos) > p_distance)
|
|
|
|
break;
|
|
|
|
top*=2.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
real_t bottom = 0.0;
|
|
|
|
iterations=8;
|
|
|
|
real_t final_offset;
|
|
|
|
|
|
|
|
|
|
|
|
for(int i=0;i<iterations;i++) {
|
|
|
|
|
|
|
|
real_t middle = (bottom+top)*0.5;
|
|
|
|
real_t o=base+middle*sign;
|
|
|
|
Vector2 new_d = interpolatef(o);
|
|
|
|
|
|
|
|
if (new_d.distance_to(pos) > p_distance) {
|
|
|
|
bottom=middle;
|
|
|
|
} else {
|
|
|
|
top=middle;
|
|
|
|
}
|
|
|
|
final_offset=o;
|
|
|
|
}
|
|
|
|
|
|
|
|
r_index=(int)final_offset;
|
|
|
|
r_pos=Math::fmod(final_offset,1.0);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curve2D::get_approx_position_from_offset(real_t p_offset,int &r_index, real_t &r_pos,int p_subdivs) const {
|
|
|
|
|
|
|
|
ERR_FAIL_COND(points.size()<2);
|
|
|
|
|
|
|
|
real_t accum=0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for(int i=0;i<points.size();i++) {
|
|
|
|
|
|
|
|
Vector2 prev_p=interpolate(i,0);
|
|
|
|
|
|
|
|
|
|
|
|
for(int j=1;j<=p_subdivs;j++) {
|
|
|
|
|
|
|
|
real_t frac = j/(real_t)p_subdivs;
|
|
|
|
Vector2 p = interpolate(i,frac);
|
|
|
|
real_t d = p.distance_to(prev_p);
|
|
|
|
|
|
|
|
accum+=d;
|
|
|
|
if (accum>p_offset) {
|
|
|
|
|
|
|
|
|
|
|
|
r_index=j-1;
|
|
|
|
if (d>0) {
|
|
|
|
real_t mf = (p_offset-(accum-d)) / d;
|
|
|
|
r_pos=frac-(1.0-mf);
|
|
|
|
} else {
|
|
|
|
r_pos=frac;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
prev_p=p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
r_index=points.size()-1;
|
|
|
|
r_pos=1.0;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curve2D::set_points_in(const Vector2Array& p_points) {
|
|
|
|
|
|
|
|
points.resize(p_points.size());
|
|
|
|
for (int i=0; i<p_points.size(); i++) {
|
|
|
|
|
|
|
|
Point p = points[i];
|
|
|
|
p.in = p_points[i];
|
|
|
|
points[i] = p;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
void Curve2D::set_points_out(const Vector2Array& p_points) {
|
|
|
|
|
|
|
|
points.resize(p_points.size());
|
|
|
|
for (int i=0; i<p_points.size(); i++) {
|
|
|
|
|
|
|
|
Point p = points[i];
|
|
|
|
p.out = p_points[i];
|
|
|
|
points[i] = p;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
void Curve2D::set_points_pos(const Vector2Array& p_points) {
|
|
|
|
|
|
|
|
points.resize(p_points.size());
|
|
|
|
for (int i=0; i<p_points.size(); i++) {
|
|
|
|
|
|
|
|
Point p = points[i];
|
|
|
|
p.pos = p_points[i];
|
|
|
|
points[i] = p;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
Vector2Array Curve2D::get_points_in() const {
|
|
|
|
Vector2Array ret;
|
|
|
|
ret.resize(points.size());
|
|
|
|
for (int i=0; i<points.size(); i++) {
|
|
|
|
ret.set(i, points[i].in);
|
|
|
|
};
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
Vector2Array Curve2D::get_points_out() const {
|
|
|
|
Vector2Array ret;
|
|
|
|
ret.resize(points.size());
|
|
|
|
for (int i=0; i<points.size(); i++) {
|
|
|
|
ret.set(i, points[i].out);
|
|
|
|
};
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
Vector2Array Curve2D::get_points_pos() const {
|
|
|
|
Vector2Array ret;
|
|
|
|
ret.resize(points.size());
|
|
|
|
for (int i=0; i<points.size(); i++) {
|
|
|
|
ret.set(i, points[i].pos);
|
|
|
|
};
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
void Curve2D::_bind_methods() {
|
|
|
|
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_count"),&Curve2D::get_point_count);
|
|
|
|
ObjectTypeDB::bind_method(_MD("add_point","pos","in","out"),&Curve2D::add_point,DEFVAL(Vector2()),DEFVAL(Vector2()));
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_pos","idx","pos"),&Curve2D::set_point_pos);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_pos","idx"),&Curve2D::get_point_pos);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_in","idx","pos"),&Curve2D::set_point_in);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_in","idx"),&Curve2D::get_point_in);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_out","idx","pos"),&Curve2D::set_point_out);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_out","idx"),&Curve2D::get_point_out);
|
|
|
|
ObjectTypeDB::bind_method(_MD("remove_point","idx"),&Curve2D::remove_point);
|
|
|
|
ObjectTypeDB::bind_method(_MD("interpolate","idx","t"),&Curve2D::interpolate);
|
|
|
|
ObjectTypeDB::bind_method(_MD("bake","subdivs"),&Curve2D::bake,DEFVAL(10));
|
|
|
|
|
|
|
|
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_points_in"),&Curve2D::set_points_in);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_points_out"),&Curve2D::set_points_out);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_points_pos"),&Curve2D::set_points_pos);
|
|
|
|
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_points_in"),&Curve2D::get_points_in);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_points_out"),&Curve2D::get_points_out);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_points_pos"),&Curve2D::get_points_pos);
|
|
|
|
|
|
|
|
ADD_PROPERTY( PropertyInfo( Variant::VECTOR2_ARRAY, "points_in"), _SCS("set_points_in"),_SCS("get_points_in"));
|
|
|
|
ADD_PROPERTY( PropertyInfo( Variant::VECTOR2_ARRAY, "points_out"), _SCS("set_points_out"),_SCS("get_points_out"));
|
|
|
|
ADD_PROPERTY( PropertyInfo( Variant::VECTOR2_ARRAY, "points_pos"), _SCS("set_points_pos"),_SCS("get_points_pos"));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Curve2D::Curve2D()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
#endif
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
int Curve2D::get_point_count() const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return points.size();
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve2D::add_point(const Vector2 &p_pos, const Vector2 &p_in, const Vector2 &p_out, int p_atpos) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Point n;
|
2017-03-19 00:36:26 +01:00
|
|
|
n.pos = p_pos;
|
|
|
|
n.in = p_in;
|
|
|
|
n.out = p_out;
|
|
|
|
if (p_atpos >= 0 && p_atpos < points.size())
|
|
|
|
points.insert(p_atpos, n);
|
2014-02-10 02:10:30 +01:00
|
|
|
else
|
|
|
|
points.push_back(n);
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_cache_dirty = true;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve2D::set_point_pos(int p_index, const Vector2 &p_pos) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[p_index].pos = p_pos;
|
|
|
|
baked_cache_dirty = true;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2 Curve2D::get_point_pos(int p_index) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_index, points.size(), Vector2());
|
2014-02-10 02:10:30 +01:00
|
|
|
return points[p_index].pos;
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve2D::set_point_in(int p_index, const Vector2 &p_in) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[p_index].in = p_in;
|
|
|
|
baked_cache_dirty = true;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2 Curve2D::get_point_in(int p_index) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_index, points.size(), Vector2());
|
2014-02-10 02:10:30 +01:00
|
|
|
return points[p_index].in;
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve2D::set_point_out(int p_index, const Vector2 &p_out) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[p_index].out = p_out;
|
|
|
|
baked_cache_dirty = true;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2 Curve2D::get_point_out(int p_index) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_index, points.size(), Vector2());
|
2014-02-10 02:10:30 +01:00
|
|
|
return points[p_index].out;
|
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
void Curve2D::remove_point(int p_index) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-02-10 02:10:30 +01:00
|
|
|
points.remove(p_index);
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_cache_dirty = true;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
|
2016-12-03 21:35:59 +01:00
|
|
|
void Curve2D::clear_points() {
|
|
|
|
if (!points.empty()) {
|
|
|
|
points.clear();
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_cache_dirty = true;
|
2016-12-03 21:35:59 +01:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2 Curve2D::interpolate(int p_index, float p_offset) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
int pc = points.size();
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_COND_V(pc == 0, Vector2());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_index >= pc - 1)
|
|
|
|
return points[pc - 1].pos;
|
|
|
|
else if (p_index < 0)
|
2014-02-10 02:10:30 +01:00
|
|
|
return points[0].pos;
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2 p0 = points[p_index].pos;
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2 p1 = p0 + points[p_index].out;
|
|
|
|
Vector2 p3 = points[p_index + 1].pos;
|
|
|
|
Vector2 p2 = p3 + points[p_index + 1].in;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
return _bezier_interp(p_offset, p0, p1, p2, p3);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2 Curve2D::interpolatef(real_t p_findex) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_findex < 0)
|
|
|
|
p_findex = 0;
|
|
|
|
else if (p_findex >= points.size())
|
|
|
|
p_findex = points.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
return interpolate((int)p_findex, Math::fmod(p_findex, 1.0));
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve2D::_bake_segment2d(Map<float, Vector2> &r_bake, float p_begin, float p_end, const Vector2 &p_a, const Vector2 &p_out, const Vector2 &p_b, const Vector2 &p_in, int p_depth, int p_max_depth, float p_tol) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
float mp = p_begin + (p_end - p_begin) * 0.5;
|
|
|
|
Vector2 beg = _bezier_interp(p_begin, p_a, p_a + p_out, p_b + p_in, p_b);
|
|
|
|
Vector2 mid = _bezier_interp(mp, p_a, p_a + p_out, p_b + p_in, p_b);
|
|
|
|
Vector2 end = _bezier_interp(p_end, p_a, p_a + p_out, p_b + p_in, p_b);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2 na = (mid - beg).normalized();
|
|
|
|
Vector2 nb = (end - mid).normalized();
|
2014-07-06 16:49:27 +02:00
|
|
|
float dp = na.dot(nb);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (dp < Math::cos(Math::deg2rad(p_tol))) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
r_bake[mp] = mid;
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_depth < p_max_depth) {
|
|
|
|
_bake_segment2d(r_bake, p_begin, mp, p_a, p_out, p_b, p_in, p_depth + 1, p_max_depth, p_tol);
|
|
|
|
_bake_segment2d(r_bake, mp, p_end, p_a, p_out, p_b, p_in, p_depth + 1, p_max_depth, p_tol);
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
void Curve2D::_bake() const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
if (!baked_cache_dirty)
|
|
|
|
return;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_max_ofs = 0;
|
|
|
|
baked_cache_dirty = false;
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (points.size() == 0) {
|
2014-07-06 16:49:27 +02:00
|
|
|
baked_point_cache.resize(0);
|
|
|
|
return;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (points.size() == 1) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
baked_point_cache.resize(1);
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_point_cache.set(0, points[0].pos);
|
2014-07-06 16:49:27 +02:00
|
|
|
return;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2 pos = points[0].pos;
|
2014-07-06 16:49:27 +02:00
|
|
|
List<Vector2> pointlist;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2016-04-15 05:13:17 +02:00
|
|
|
pointlist.push_back(pos); //start always from origin
|
2016-05-21 15:29:25 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int i = 0; i < points.size() - 1; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2015-01-16 07:39:11 +01:00
|
|
|
float step = 0.1; // at least 10 substeps ought to be enough?
|
2014-07-06 16:49:27 +02:00
|
|
|
float p = 0;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
while (p < 1.0) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
float np = p + step;
|
|
|
|
if (np > 1.0)
|
|
|
|
np = 1.0;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2 npp = _bezier_interp(np, points[i].pos, points[i].pos + points[i].out, points[i + 1].pos + points[i + 1].in, points[i + 1].pos);
|
2014-07-06 16:49:27 +02:00
|
|
|
float d = pos.distance_to(npp);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (d > bake_interval) {
|
2014-07-06 16:49:27 +02:00
|
|
|
// OK! between P and NP there _has_ to be Something, let's go searching!
|
|
|
|
|
|
|
|
int iterations = 10; //lots of detail!
|
|
|
|
|
|
|
|
float low = p;
|
|
|
|
float hi = np;
|
2017-03-19 00:36:26 +01:00
|
|
|
float mid = low + (hi - low) * 0.5;
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int j = 0; j < iterations; j++) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
npp = _bezier_interp(mid, points[i].pos, points[i].pos + points[i].out, points[i + 1].pos + points[i + 1].in, points[i + 1].pos);
|
2014-07-06 16:49:27 +02:00
|
|
|
d = pos.distance_to(npp);
|
|
|
|
|
|
|
|
if (bake_interval < d)
|
2017-03-19 00:36:26 +01:00
|
|
|
hi = mid;
|
2014-07-06 16:49:27 +02:00
|
|
|
else
|
2017-03-19 00:36:26 +01:00
|
|
|
low = mid;
|
|
|
|
mid = low + (hi - low) * 0.5;
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
pos = npp;
|
|
|
|
p = mid;
|
2014-07-06 16:49:27 +02:00
|
|
|
pointlist.push_back(pos);
|
|
|
|
} else {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
p = np;
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2 lastpos = points[points.size() - 1].pos;
|
2014-07-06 16:49:27 +02:00
|
|
|
|
|
|
|
float rem = pos.distance_to(lastpos);
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_max_ofs = (pointlist.size() - 1) * bake_interval + rem;
|
2014-07-06 16:49:27 +02:00
|
|
|
pointlist.push_back(lastpos);
|
|
|
|
|
|
|
|
baked_point_cache.resize(pointlist.size());
|
|
|
|
Vector2Array::Write w = baked_point_cache.write();
|
2017-03-19 00:36:26 +01:00
|
|
|
int idx = 0;
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (List<Vector2>::Element *E = pointlist.front(); E; E = E->next()) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
w[idx] = E->get();
|
2014-07-06 16:49:27 +02:00
|
|
|
idx++;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
float Curve2D::get_baked_length() const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
if (baked_cache_dirty)
|
|
|
|
_bake();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
return baked_max_ofs;
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2 Curve2D::interpolate_baked(float p_offset, bool p_cubic) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
if (baked_cache_dirty)
|
|
|
|
_bake();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
//validate//
|
|
|
|
int pc = baked_point_cache.size();
|
2017-03-19 00:36:26 +01:00
|
|
|
if (pc == 0) {
|
2014-07-06 16:49:27 +02:00
|
|
|
ERR_EXPLAIN("No points in Curve2D");
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_COND_V(pc == 0, Vector2());
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (pc == 1)
|
2014-07-06 16:49:27 +02:00
|
|
|
return baked_point_cache.get(0);
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
int bpc = baked_point_cache.size();
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2Array::Read r = baked_point_cache.read();
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_offset < 0)
|
2014-07-06 16:49:27 +02:00
|
|
|
return r[0];
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_offset >= baked_max_ofs)
|
|
|
|
return r[bpc - 1];
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
int idx = Math::floor((double)p_offset / (double)bake_interval);
|
|
|
|
float frac = Math::fmod(p_offset, bake_interval);
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (idx >= bpc - 1) {
|
|
|
|
return r[bpc - 1];
|
|
|
|
} else if (idx == bpc - 2) {
|
|
|
|
frac /= Math::fmod(baked_max_ofs, bake_interval);
|
2014-07-06 16:49:27 +02:00
|
|
|
} else {
|
2017-03-19 00:36:26 +01:00
|
|
|
frac /= bake_interval;
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (p_cubic) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2 pre = idx > 0 ? r[idx - 1] : r[idx];
|
|
|
|
Vector2 post = (idx < (bpc - 2)) ? r[idx + 2] : r[idx + 1];
|
|
|
|
return r[idx].cubic_interpolate(r[idx + 1], pre, post, frac);
|
2014-07-06 16:49:27 +02:00
|
|
|
} else {
|
2017-03-19 00:36:26 +01:00
|
|
|
return r[idx].linear_interpolate(r[idx + 1], frac);
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2Array Curve2D::get_baked_points() const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
if (baked_cache_dirty)
|
|
|
|
_bake();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
return baked_point_cache;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve2D::set_bake_interval(float p_tolerance) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
bake_interval = p_tolerance;
|
|
|
|
baked_cache_dirty = true;
|
2014-07-06 16:49:27 +02:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
float Curve2D::get_bake_interval() const {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
|
|
|
return bake_interval;
|
|
|
|
}
|
|
|
|
|
|
|
|
Dictionary Curve2D::_get_data() const {
|
|
|
|
|
|
|
|
Dictionary dc;
|
|
|
|
|
|
|
|
Vector2Array d;
|
2017-03-19 00:36:26 +01:00
|
|
|
d.resize(points.size() * 3);
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2Array::Write w = d.write();
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int i = 0; i < points.size(); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
w[i * 3 + 0] = points[i].in;
|
|
|
|
w[i * 3 + 1] = points[i].out;
|
|
|
|
w[i * 3 + 2] = points[i].pos;
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
w = Vector2Array::Write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
dc["points"] = d;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
return dc;
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve2D::_set_data(const Dictionary &p_data) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
ERR_FAIL_COND(!p_data.has("points"));
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2Array rp = p_data["points"];
|
2014-07-06 16:49:27 +02:00
|
|
|
int pc = rp.size();
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_COND(pc % 3 != 0);
|
|
|
|
points.resize(pc / 3);
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector2Array::Read r = rp.read();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int i = 0; i < points.size(); i++) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[i].in = r[i * 3 + 0];
|
|
|
|
points[i].out = r[i * 3 + 1];
|
|
|
|
points[i].pos = r[i * 3 + 2];
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_cache_dirty = true;
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2Array Curve2D::tesselate(int p_max_stages, float p_tolerance) const {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
|
|
|
Vector2Array tess;
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (points.size() == 0) {
|
2014-07-06 16:49:27 +02:00
|
|
|
return tess;
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector<Map<float, Vector2> > midpoints;
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
midpoints.resize(points.size() - 1);
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
int pc = 1;
|
|
|
|
for (int i = 0; i < points.size() - 1; i++) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
_bake_segment2d(midpoints[i], 0, 1, points[i].pos, points[i].out, points[i + 1].pos, points[i + 1].in, 0, p_max_stages, p_tolerance);
|
2014-07-06 16:49:27 +02:00
|
|
|
pc++;
|
2017-03-19 00:36:26 +01:00
|
|
|
pc += midpoints[i].size();
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
tess.resize(pc);
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector2Array::Write bpw = tess.write();
|
|
|
|
bpw[0] = points[0].pos;
|
|
|
|
int pidx = 0;
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int i = 0; i < points.size() - 1; i++) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (Map<float, Vector2>::Element *E = midpoints[i].front(); E; E = E->next()) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
|
|
|
pidx++;
|
|
|
|
bpw[pidx] = E->get();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2014-07-06 16:49:27 +02:00
|
|
|
|
|
|
|
pidx++;
|
2017-03-19 00:36:26 +01:00
|
|
|
bpw[pidx] = points[i + 1].pos;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
bpw = Vector2Array::Write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
return tess;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
void Curve2D::_bind_methods() {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_count"), &Curve2D::get_point_count);
|
|
|
|
ObjectTypeDB::bind_method(_MD("add_point", "pos", "in", "out", "atpos"), &Curve2D::add_point, DEFVAL(Vector2()), DEFVAL(Vector2()), DEFVAL(-1));
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_pos", "idx", "pos"), &Curve2D::set_point_pos);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_pos", "idx"), &Curve2D::get_point_pos);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_in", "idx", "pos"), &Curve2D::set_point_in);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_in", "idx"), &Curve2D::get_point_in);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_out", "idx", "pos"), &Curve2D::set_point_out);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_out", "idx"), &Curve2D::get_point_out);
|
|
|
|
ObjectTypeDB::bind_method(_MD("remove_point", "idx"), &Curve2D::remove_point);
|
|
|
|
ObjectTypeDB::bind_method(_MD("clear_points"), &Curve2D::clear_points);
|
|
|
|
ObjectTypeDB::bind_method(_MD("interpolate", "idx", "t"), &Curve2D::interpolate);
|
|
|
|
ObjectTypeDB::bind_method(_MD("interpolatef", "fofs"), &Curve2D::interpolatef);
|
2014-07-06 16:49:27 +02:00
|
|
|
//ObjectTypeDB::bind_method(_MD("bake","subdivs"),&Curve2D::bake,DEFVAL(10));
|
2017-03-19 00:36:26 +01:00
|
|
|
ObjectTypeDB::bind_method(_MD("set_bake_interval", "distance"), &Curve2D::set_bake_interval);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_bake_interval"), &Curve2D::get_bake_interval);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ObjectTypeDB::bind_method(_MD("get_baked_length"), &Curve2D::get_baked_length);
|
|
|
|
ObjectTypeDB::bind_method(_MD("interpolate_baked", "offset", "cubic"), &Curve2D::interpolate_baked, DEFVAL(false));
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_baked_points"), &Curve2D::get_baked_points);
|
|
|
|
ObjectTypeDB::bind_method(_MD("tesselate", "max_stages", "tolerance_degrees"), &Curve2D::tesselate, DEFVAL(5), DEFVAL(4));
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ObjectTypeDB::bind_method(_MD("_get_data"), &Curve2D::_get_data);
|
|
|
|
ObjectTypeDB::bind_method(_MD("_set_data"), &Curve2D::_set_data);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "bake_interval", PROPERTY_HINT_RANGE, "0.01,512,0.01"), _SCS("set_bake_interval"), _SCS("get_bake_interval"));
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), _SCS("_set_data"), _SCS("_get_data"));
|
2014-07-06 16:49:27 +02:00
|
|
|
/*ADD_PROPERTY( PropertyInfo( Variant::VECTOR3_ARRAY, "points_out"), _SCS("set_points_out"),_SCS("get_points_out"));
|
|
|
|
ADD_PROPERTY( PropertyInfo( Variant::VECTOR3_ARRAY, "points_pos"), _SCS("set_points_pos"),_SCS("get_points_pos"));
|
|
|
|
*/
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Curve2D::Curve2D() {
|
|
|
|
baked_cache_dirty = false;
|
|
|
|
baked_max_ofs = 0;
|
|
|
|
/* add_point(Vector2(-1,0,0));
|
2014-07-06 16:49:27 +02:00
|
|
|
add_point(Vector2(0,2,0));
|
|
|
|
add_point(Vector2(0,3,5));*/
|
2017-03-19 00:36:26 +01:00
|
|
|
bake_interval = 5;
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
/***********************************************************************************/
|
|
|
|
/***********************************************************************************/
|
|
|
|
/***********************************************************************************/
|
|
|
|
/***********************************************************************************/
|
|
|
|
/***********************************************************************************/
|
|
|
|
/***********************************************************************************/
|
|
|
|
|
|
|
|
int Curve3D::get_point_count() const {
|
|
|
|
|
|
|
|
return points.size();
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve3D::add_point(const Vector3 &p_pos, const Vector3 &p_in, const Vector3 &p_out, int p_atpos) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
|
|
|
Point n;
|
2017-03-19 00:36:26 +01:00
|
|
|
n.pos = p_pos;
|
|
|
|
n.in = p_in;
|
|
|
|
n.out = p_out;
|
|
|
|
if (p_atpos >= 0 && p_atpos < points.size())
|
|
|
|
points.insert(p_atpos, n);
|
2014-07-06 16:49:27 +02:00
|
|
|
else
|
|
|
|
points.push_back(n);
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_cache_dirty = true;
|
2014-07-06 16:49:27 +02:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve3D::set_point_pos(int p_index, const Vector3 &p_pos) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[p_index].pos = p_pos;
|
|
|
|
baked_cache_dirty = true;
|
2014-07-06 16:49:27 +02:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
Vector3 Curve3D::get_point_pos(int p_index) const {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_index, points.size(), Vector3());
|
2014-07-06 16:49:27 +02:00
|
|
|
return points[p_index].pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curve3D::set_point_tilt(int p_index, float p_tilt) {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[p_index].tilt = p_tilt;
|
|
|
|
baked_cache_dirty = true;
|
2014-07-06 16:49:27 +02:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
float Curve3D::get_point_tilt(int p_index) const {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_index, points.size(), 0);
|
2014-07-06 16:49:27 +02:00
|
|
|
return points[p_index].tilt;
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve3D::set_point_in(int p_index, const Vector3 &p_in) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[p_index].in = p_in;
|
|
|
|
baked_cache_dirty = true;
|
2014-07-06 16:49:27 +02:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
Vector3 Curve3D::get_point_in(int p_index) const {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_index, points.size(), Vector3());
|
2014-07-06 16:49:27 +02:00
|
|
|
return points[p_index].in;
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve3D::set_point_out(int p_index, const Vector3 &p_out) {
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[p_index].out = p_out;
|
|
|
|
baked_cache_dirty = true;
|
2014-07-06 16:49:27 +02:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector3 Curve3D::get_point_out(int p_index) const {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_index, points.size(), Vector3());
|
2014-07-06 16:49:27 +02:00
|
|
|
return points[p_index].out;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curve3D::remove_point(int p_index) {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_INDEX(p_index, points.size());
|
2014-07-06 16:49:27 +02:00
|
|
|
points.remove(p_index);
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_cache_dirty = true;
|
2014-07-06 16:49:27 +02:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
|
2016-12-03 21:35:59 +01:00
|
|
|
void Curve3D::clear_points() {
|
|
|
|
|
|
|
|
if (!points.empty()) {
|
|
|
|
points.clear();
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_cache_dirty = true;
|
2016-12-03 21:35:59 +01:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-06 16:49:27 +02:00
|
|
|
Vector3 Curve3D::interpolate(int p_index, float p_offset) const {
|
|
|
|
|
|
|
|
int pc = points.size();
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_COND_V(pc == 0, Vector3());
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_index >= pc - 1)
|
|
|
|
return points[pc - 1].pos;
|
|
|
|
else if (p_index < 0)
|
2014-07-06 16:49:27 +02:00
|
|
|
return points[0].pos;
|
|
|
|
|
|
|
|
Vector3 p0 = points[p_index].pos;
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3 p1 = p0 + points[p_index].out;
|
|
|
|
Vector3 p3 = points[p_index + 1].pos;
|
|
|
|
Vector3 p2 = p3 + points[p_index + 1].in;
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
return _bezier_interp(p_offset, p0, p1, p2, p3);
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Vector3 Curve3D::interpolatef(real_t p_findex) const {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_findex < 0)
|
|
|
|
p_findex = 0;
|
|
|
|
else if (p_findex >= points.size())
|
|
|
|
p_findex = points.size();
|
2014-07-06 16:49:27 +02:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
return interpolate((int)p_findex, Math::fmod(p_findex, 1.0));
|
2014-07-06 16:49:27 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve3D::_bake_segment3d(Map<float, Vector3> &r_bake, float p_begin, float p_end, const Vector3 &p_a, const Vector3 &p_out, const Vector3 &p_b, const Vector3 &p_in, int p_depth, int p_max_depth, float p_tol) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
float mp = p_begin + (p_end - p_begin) * 0.5;
|
|
|
|
Vector3 beg = _bezier_interp(p_begin, p_a, p_a + p_out, p_b + p_in, p_b);
|
|
|
|
Vector3 mid = _bezier_interp(mp, p_a, p_a + p_out, p_b + p_in, p_b);
|
|
|
|
Vector3 end = _bezier_interp(p_end, p_a, p_a + p_out, p_b + p_in, p_b);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3 na = (mid - beg).normalized();
|
|
|
|
Vector3 nb = (end - mid).normalized();
|
2014-02-10 02:10:30 +01:00
|
|
|
float dp = na.dot(nb);
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (dp < Math::cos(Math::deg2rad(p_tol))) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
r_bake[mp] = mid;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_depth < p_max_depth) {
|
|
|
|
_bake_segment3d(r_bake, p_begin, mp, p_a, p_out, p_b, p_in, p_depth + 1, p_max_depth, p_tol);
|
|
|
|
_bake_segment3d(r_bake, mp, p_end, p_a, p_out, p_b, p_in, p_depth + 1, p_max_depth, p_tol);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curve3D::_bake() const {
|
|
|
|
|
|
|
|
if (!baked_cache_dirty)
|
|
|
|
return;
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_max_ofs = 0;
|
|
|
|
baked_cache_dirty = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (points.size() == 0) {
|
2014-02-10 02:10:30 +01:00
|
|
|
baked_point_cache.resize(0);
|
|
|
|
baked_tilt_cache.resize(0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (points.size() == 1) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
baked_point_cache.resize(1);
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_point_cache.set(0, points[0].pos);
|
2014-02-10 02:10:30 +01:00
|
|
|
baked_tilt_cache.resize(1);
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_tilt_cache.set(0, points[0].tilt);
|
2014-02-10 02:10:30 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3 pos = points[0].pos;
|
2014-02-10 02:10:30 +01:00
|
|
|
List<Plane> pointlist;
|
2017-03-19 00:36:26 +01:00
|
|
|
pointlist.push_back(Plane(pos, points[0].tilt));
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int i = 0; i < points.size() - 1; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2015-01-16 07:39:11 +01:00
|
|
|
float step = 0.1; // at least 10 substeps ought to be enough?
|
2014-02-10 02:10:30 +01:00
|
|
|
float p = 0;
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
while (p < 1.0) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
float np = p + step;
|
|
|
|
if (np > 1.0)
|
|
|
|
np = 1.0;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3 npp = _bezier_interp(np, points[i].pos, points[i].pos + points[i].out, points[i + 1].pos + points[i + 1].in, points[i + 1].pos);
|
2014-02-10 02:10:30 +01:00
|
|
|
float d = pos.distance_to(npp);
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (d > bake_interval) {
|
2014-02-10 02:10:30 +01:00
|
|
|
// OK! between P and NP there _has_ to be Something, let's go searching!
|
|
|
|
|
|
|
|
int iterations = 10; //lots of detail!
|
|
|
|
|
|
|
|
float low = p;
|
|
|
|
float hi = np;
|
2017-03-19 00:36:26 +01:00
|
|
|
float mid = low + (hi - low) * 0.5;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int j = 0; j < iterations; j++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
npp = _bezier_interp(mid, points[i].pos, points[i].pos + points[i].out, points[i + 1].pos + points[i + 1].in, points[i + 1].pos);
|
2014-02-10 02:10:30 +01:00
|
|
|
d = pos.distance_to(npp);
|
|
|
|
|
|
|
|
if (bake_interval < d)
|
2017-03-19 00:36:26 +01:00
|
|
|
hi = mid;
|
2014-02-10 02:10:30 +01:00
|
|
|
else
|
2017-03-19 00:36:26 +01:00
|
|
|
low = mid;
|
|
|
|
mid = low + (hi - low) * 0.5;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
pos = npp;
|
|
|
|
p = mid;
|
2014-02-10 02:10:30 +01:00
|
|
|
Plane post;
|
2017-03-19 00:36:26 +01:00
|
|
|
post.normal = pos;
|
|
|
|
post.d = Math::lerp(points[i].tilt, points[i + 1].tilt, mid);
|
2014-02-10 02:10:30 +01:00
|
|
|
pointlist.push_back(post);
|
|
|
|
} else {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
p = np;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3 lastpos = points[points.size() - 1].pos;
|
|
|
|
float lastilt = points[points.size() - 1].tilt;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
float rem = pos.distance_to(lastpos);
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_max_ofs = (pointlist.size() - 1) * bake_interval + rem;
|
|
|
|
pointlist.push_back(Plane(lastpos, lastilt));
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
baked_point_cache.resize(pointlist.size());
|
|
|
|
Vector3Array::Write w = baked_point_cache.write();
|
2017-03-19 00:36:26 +01:00
|
|
|
int idx = 0;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
baked_tilt_cache.resize(pointlist.size());
|
|
|
|
RealArray::Write wt = baked_tilt_cache.write();
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (List<Plane>::Element *E = pointlist.front(); E; E = E->next()) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
w[idx] = E->get().normal;
|
|
|
|
wt[idx] = E->get().d;
|
2014-02-10 02:10:30 +01:00
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
float Curve3D::get_baked_length() const {
|
|
|
|
|
|
|
|
if (baked_cache_dirty)
|
|
|
|
_bake();
|
|
|
|
|
|
|
|
return baked_max_ofs;
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3 Curve3D::interpolate_baked(float p_offset, bool p_cubic) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (baked_cache_dirty)
|
|
|
|
_bake();
|
|
|
|
|
|
|
|
//validate//
|
|
|
|
int pc = baked_point_cache.size();
|
2017-03-19 00:36:26 +01:00
|
|
|
if (pc == 0) {
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_EXPLAIN("No points in Curve3D");
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_COND_V(pc == 0, Vector3());
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (pc == 1)
|
2014-02-10 02:10:30 +01:00
|
|
|
return baked_point_cache.get(0);
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
int bpc = baked_point_cache.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
Vector3Array::Read r = baked_point_cache.read();
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_offset < 0)
|
2014-02-10 02:10:30 +01:00
|
|
|
return r[0];
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_offset >= baked_max_ofs)
|
|
|
|
return r[bpc - 1];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
int idx = Math::floor((double)p_offset / (double)bake_interval);
|
|
|
|
float frac = Math::fmod(p_offset, bake_interval);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (idx >= bpc - 1) {
|
|
|
|
return r[bpc - 1];
|
|
|
|
} else if (idx == bpc - 2) {
|
|
|
|
frac /= Math::fmod(baked_max_ofs, bake_interval);
|
2014-02-10 02:10:30 +01:00
|
|
|
} else {
|
2017-03-19 00:36:26 +01:00
|
|
|
frac /= bake_interval;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (p_cubic) {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3 pre = idx > 0 ? r[idx - 1] : r[idx];
|
|
|
|
Vector3 post = (idx < (bpc - 2)) ? r[idx + 2] : r[idx + 1];
|
|
|
|
return r[idx].cubic_interpolate(r[idx + 1], pre, post, frac);
|
2014-02-10 02:10:30 +01:00
|
|
|
} else {
|
2017-03-19 00:36:26 +01:00
|
|
|
return r[idx].linear_interpolate(r[idx + 1], frac);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
float Curve3D::interpolate_baked_tilt(float p_offset) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (baked_cache_dirty)
|
|
|
|
_bake();
|
|
|
|
|
|
|
|
//validate//
|
|
|
|
int pc = baked_tilt_cache.size();
|
2017-03-19 00:36:26 +01:00
|
|
|
if (pc == 0) {
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_EXPLAIN("No tilts in Curve3D");
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_COND_V(pc == 0, 0);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (pc == 1)
|
2014-02-10 02:10:30 +01:00
|
|
|
return baked_tilt_cache.get(0);
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
int bpc = baked_tilt_cache.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
RealArray::Read r = baked_tilt_cache.read();
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_offset < 0)
|
2014-02-10 02:10:30 +01:00
|
|
|
return r[0];
|
2017-03-19 00:36:26 +01:00
|
|
|
if (p_offset >= baked_max_ofs)
|
|
|
|
return r[bpc - 1];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
int idx = Math::floor((double)p_offset / (double)bake_interval);
|
|
|
|
float frac = Math::fmod(p_offset, bake_interval);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (idx >= bpc - 1) {
|
|
|
|
return r[bpc - 1];
|
|
|
|
} else if (idx == bpc - 2) {
|
|
|
|
frac /= Math::fmod(baked_max_ofs, bake_interval);
|
2014-02-10 02:10:30 +01:00
|
|
|
} else {
|
2017-03-19 00:36:26 +01:00
|
|
|
frac /= bake_interval;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
return Math::lerp(r[idx], r[idx + 1], frac);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Vector3Array Curve3D::get_baked_points() const {
|
|
|
|
|
|
|
|
if (baked_cache_dirty)
|
|
|
|
_bake();
|
|
|
|
|
|
|
|
return baked_point_cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
RealArray Curve3D::get_baked_tilts() const {
|
|
|
|
|
|
|
|
if (baked_cache_dirty)
|
|
|
|
_bake();
|
|
|
|
|
|
|
|
return baked_tilt_cache;
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve3D::set_bake_interval(float p_tolerance) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
bake_interval = p_tolerance;
|
|
|
|
baked_cache_dirty = true;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_signal(CoreStringNames::get_singleton()->changed);
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
float Curve3D::get_bake_interval() const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return bake_interval;
|
|
|
|
}
|
|
|
|
|
|
|
|
Dictionary Curve3D::_get_data() const {
|
|
|
|
|
|
|
|
Dictionary dc;
|
|
|
|
|
|
|
|
Vector3Array d;
|
2017-03-19 00:36:26 +01:00
|
|
|
d.resize(points.size() * 3);
|
2014-02-10 02:10:30 +01:00
|
|
|
Vector3Array::Write w = d.write();
|
|
|
|
RealArray t;
|
|
|
|
t.resize(points.size());
|
|
|
|
RealArray::Write wt = t.write();
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int i = 0; i < points.size(); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
w[i * 3 + 0] = points[i].in;
|
|
|
|
w[i * 3 + 1] = points[i].out;
|
|
|
|
w[i * 3 + 2] = points[i].pos;
|
|
|
|
wt[i] = points[i].tilt;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
w = Vector3Array::Write();
|
|
|
|
wt = RealArray::Write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
dc["points"] = d;
|
|
|
|
dc["tilts"] = t;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return dc;
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
void Curve3D::_set_data(const Dictionary &p_data) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_COND(!p_data.has("points"));
|
|
|
|
ERR_FAIL_COND(!p_data.has("tilts"));
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3Array rp = p_data["points"];
|
2014-02-10 02:10:30 +01:00
|
|
|
int pc = rp.size();
|
2017-03-19 00:36:26 +01:00
|
|
|
ERR_FAIL_COND(pc % 3 != 0);
|
|
|
|
points.resize(pc / 3);
|
2014-02-10 02:10:30 +01:00
|
|
|
Vector3Array::Read r = rp.read();
|
2017-03-19 00:36:26 +01:00
|
|
|
RealArray rtl = p_data["tilts"];
|
|
|
|
RealArray::Read rt = rtl.read();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int i = 0; i < points.size(); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
points[i].in = r[i * 3 + 0];
|
|
|
|
points[i].out = r[i * 3 + 1];
|
|
|
|
points[i].pos = r[i * 3 + 2];
|
|
|
|
points[i].tilt = rt[i];
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
baked_cache_dirty = true;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3Array Curve3D::tesselate(int p_max_stages, float p_tolerance) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Vector3Array tess;
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
if (points.size() == 0) {
|
2014-02-10 02:10:30 +01:00
|
|
|
return tess;
|
|
|
|
}
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector<Map<float, Vector3> > midpoints;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
midpoints.resize(points.size() - 1);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
int pc = 1;
|
|
|
|
for (int i = 0; i < points.size() - 1; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
_bake_segment3d(midpoints[i], 0, 1, points[i].pos, points[i].out, points[i + 1].pos, points[i + 1].in, 0, p_max_stages, p_tolerance);
|
2014-02-10 02:10:30 +01:00
|
|
|
pc++;
|
2017-03-19 00:36:26 +01:00
|
|
|
pc += midpoints[i].size();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
tess.resize(pc);
|
2017-03-19 00:36:26 +01:00
|
|
|
Vector3Array::Write bpw = tess.write();
|
|
|
|
bpw[0] = points[0].pos;
|
|
|
|
int pidx = 0;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (int i = 0; i < points.size() - 1; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
for (Map<float, Vector3>::Element *E = midpoints[i].front(); E; E = E->next()) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
pidx++;
|
|
|
|
bpw[pidx] = E->get();
|
|
|
|
}
|
|
|
|
|
|
|
|
pidx++;
|
2017-03-19 00:36:26 +01:00
|
|
|
bpw[pidx] = points[i + 1].pos;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
bpw = Vector3Array::Write();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return tess;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curve3D::_bind_methods() {
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_count"), &Curve3D::get_point_count);
|
|
|
|
ObjectTypeDB::bind_method(_MD("add_point", "pos", "in", "out", "atpos"), &Curve3D::add_point, DEFVAL(Vector3()), DEFVAL(Vector3()), DEFVAL(-1));
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_pos", "idx", "pos"), &Curve3D::set_point_pos);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_pos", "idx"), &Curve3D::get_point_pos);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_tilt", "idx", "tilt"), &Curve3D::set_point_tilt);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_tilt", "idx"), &Curve3D::get_point_tilt);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_in", "idx", "pos"), &Curve3D::set_point_in);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_in", "idx"), &Curve3D::get_point_in);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_point_out", "idx", "pos"), &Curve3D::set_point_out);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_point_out", "idx"), &Curve3D::get_point_out);
|
|
|
|
ObjectTypeDB::bind_method(_MD("remove_point", "idx"), &Curve3D::remove_point);
|
|
|
|
ObjectTypeDB::bind_method(_MD("clear_points"), &Curve3D::clear_points);
|
|
|
|
ObjectTypeDB::bind_method(_MD("interpolate", "idx", "t"), &Curve3D::interpolate);
|
|
|
|
ObjectTypeDB::bind_method(_MD("interpolatef", "fofs"), &Curve3D::interpolatef);
|
2014-02-10 02:10:30 +01:00
|
|
|
//ObjectTypeDB::bind_method(_MD("bake","subdivs"),&Curve3D::bake,DEFVAL(10));
|
2017-03-19 00:36:26 +01:00
|
|
|
ObjectTypeDB::bind_method(_MD("set_bake_interval", "distance"), &Curve3D::set_bake_interval);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_bake_interval"), &Curve3D::get_bake_interval);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ObjectTypeDB::bind_method(_MD("get_baked_length"), &Curve3D::get_baked_length);
|
|
|
|
ObjectTypeDB::bind_method(_MD("interpolate_baked", "offset", "cubic"), &Curve3D::interpolate_baked, DEFVAL(false));
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_baked_points"), &Curve3D::get_baked_points);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_baked_tilts"), &Curve3D::get_baked_tilts);
|
|
|
|
ObjectTypeDB::bind_method(_MD("tesselate", "max_stages", "tolerance_degrees"), &Curve3D::tesselate, DEFVAL(5), DEFVAL(4));
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ObjectTypeDB::bind_method(_MD("_get_data"), &Curve3D::_get_data);
|
|
|
|
ObjectTypeDB::bind_method(_MD("_set_data"), &Curve3D::_set_data);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "bake_interval", PROPERTY_HINT_RANGE, "0.01,512,0.01"), _SCS("set_bake_interval"), _SCS("get_bake_interval"));
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), _SCS("_set_data"), _SCS("_get_data"));
|
2014-02-10 02:10:30 +01:00
|
|
|
/*ADD_PROPERTY( PropertyInfo( Variant::VECTOR3_ARRAY, "points_out"), _SCS("set_points_out"),_SCS("get_points_out"));
|
|
|
|
ADD_PROPERTY( PropertyInfo( Variant::VECTOR3_ARRAY, "points_pos"), _SCS("set_points_pos"),_SCS("get_points_pos"));
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2017-03-19 00:36:26 +01:00
|
|
|
Curve3D::Curve3D() {
|
|
|
|
baked_cache_dirty = false;
|
|
|
|
baked_max_ofs = 0;
|
|
|
|
/* add_point(Vector3(-1,0,0));
|
2014-02-10 02:10:30 +01:00
|
|
|
add_point(Vector3(0,2,0));
|
|
|
|
add_point(Vector3(0,3,5));*/
|
2017-03-19 00:36:26 +01:00
|
|
|
bake_interval = 0.2;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|