summaryrefslogtreecommitdiff
path: root/scene/resources/curve.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'scene/resources/curve.cpp')
-rw-r--r--scene/resources/curve.cpp587
1 files changed, 414 insertions, 173 deletions
diff --git a/scene/resources/curve.cpp b/scene/resources/curve.cpp
index f39bbf4c4e..ae2c07ff56 100644
--- a/scene/resources/curve.cpp
+++ b/scene/resources/curve.cpp
@@ -44,6 +44,7 @@ static _FORCE_INLINE_ T _bezier_interp(real_t t, T start, T control_1, T control
+ end * t3;
}
+#if 0
int Curve2D::get_point_count() const {
@@ -379,21 +380,16 @@ Curve2D::Curve2D()
{
}
+#endif
-/***********************************************************************************/
-/***********************************************************************************/
-/***********************************************************************************/
-/***********************************************************************************/
-/***********************************************************************************/
-/***********************************************************************************/
-int Curve3D::get_point_count() const {
+int Curve2D::get_point_count() const {
return points.size();
}
-void Curve3D::add_point(const Vector3& p_pos, const Vector3& p_in, const Vector3& p_out,int p_atpos) {
+void Curve2D::add_point(const Vector2& p_pos, const Vector2& p_in, const Vector2& p_out,int p_atpos) {
Point n;
n.pos=p_pos;
@@ -408,7 +404,8 @@ void Curve3D::add_point(const Vector3& p_pos, const Vector3& p_in, const Vector3
baked_cache_dirty=true;
emit_signal(CoreStringNames::get_singleton()->changed);
}
-void Curve3D::set_point_pos(int p_index, const Vector3& p_pos) {
+
+void Curve2D::set_point_pos(int p_index, const Vector2& p_pos) {
ERR_FAIL_INDEX(p_index,points.size());
@@ -417,31 +414,15 @@ void Curve3D::set_point_pos(int p_index, const Vector3& p_pos) {
emit_signal(CoreStringNames::get_singleton()->changed);
}
-Vector3 Curve3D::get_point_pos(int p_index) const {
+Vector2 Curve2D::get_point_pos(int p_index) const {
- ERR_FAIL_INDEX_V(p_index,points.size(),Vector3());
+ ERR_FAIL_INDEX_V(p_index,points.size(),Vector2());
return points[p_index].pos;
}
-void Curve3D::set_point_tilt(int p_index, float p_tilt) {
-
- ERR_FAIL_INDEX(p_index,points.size());
-
- points[p_index].tilt=p_tilt;
- baked_cache_dirty=true;
- emit_signal(CoreStringNames::get_singleton()->changed);
-
-}
-float Curve3D::get_point_tilt(int p_index) const {
-
- ERR_FAIL_INDEX_V(p_index,points.size(),0);
- return points[p_index].tilt;
-}
-
-
-void Curve3D::set_point_in(int p_index, const Vector3& p_in) {
+void Curve2D::set_point_in(int p_index, const Vector2& p_in) {
ERR_FAIL_INDEX(p_index,points.size());
@@ -450,14 +431,14 @@ void Curve3D::set_point_in(int p_index, const Vector3& p_in) {
emit_signal(CoreStringNames::get_singleton()->changed);
}
-Vector3 Curve3D::get_point_in(int p_index) const {
+Vector2 Curve2D::get_point_in(int p_index) const {
- ERR_FAIL_INDEX_V(p_index,points.size(),Vector3());
+ ERR_FAIL_INDEX_V(p_index,points.size(),Vector2());
return points[p_index].in;
}
-void Curve3D::set_point_out(int p_index, const Vector3& p_out) {
+void Curve2D::set_point_out(int p_index, const Vector2& p_out) {
ERR_FAIL_INDEX(p_index,points.size());
@@ -467,15 +448,15 @@ void Curve3D::set_point_out(int p_index, const Vector3& p_out) {
}
-Vector3 Curve3D::get_point_out(int p_index) const {
+Vector2 Curve2D::get_point_out(int p_index) const {
- ERR_FAIL_INDEX_V(p_index,points.size(),Vector3());
+ ERR_FAIL_INDEX_V(p_index,points.size(),Vector2());
return points[p_index].out;
}
-void Curve3D::remove_point(int p_index) {
+void Curve2D::remove_point(int p_index) {
ERR_FAIL_INDEX(p_index,points.size());
points.remove(p_index);
@@ -483,25 +464,25 @@ void Curve3D::remove_point(int p_index) {
emit_signal(CoreStringNames::get_singleton()->changed);
}
-Vector3 Curve3D::interpolate(int p_index, float p_offset) const {
+Vector2 Curve2D::interpolate(int p_index, float p_offset) const {
int pc = points.size();
- ERR_FAIL_COND_V(pc==0,Vector3());
+ 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;
- Vector3 p0 = points[p_index].pos;
- Vector3 p1 = p0+points[p_index].out;
- Vector3 p3 = points[p_index+1].pos;
- Vector3 p2 = p3+points[p_index+1].in;
+ 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);
}
-Vector3 Curve3D::interpolatef(real_t p_findex) const {
+Vector2 Curve2D::interpolatef(real_t p_findex) const {
if (p_findex>0)
@@ -513,216 +494,476 @@ Vector3 Curve3D::interpolatef(real_t p_findex) const {
}
-#if 0
-DVector<Point3> Curve3D::bake(int p_subdivs) const {
- int pc = points.size();
+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 {
- DVector<Point3> ret;
- if (pc<3)
- return ret;
+ 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);
- ret.resize((pc-1)*p_subdivs+1);
+ Vector2 na = (mid-beg).normalized();
+ Vector2 nb = (end-mid).normalized();
+ float dp = na.dot(nb);
- DVector<Point3>::Write w = ret.write();
- const Point *r = points.ptr();
+ if (dp<Math::cos(Math::deg2rad(p_tol))) {
- for(int i=0;i<pc;i++) {
+ r_bake[mp]=mid;
+ }
- int ofs = pc*p_subdivs;
+ 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);
+ }
+}
- int limit=(i==pc-1)?p_subdivs+1:p_subdivs;
- for(int j=0;j<limit;j++) {
- Vector3 p0 = r[i].pos;
- Vector3 p1 = p0+r[i].out;
- Vector3 p3 = r[i].pos;
- Vector3 p3 = p3+r[i].in;
- real_t t = j/(real_t)p_subdivs;
+void Curve2D::_bake() const {
- w[ofs+j]=_bezier_interp(t,p0,p1,p3,p3);
+ if (!baked_cache_dirty)
+ return;
- }
+ baked_max_ofs=0;
+ baked_cache_dirty=false;
+
+ if (points.size()==0) {
+ baked_point_cache.resize(0);
+ return;
}
- w = DVector<Point3>::Write();
+ if (points.size()==1) {
- return ret;
-}
+ baked_point_cache.resize(1);
+ baked_point_cache.set(0,points[0].pos);
+ return;
+ }
+ Vector2 pos=points[0].pos;
+ int point=0;
+ float ofs=0;
+ List<Vector2> pointlist;
-void Curve3D::advance(real_t p_distance,int &r_index, real_t &r_pos) const {
- int pc = points.size();
- ERR_FAIL_COND(pc<3);
- if (r_index<0 || r_index>=(pc-1))
- return;
+ for(int i=0;i<points.size()-1;i++) {
- Vector3 pos = interpolate(r_index,r_pos);
+ float slen=points[i].pos.distance_to(points[i+1].pos);
+ float divs = slen / bake_interval;
+ if (divs>1)
+ divs=1;
- float sign=p_distance<0 ? -1 : 1;
- p_distance=Math::abs(p_distance);
+ float step = divs*0.1; // 10 substeps ought to be enough?
+ float p = 0;
- real_t base = r_index+r_pos;
- real_t top = 0.1; //a tenth is in theory representative
- int iterations=33;
+ while(p<1.0) {
+ float np=p+step;
+ if (np>1.0)
+ np=1.0;
- for(int i=0;i<iterations;i++) {
+ 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);
+ float d = pos.distance_to(npp);
+ if (d>bake_interval) {
+ // 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;
+ float mid = low+(hi-low)*0.5;
+
+ for(int j=0;j<iterations;j++) {
+
+
+ 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);
+ d = pos.distance_to(npp);
+
+ if (bake_interval < d)
+ hi=mid;
+ else
+ low=mid;
+ mid = low+(hi-low)*0.5;
+
+ }
+
+ pos=npp;
+ p=mid;
+ pointlist.push_back(pos);
+ } else {
+
+ p=np;
+ }
- real_t o=base+top*sign;
- if (sign>0 && o >=pc) {
- top=pc-base;
- break;
- } else if (sign<0 && o <0) {
- top=-base;
- break;
}
+ }
- Vector3 new_d = interpolatef(o);
+ Vector2 lastpos = points[points.size()-1].pos;
- if (new_d.distance_to(pos) > p_distance)
- break;
- top*=3.0;
+
+ float rem = pos.distance_to(lastpos);
+ baked_max_ofs=(pointlist.size()-1)*bake_interval+rem;
+ pointlist.push_back(lastpos);
+
+ baked_point_cache.resize(pointlist.size());
+ Vector2Array::Write w = baked_point_cache.write();
+ int idx=0;
+
+
+ for(List<Vector2>::Element *E=pointlist.front();E;E=E->next()) {
+
+ w[idx]=E->get();
+ idx++;
}
+}
- real_t bottom = 0.0;
- iterations=8;
- real_t final_offset;
+float Curve2D::get_baked_length() const {
+ if (baked_cache_dirty)
+ _bake();
- for(int i=0;i<iterations;i++) {
+ return baked_max_ofs;
+}
+Vector2 Curve2D::interpolate_baked(float p_offset,bool p_cubic) const{
- real_t middle = (bottom+top)*0.5;
- real_t o=base+middle*sign;
- Vector3 new_d = interpolatef(o);
+ if (baked_cache_dirty)
+ _bake();
- if (new_d.distance_to(pos) > p_distance) {
- bottom=middle;
- } else {
- top=middle;
- }
- final_offset=o;
+ //validate//
+ int pc = baked_point_cache.size();
+ if (pc==0) {
+ ERR_EXPLAIN("No points in Curve2D");
+ ERR_FAIL_COND_V(pc==0,Vector2());
}
- r_index=(int)final_offset;
- r_pos=Math::fmod(final_offset,1.0);
+ if (pc==1)
+ return baked_point_cache.get(0);
+
+ int bpc=baked_point_cache.size();
+ Vector2Array::Read r = baked_point_cache.read();
+
+ if (p_offset<0)
+ return r[0];
+ if (p_offset>=baked_max_ofs)
+ return r[bpc-1];
+
+ int idx = Math::floor(p_offset/bake_interval);
+ float frac = Math::fmod(p_offset,bake_interval);
+
+ if (idx>=bpc-1) {
+ return r[bpc-1];
+ } else if (idx==bpc-2) {
+ frac/=Math::fmod(baked_max_ofs,bake_interval);
+ } else {
+ frac/=bake_interval;
+ }
+
+ if (p_cubic) {
+
+ 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);
+ } else {
+ return r[idx].linear_interpolate(r[idx+1],frac);
+ }
+}
+
+Vector2Array Curve2D::get_baked_points() const {
+
+ if (baked_cache_dirty)
+ _bake();
+
+ return baked_point_cache;
}
-void Curve3D::get_approx_position_from_offset(real_t p_offset,int &r_index, real_t &r_pos,int p_subdivs) const {
+void Curve2D::set_bake_interval(float p_tolerance){
+
+ bake_interval=p_tolerance;
+ baked_cache_dirty=true;
+ emit_signal(CoreStringNames::get_singleton()->changed);
+
+}
- ERR_FAIL_COND(points.size()<3);
+float Curve2D::get_bake_interval() const{
- real_t accum=0;
+ return bake_interval;
+}
+Dictionary Curve2D::_get_data() const {
+
+ Dictionary dc;
+
+ Vector2Array d;
+ d.resize(points.size()*3);
+ Vector2Array::Write w = d.write();
for(int i=0;i<points.size();i++) {
- Vector3 prev_p=interpolate(i,0);
+ w[i*3+0]=points[i].in;
+ w[i*3+1]=points[i].out;
+ w[i*3+2]=points[i].pos;
+ }
- for(int j=1;j<=p_subdivs;j++) {
+ w=Vector2Array::Write();
- real_t frac = j/(real_t)p_subdivs;
- Vector3 p = interpolate(i,frac);
- real_t d = p.distance_to(prev_p);
+ dc["points"]=d;
- accum+=d;
- if (accum>p_offset) {
+ return dc;
+}
+void Curve2D::_set_data(const Dictionary& p_data){
- 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;
- }
+ ERR_FAIL_COND(!p_data.has("points"));
- return;
- }
+ Vector2Array rp=p_data["points"];
+ int pc = rp.size();
+ ERR_FAIL_COND(pc%3!=0);
+ points.resize(pc/3);
+ Vector2Array::Read r = rp.read();
- prev_p=p;
+ for(int i=0;i<points.size();i++) {
+
+ points[i].in=r[i*3+0];
+ points[i].out=r[i*3+1];
+ points[i].pos=r[i*3+2];
+ }
+
+ baked_cache_dirty=true;
+
+}
+
+
+Vector2Array Curve2D::tesselate(int p_max_stages,float p_tolerance) const {
+
+ Vector2Array tess;
+
+
+ if (points.size()==0) {
+ return tess;
+ }
+ Vector< Map<float,Vector2> > midpoints;
+
+ midpoints.resize(points.size()-1);
+
+ int pc=1;
+ for(int i=0;i<points.size()-1;i++) {
+
+ _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);
+ pc++;
+ pc+=midpoints[i].size();
+
+ }
+
+ tess.resize(pc);
+ Vector2Array::Write bpw=tess.write();
+ bpw[0]=points[0].pos;
+ int pidx=0;
+
+ for(int i=0;i<points.size()-1;i++) {
+
+ for(Map<float,Vector2>::Element *E=midpoints[i].front();E;E=E->next()) {
+
+ pidx++;
+ bpw[pidx] = E->get();
}
+
+ pidx++;
+ bpw[pidx] = points[i+1].pos;
+
}
- r_index=points.size()-1;
- r_pos=1.0;
+ bpw=Vector2Array::Write ();
+ return tess;
}
+void Curve2D::_bind_methods() {
-void Curve3D::set_points_in(const Vector3Array& p_points) {
+ 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("interpolate","idx","t"),&Curve2D::interpolate);
+ ObjectTypeDB::bind_method(_MD("interpolatef","fofs"),&Curve2D::interpolatef);
+ //ObjectTypeDB::bind_method(_MD("bake","subdivs"),&Curve2D::bake,DEFVAL(10));
+ ObjectTypeDB::bind_method(_MD("set_bake_interval","distance"),&Curve2D::set_bake_interval);
+ ObjectTypeDB::bind_method(_MD("get_bake_interval"),&Curve2D::get_bake_interval);
- points.resize(p_points.size());
- for (int i=0; i<p_points.size(); i++) {
+ 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);
- Point p = points[i];
- p.in = p_points[i];
- points[i] = p;
- };
-};
+ ObjectTypeDB::bind_method(_MD("_get_data"),&Curve2D::_get_data);
+ ObjectTypeDB::bind_method(_MD("_set_data"),&Curve2D::_set_data);
-void Curve3D::set_points_out(const Vector3Array& p_points) {
- points.resize(p_points.size());
- for (int i=0; i<p_points.size(); i++) {
+ 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"));
+ /*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"));
+*/
+}
- Point p = points[i];
- p.out = p_points[i];
- points[i] = p;
- };
-};
-void Curve3D::set_points_pos(const Vector3Array& 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;
- };
-};
+Curve2D::Curve2D()
+{
+ baked_cache_dirty=false;
+ baked_max_ofs=0;
+/* add_point(Vector2(-1,0,0));
+ add_point(Vector2(0,2,0));
+ add_point(Vector2(0,3,5));*/
+ bake_interval=5;
-Vector3Array Curve3D::get_points_in() const {
- Vector3Array ret;
- ret.resize(points.size());
- for (int i=0; i<points.size(); i++) {
- ret.set(i, points[i].in);
- };
- return ret;
-};
+}
-Vector3Array Curve3D::get_points_out() const {
- Vector3Array ret;
- ret.resize(points.size());
- for (int i=0; i<points.size(); i++) {
- ret.set(i, points[i].out);
- };
- return ret;
-};
-Vector3Array Curve3D::get_points_pos() const {
- Vector3Array ret;
- ret.resize(points.size());
- for (int i=0; i<points.size(); i++) {
- ret.set(i, points[i].pos);
- };
- return ret;
-};
-#endif
+/***********************************************************************************/
+/***********************************************************************************/
+/***********************************************************************************/
+/***********************************************************************************/
+/***********************************************************************************/
+/***********************************************************************************/
+
+int Curve3D::get_point_count() const {
+
+ return points.size();
+}
+void Curve3D::add_point(const Vector3& p_pos, const Vector3& p_in, const Vector3& p_out,int p_atpos) {
+
+ Point n;
+ 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);
+ else
+ points.push_back(n);
+
+
+ baked_cache_dirty=true;
+ emit_signal(CoreStringNames::get_singleton()->changed);
+}
+void Curve3D::set_point_pos(int p_index, const Vector3& p_pos) {
+
+ ERR_FAIL_INDEX(p_index,points.size());
+
+ points[p_index].pos=p_pos;
+ baked_cache_dirty=true;
+ emit_signal(CoreStringNames::get_singleton()->changed);
+
+}
+Vector3 Curve3D::get_point_pos(int p_index) const {
+
+ ERR_FAIL_INDEX_V(p_index,points.size(),Vector3());
+ return points[p_index].pos;
+
+}
+
+void Curve3D::set_point_tilt(int p_index, float p_tilt) {
+
+ ERR_FAIL_INDEX(p_index,points.size());
+
+ points[p_index].tilt=p_tilt;
+ baked_cache_dirty=true;
+ emit_signal(CoreStringNames::get_singleton()->changed);
+
+}
+float Curve3D::get_point_tilt(int p_index) const {
+
+ ERR_FAIL_INDEX_V(p_index,points.size(),0);
+ return points[p_index].tilt;
+
+}
+
+
+void Curve3D::set_point_in(int p_index, const Vector3& p_in) {
+
+ ERR_FAIL_INDEX(p_index,points.size());
+
+ points[p_index].in=p_in;
+ baked_cache_dirty=true;
+ emit_signal(CoreStringNames::get_singleton()->changed);
+
+}
+Vector3 Curve3D::get_point_in(int p_index) const {
+
+ ERR_FAIL_INDEX_V(p_index,points.size(),Vector3());
+ return points[p_index].in;
+
+}
+
+void Curve3D::set_point_out(int p_index, const Vector3& p_out) {
+
+ ERR_FAIL_INDEX(p_index,points.size());
+
+ points[p_index].out=p_out;
+ baked_cache_dirty=true;
+ emit_signal(CoreStringNames::get_singleton()->changed);
+
+}
+
+Vector3 Curve3D::get_point_out(int p_index) const {
+
+ ERR_FAIL_INDEX_V(p_index,points.size(),Vector3());
+ return points[p_index].out;
+
+}
+
+
+void Curve3D::remove_point(int p_index) {
+
+ ERR_FAIL_INDEX(p_index,points.size());
+ points.remove(p_index);
+ baked_cache_dirty=true;
+ emit_signal(CoreStringNames::get_singleton()->changed);
+}
+
+Vector3 Curve3D::interpolate(int p_index, float p_offset) const {
+
+ int pc = points.size();
+ ERR_FAIL_COND_V(pc==0,Vector3());
+
+ if (p_index >= pc-1)
+ return points[pc-1].pos;
+ else if (p_index<0)
+ return points[0].pos;
+
+ Vector3 p0 = points[p_index].pos;
+ Vector3 p1 = p0+points[p_index].out;
+ Vector3 p3 = points[p_index+1].pos;
+ Vector3 p2 = p3+points[p_index+1].in;
+
+ return _bezier_interp(p_offset,p0,p1,p2,p3);
+}
+
+Vector3 Curve3D::interpolatef(real_t p_findex) const {
+
+
+ if (p_findex>0)
+ p_findex=0;
+ else if (p_findex>=points.size())
+ p_findex=points.size();
+
+ return interpolate((int)p_findex,Math::fmod(p_findex,1.0));
+
+}
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 {
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-27 18:57:01 +0000