SceneObjectPtr
BezierCurve::copy(DeepCopier& copier) const
{
BezierCurve * ptr = new BezierCurve(*this);
copier.copy_attribute(ptr->getCtrlPointList());
return SceneObjectPtr(ptr);
}
void CurveEditor::handleEvent(Event *event) {
if(mode == MODE_ADD) {
if(event->getDispatcher() == bg) {
if(event->getEventCode() == InputEvent::EVENT_MOUSEDOWN) {
InputEvent *inputEvent = (InputEvent*)event;
if(selectedCurve) {
Vector2 pos = inputEvent->mousePosition;
pos.x = pos.x/610.0;
pos.y = 1.0-(pos.y/254.0);
BezierCurve *targetCurve = selectedCurve->targetCurve;
bool done = false;
for(int i=0; i < targetCurve->getNumControlPoints(); i++) {
if(pos.x < targetCurve->getControlPoint(i)->p2.x && !done) {
targetCurve->insertPoint = targetCurve->getControlPoint(i);
done = true;
}
}
targetCurve->addControlPoint2dWithHandles(pos.x-0.1, pos.y, pos.x, pos.y, pos.x + 0.1, pos.y);
selectedCurve->updatePoints();
selectedCurve->updateCurve();
}
}
}
}
if(event->getDispatcher() == selectButton) {
selectorImage->setPosition(selectButton->getPosition().x - 4, selectButton->getPosition().y - 4);
setMode(0);
}
if(event->getDispatcher() == addButton) {
selectorImage->setPosition(addButton->getPosition().x - 4, addButton->getPosition().y - 4);
setMode(1);
}
if(event->getDispatcher() == removeButton) {
selectorImage->setPosition(removeButton->getPosition().x - 4, removeButton->getPosition().y - 4);
setMode(2);
}
if(event->getDispatcher() == treeContainer->getRootNode()) {
if(event->getEventCode() == UITreeEvent::SELECTED_EVENT) {
EditCurve *curve = (EditCurve *)treeContainer->getRootNode()->getSelectedNode()->getUserData();
if(selectedCurve) {
selectedCurve->Deactivate();
}
selectedCurve = curve;
if(curve) {
curve->Activate();
curve->setMode(mode);
}
}
}
UIWindow::handleEvent(event);
}
BezierCurve BezierCurve::transformed(QTransform transformation)
{
BezierCurve transformedCurve = *this; // copy the curve
if (isSelected(-1)) { transformedCurve.setOrigin(transformation.map(origin)); }
for(int i=0; i< vertex.size(); i++)
{
if (isSelected(i-1)) { transformedCurve.setC1(i, transformation.map(c1.at(i))); }
if (isSelected(i))
{
transformedCurve.setC2(i, transformation.map(c2.at(i)));
transformedCurve.setVertex(i, transformation.map(vertex.at(i)));
}
}
//transformedCurve.smoothCurve();
/*QPointF newOrigin = origin;
if (isSelected(-1)) { newOrigin = transformation.map(newOrigin); }
transformedCurve.setOrigin( newOrigin );
for(int i=0; i< vertex.size(); i++) {
QPointF newC1 = c1.at(i);
QPointF newC2 = c2.at(i);
QPointF newVertex = vertex.at(i);
if (isSelected(i-1)) { newC1 = transformation.map(newC1); }
if (isSelected(i)) { newC2 = transformation.map(newC2); newVertex = transformation.map(newVertex); }
transformedCurve.appendCubic( newC1, newC2, newVertex, pressure.at(i) );
if (isSelected(i)) { transformedCurve.setSelected(i, true); }
}
transformedCurve.setWidth( width);
transformedCurve.setVariableWidth( variableWidth );
//transformedCurve.setSelected(true); // or select only the selected elements of the orginal curve?
*/
return transformedCurve;
}
qreal BezierCurve::findDistance(BezierCurve curve, int i, QPointF P, QPointF& nearestPoint, qreal& t) //finds the distance between a cubic section and a point
{
//qDebug() << "---- INTER CUBIC SEGMENT";
int nSteps = 24;
int k0 = 0;
QPointF Q;
Q = curve.getVertex(i-1);
qreal distMin = eLength(Q-P);
nearestPoint = Q;
t = 0;
for(int k=1; k<=nSteps; k++)
{
qreal s = (k+0.0)/nSteps;
Q = curve.getPointOnCubic(i, s);
qreal dist = eLength(Q-P);
if (dist <= distMin)
{
distMin = dist;
nearestPoint = Q;
t = s;
k0 = k;
}
}
//QPointF Q1 = curve.getPointOnCubic(i, t);
return distMin;
}
void Window::load() {
// Generate light source:
Matrix4 temp;
temp.identity();
setMatrix(temp);
glEnable(GL_LIGHTING);
camera.set(e, d, up);
object.move(0, 1, 0);
cameraObject.set(initial.get(0),initial.get(1),initial.get(2));
bCurve.setPoints(initial, Vector4(-2, 8, -4, 0), Vector4(2, 8, 4, 0), endV);
for (int i = 0; i < 100; i++) {
points[i] = bCurve.evalBCurve((double)i / 100);
}
belzCamera.set(points[0], belzD, belzUp);
loadTextures();
loadCharacter();
Vector4 points[49];
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 7; j++) {
int k = i * 7 + j;
points[k] = Vector4((double)i*2 - 6, (double)10, (double)j*2 - 6, 0);
}
}
plane.definePoints(points);
}
void SplineTrack::merge(IMeshBufferPtr buf) const
{
Vector<float> off = make_vector(
static_cast<float>(origin.x),
height,
static_cast<float>(origin.y));
buf->merge(rail_buf, off, 0.0f);
// Draw the sleepers
const float sleeper_sep = 0.25f;
float delta = 0;
int n = 0;
do {
++n;
delta = ((curve.length - sleeper_sep) / n) - sleeper_sep;
} while (delta > sleeper_sep / n);
for (int i = 0; i <= n; i++) {
float pos = (sleeper_sep / 2) + i * (sleeper_sep + delta);
float u_curve_delta;
Vector<float> v = curve.linear(pos / curve.length, &u_curve_delta);
const Vector<float> deriv = curve.deriv(u_curve_delta);
const float angle =
rad_to_deg<float>(atanf(deriv.z / deriv.x));
merge_sleeper(buf, off + v, -angle);
}
}
void SlopeTrack::merge(IMeshBufferPtr buf) const
{
Vector<float> off = make_vector(
static_cast<float>(origin.x),
height,
static_cast<float>(origin.y));
float y_angle = axis == axis::Y ? -90.0f : 0.0f;
off += rotateY(make_vector(-0.5f, 0.0f, 0.0f), y_angle);
buf->merge(rail_buf, off, y_angle);
// Draw the sleepers
for (float t = 0.1f; t < 1.0f; t += 0.25f) {
float u_curve_value;
const Vector<float> curve_value = curve.linear(t, &u_curve_value);
#if 0
// Should the sleepers be at the same angle as the slope?
const Vector<float> deriv = curve.deriv(u_curve_value);
const float angle =
rad_to_deg<float>(atanf(deriv.y / deriv.x));
#endif
Vector<float> v = make_vector(curve_value.x, curve_value.y, 0.0f);
merge_sleeper(buf, off + rotateY(v, y_angle), y_angle);
}
}
void mouse(int button, int state, int x, int y)
{
double vertex[3];
//获取矩阵信息
glGetIntegerv(GL_VIEWPORT, g_Viewport);
glGetDoublev(GL_MODELVIEW_MATRIX, g_ModelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, g_ProjMatrix);
y = g_Viewport[3] - y;
gluUnProject( x, y, 0,
g_ModelMatrix, g_ProjMatrix, g_Viewport,
&vertex[0], &vertex[1], &vertex[2] );
if (button==GLUT_LEFT && state==GLUT_DOWN)
{
myBezier.mouseSynchro( BezierCurve::LButtonDown, vertex );
glutSetCursor( GLUT_CURSOR_RIGHT_ARROW );
}
else if (button == GLUT_LEFT && state == GLUT_UP)
{
myBezier.mouseSynchro( BezierCurve::LButtonUp, vertex );
}
glutPostRedisplay();
}
int w_BezierCurve_getDerivative(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
BezierCurve *deriv = new BezierCurve(curve->getDerivative());
luax_pushtype(L, MATH_BEZIER_CURVE_ID, deriv);
deriv->release();
return 1;
}
int w_BezierCurve_translate(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
float dx = (float) luaL_checknumber(L, 2);
float dy = (float) luaL_checknumber(L, 3);
curve->translate(Vector(dx,dy));
return 0;
}
int w_BezierCurve_scale(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
double s = luaL_checknumber(L, 2);
float ox = (float) luaL_optnumber(L, 3, 0);
float oy = (float) luaL_optnumber(L, 4, 0);
curve->scale(s, Vector(ox,oy));
return 0;
}
int w_BezierCurve_removeControlPoint(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
int idx = (int) luaL_checknumber(L, 2);
if (idx > 0) // 1-indexing
idx--;
luax_catchexcept(L, [&](){ curve->removeControlPoint(idx); });
return 0;
}
float BccWorld::groupCurveLength(GeometryArray * geos)
{
float sum = 0.f;
const unsigned n = geos->numGeometries();
unsigned i = 0;
for(;i<n;i++) {
BezierCurve * c = static_cast<BezierCurve *>(geos->geometry(i));
sum += c->length();
}
return sum;
}
BezierCurve* GameEngine::generateCurve(int numPoints, int sizeCurve) {
BezierCurve *curve = new BezierCurve();
float randX, randY, randZ;
for (int j=0; j < numPoints; j++) {
randX = rand() % sizeCurve - (sizeCurve/2.0);
randY = rand() % sizeCurve - (sizeCurve/2.0);
randZ = rand() % sizeCurve - (sizeCurve/2.0);
curve->addSmoothHandlePoint(randX,randY,randZ);
}
return curve;
}
int w_BezierCurve_insertControlPoint(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
float vx = (float) luaL_checknumber(L, 2);
float vy = (float) luaL_checknumber(L, 3);
int idx = (int) luaL_optnumber(L, 4, -1);
if (idx > 0) // 1-indexing
idx--;
luax_catchexcept(L, [&](){ curve->insertControlPoint(Vector(vx,vy), idx); });
return 0;
}
int w_BezierCurve_getSegment(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
double t1 = luaL_checknumber(L, 2);
double t2 = luaL_checknumber(L, 3);
BezierCurve *segment;
luax_catchexcept(L, [&](){ segment = curve->getSegment(t1, t2); });
luax_pushtype(L, MATH_BEZIER_CURVE_ID, segment);
segment->release();
return 1;
}
int w_BezierCurve_evaluate(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
double t = luaL_checknumber(L, 2);
luax_catchexcept(L, [&]() {
Vector v = curve->evaluate(t);
lua_pushnumber(L, v.x);
lua_pushnumber(L, v.y);
});
return 2;
}
void SplineTrack::bounding_polygon(Polygon& poly) const
{
const float step = 0.01f;
const float fudge = 0.8f;
for (float t = 0.0f; t <= 1.0f; t += step) {
Vector<float> v = curve.offset(t, fudge);
poly.push_back(make_point(v.x, v.z));
}
for (float t = 1.0f; t >= 0.0f; t -= step) {
Vector<float> v = curve.offset(t, -fudge);
poly.push_back(make_point(v.x, v.z));
}
}
void Shape2D_Impl::add_rotated_curve(Path2D &path, const Pointf ¢er, const Angle &angle, Pointf point_1, Pointf point_2, Pointf point_3)
{
if (angle.to_radians() != 0.0f)
{
point_1.rotate(center, angle);
point_2.rotate(center, angle);
point_3.rotate(center, angle);
}
BezierCurve curve;
curve.add_control_point(point_1);
curve.add_control_point(point_2);
curve.add_control_point(point_3);
path.add_curve(curve);
}
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
myBezier.begin();
}
int w_BezierCurve_getControlPoint(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
int idx = (int) luaL_checknumber(L, 2);
if (idx > 0) // 1-indexing
idx--;
luax_catchexcept(L, [&]() {
Vector v = curve->getControlPoint(idx);
lua_pushnumber(L, v.x);
lua_pushnumber(L, v.y);
});
return 2;
}
void SlopeTrack::transform(const track::TravelToken& token, float delta) const
{
assert(delta < length && delta >= 0.0f);
#if 0
debug() << "f(0)=" << curve(0.0f)
<< " f(0.5)=" << curve(0.5f)
<< " f(1.0)=" << curve(1.0f);
debug() << "f'(0)=" << curve.deriv(0.0f)
<< " f'(0.5)=" << curve.deriv(0.5f)
<< " f'(1.0)=" << curve.deriv(1.0f);
#endif
if (token.direction == -axis)
delta = length - delta;
const float curve_delta = delta / length;
float u_curve_delta;
const Vector<float> curve_value = curve.linear(curve_delta, &u_curve_delta);
const float x_trans = axis == axis::X ? curve_value.x : 0.0f;
const float y_trans =curve_value.y;
const float z_trans = axis == axis::Y ? curve_value.x : 0.0f;
glTranslated(static_cast<double>(origin.x) + x_trans,
height + y_trans,
static_cast<double>(origin.y) + z_trans);
if (axis == axis::Y)
glRotated(-90.0, 0.0, 1.0, 0.0);
glTranslated(-0.5, 0.0, 0.0);
if (token.direction == -axis)
glRotated(-180.0, 0.0, 1.0, 0.0);
const Vector<float> deriv = curve.deriv(u_curve_delta);
const float angle =
rad_to_deg<float>(atanf(deriv.y / deriv.x));
if (token.direction == -axis)
glRotatef(-angle, 0.0f, 0.0f, 1.0f);
else
glRotatef(angle, 0.0f, 0.0f, 1.0f);
}
float SlopeTrack::gradient(const track::TravelToken& token, float delta) const
{
assert(delta < length && delta >= 0.0f);
if (token.direction == -axis)
delta = length - delta;
return curve.deriv(delta / length).y;
}
void ViewportPainter::drawBezierCurve(BezierCurve & curve) {
Point2D * beginPoint = curve.getBeginPoint();
Point2D * endPoint = curve.getEndPoint();
Point2D * controlPoint = curve.getControlPoint();
// Plus tard dessin de la courbe :
// this->drawArc(beginPoint->x(),beginPoint->y(),endPoint->x()-beginPoint->x(),endPoint->y()-beginPoint->y(),0*16,360*16);
this->drawLine(beginPoint->x(),beginPoint->y(),endPoint->x(),endPoint->y());
// Dessin du vecteur
/*this->setPen(QColor(255, 120, 0, 255));
this->drawPoint(*controlPoint);
this->drawLine(beginPoint->x(),beginPoint->y(),controlPoint->x(),controlPoint->y());
// Dessiner la fleche du vecteur
//this->drawLine(controlPoint->x(),controlPoint->y());
//this->drawLine(controlPoint->x(),controlPoint->y());
this->setPen(QColor(0, 0, 0, 255));*/
}
int w_BezierCurve_render(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
int accuracy = (int) luaL_optnumber(L, 2, 5);
std::vector<Vector> points;
luax_catchexcept(L, [&](){ points = curve->render(accuracy); });
lua_createtable(L, (int) points.size() * 2, 0);
for (int i = 0; i < (int) points.size(); ++i)
{
lua_pushnumber(L, points[i].x);
lua_rawseti(L, -2, 2*i+1);
lua_pushnumber(L, points[i].y);
lua_rawseti(L, -2, 2*i+2);
}
return 1;
}
bool BccWorld::createCurveGeometryFromFile()
{
if(!readCurveDataFromFile()) return false;
m_allGeo = new GeometryArray;
m_allGeo->create(m_curves->numCurves());
const unsigned n = m_curves->numCurves();
m_allGeo = new GeometryArray;
m_allGeo->create(n);
unsigned * cc = m_curves->counts();
Vector3F * cvs = m_curves->points();
m_totalCurveLength = 0.f;
CurveBuilder cb;
unsigned ncv;
unsigned cvDrift = 0;
unsigned i, j;
for(i=0; i< n; i++) {
ncv = cc[i];
for(j=0; j < ncv; j++)
cb.addVertex(cvs[j + cvDrift]);
BezierCurve * c = new BezierCurve;
cb.finishBuild(c);
m_totalCurveLength += c->length();
m_allGeo->setGeometry(c, i);
cvDrift += ncv;
}
std::cout<<" n curves "<<n
<<" total curve length: "<<m_totalCurveLength<<"\n";
m_numCurves = n;
return true;
}
int w_BezierCurve_renderSegment(lua_State *L)
{
BezierCurve *curve = luax_checkbeziercurve(L, 1);
double start = luaL_checknumber(L, 2);
double end = luaL_checknumber(L, 3);
int accuracy = luaL_optinteger(L, 4, 5);
std::vector<Vector> points;
luax_catchexcept(L, [&](){ points = curve->renderSegment(start, end, accuracy); });
lua_createtable(L, points.size()*2, 0);
for (size_t i = 0; i < points.size(); ++i)
{
lua_pushnumber(L, points[i].x);
lua_rawseti(L, -2, 2*i+1);
lua_pushnumber(L, points[i].y);
lua_rawseti(L, -2, 2*i+2);
}
return 1;
}
bool operator()(
double const* const paramsX,
double const* const paramsY,
double* residuals) const {
BezierCurve<float, double> bezierX;
BezierCurve<float, double> bezierY;
for (int i = 0; i <= TBezierX; ++i) {
bezierX.addPoint(paramsX[i]);
}
for (int i = 0; i <= TBezierY; ++i) {
bezierY.addPoint(paramsY[i]);
}
const double vx = bezierX(x);
const double vy = bezierY(y);
*residuals = vx * vy - intensity;
CHECK(std::isfinite(*residuals));
return true;
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 0.0);
glPointSize(5.0);
glPushMatrix();
{
myBezier.renderCurve();
}glPopMatrix();
glutSwapBuffers();
}
//////////////////////////////////////////////////////////////////////////
// 计算控制节点
void motion(int x, int y)
{
double vertex[3];
glutSetCursor( GLUT_CURSOR_CROSSHAIR );
y = g_Viewport[3] - y;
gluUnProject( x, y, 0,
g_ModelMatrix, g_ProjMatrix, g_Viewport,
&vertex[0], &vertex[1], &vertex[2] );
myBezier.mouseSynchro( BezierCurve::MouseMove, vertex );
glutPostRedisplay();
}
