SisMaker
/
yzyCli


								cc = cc or {}


								--Cat_Todo : 本文件暂时没用，所以没测试过的


								local DeepCopy = function ( object )

								    local lookup_table = {}

								    local function _copy(object)

								        if type(object) ~= "table" then

								            return object

								        elseif lookup_table[object] then

								            return lookup_table[object]

								        end


								        local new_table = {}

								        lookup_table[object] = new_table

								        for index, value in pairs(object) do

								            new_table[_copy(index)] = _copy(value)

								        end


								        return setmetatable(new_table, getmetatable(object))

								    end

								    return _copy(object)

								end


								cc.PointArray = cc.PointArray or BaseClass()

								function cc.PointArray:__init( points )

								    self._controlPoints = points

								end

								function cc.PointArray:clone()

								    return DeepCopy(self)

								end


								function cc.PointArray:getControlPoints()

								    return _controlPoints;

								end


								function cc.PointArray:setControlPoints(controlPoints)

								    self._controlPoints = controlPoints

								end


								function cc.PointArray:addControlPoint(controlPoint)

								    table.insert( self._controlPoints, controlPoint )

								end


								function cc.PointArray:insertControlPoint(controlPoint, index)

								    -- self._controlPoints[index] = controlPoint

								    table.insert( self._controlPoints, index, controlPoint )

								end


								function cc.PointArray:getControlPointAtIndex(index)

								    index = math.floor( index )

								    local count = 0

								    if self._controlPoints then

								        count = #self._controlPoints

								    end

								    if index > count then

								        index = count

								    end

								    if index <= 0 then

								        index = 1

								    end

								    -- index = math.min(count, index)

								    -- index = index>=1 and index or 1

								    -- print("Cat:ActionCatmullRom.lua [34][start] self._controlPoints", self._controlPoints,index)

								    -- PrintTable(self._controlPoints)

								    -- print("Cat:ActionCatmullRom.lua [34][end]")

								    return self._controlPoints[index]

								end


								function cc.PointArray:replaceControlPoint(controlPoint, index)

								    self._controlPoints[index] = controlPoint

								end


								function cc.PointArray:removeControlPointAtIndex(index)

								    if self._controlPoints[index] then

								        table.remove( self._controlPoints, index )

								    end

								end


								function cc.PointArray:count()

								    return #self._controlPoints

								end


								function cc.PointArray:reverse()

								    local newArray = {}

								    for i=#self._controlPoints,1,-1 do

								        table.insert( newArray, self._controlPoints[i])

								    end

								    local config = cc.PointArray.New()

								    config:setControlPoints(newArray);


								    return config;

								end


								-- function cc.PointArray:reverseInline()

								-- {

								--     size_t l = _controlPoints->size();

								--     Vec2 *p1 = nullptr;

								--     Vec2 *p2 = nullptr;

								--     float x, y;

								--     for (size_t i = 0; i < l/2; ++i)

								--     {

								--         p1 = _controlPoints->at(i);

								--         p2 = _controlPoints->at(l-i-1);


								--         x = p1->x;

								--         y = p1->y;


								--         p1->x = p2->x;

								--         p1->y = p2->y;


								--         p2->x = x;

								--         p2->y = y;

								--     }

								-- }


								-- CatmullRom Spline formula:

								function cc.CardinalSplineAt(p0, p1, p2, p3, tension, t)

								    local t2 = t * t

								    local t3 = t2 * t

								    --Formula: s(-ttt + 2tt - t)P1 + s(-ttt + tt)P2 + (2ttt - 3tt + 1)P2 + s(ttt - 2tt + t)P3 + (-2ttt + 3tt)P3 + s(ttt - tt)P4


								    local s = (1 - tension) / 2


								    local b1 = s * ((-t3 + (2 * t2)) - t);                      -- s(-t3 + 2 t2 - t)P1

								    local b2 = s * (-t3 + t2) + (2 * t3 - 3 * t2 + 1);          -- s(-t3 + t2)P2 + (2 t3 - 3 t2 + 1)P2

								    local b3 = s * (t3 - 2 * t2 + t) + (-2 * t3 + 3 * t2);      -- s(t3 - 2 t2 + t)P3 + (-2 t3 + 3 t2)P3

								    local b4 = s * (t3 - t2);                                   -- s(t3 - t2)P4


								    local x = (p0.x*b1 + p1.x*b2 + p2.x*b3 + p3.x*b4);

								    local y = (p0.y*b1 + p1.y*b2 + p2.y*b3 + p3.y*b4);


								    return {x=x, y=y}

								end


								--points是控制点列表，tension是松紧程度。tension==1时，样条线是分段直线。tension<1向外松弛弯曲，tension>1向内缩紧弯曲。By动作是以当前坐标为新坐标原点

								cc.CardinalSplineTo = cc.CardinalSplineTo or BaseClass(cc.ActionInterval)

								function cc.CardinalSplineTo:__init(duration, points, tension)

								    self:initWithDuration(duration, points, tension)

								end


								function cc.CardinalSplineTo:initWithDuration(duration, points, tension)

								    self._deltaT = 0.0

								    -- self._tension = 0.0

								    -- CCASSERT(points->count() > 0, "Invalid configuration. It must at least have one control point");

								    cc.ActionInterval.initWithDuration(self, duration)

								    self._points = cc.PointArray.New(points)

								    self._tension = tension

								end


								function cc.CardinalSplineTo:startWithTarget(target)

								    cc.ActionInterval.startWithTarget(self, target);

								--     _deltaT = (float) 1 / _points->count();

								    self._deltaT =  1 / (self._points:count() - 1);

								    self._previousPosition = {}

								    self._previousPosition.x, self._previousPosition.y, self._previousPosition.z = cc.Wrapper.GetLocalPosition(target)

								    self._accumulatedDiff = {x=0, y=0}

								end


								function cc.CardinalSplineTo:clone()

								    local a = cc.CardinalSplineTo.New()

								    a:initWithDuration(self._duration, self._points:clone(), self._tension)

								    return a

								end


								function cc.CardinalSplineTo:update(time)

								    local p;

								    local lt;


								    -- eg.

								    -- p..p..p..p..p..p..p

								    -- 1..2..3..4..5..6..7

								    -- want p to be 1, 2, 3, 4, 5, 6

								    if (time == 1) then

								        p = self._points:count()-1

								        lt = 1;

								    else

								        p = math.floor(time / self._deltaT)

								        lt = (time - self._deltaT * p) / self._deltaT

								    end

								    -- print("Cat:ActionCatmullRom.lua [150] time,p,lt:", time,p,lt)

								    -- Interpolate

								    local addition = 0

								    local pp0 = DeepCopy(self._points:getControlPointAtIndex(p+0+addition))

								    local pp1 = DeepCopy(self._points:getControlPointAtIndex(p+1+addition))

								    local pp2 = DeepCopy(self._points:getControlPointAtIndex(p+2+addition))

								    local pp3 = DeepCopy(self._points:getControlPointAtIndex(p+3+addition))


								    print("Cat:ActionCatmullRom [166] pp0, pp1, pp2, pp3: ", pp0.x, pp0.y, pp1.x, pp1.y, pp2.x, pp2.y, pp3.x, pp3.y, p)

								    pp0.y = 720-pp0.y

								    pp1.y = 720-pp1.y

								    pp2.y = 720-pp2.y

								    pp3.y = 720-pp3.y

								    local newPos = cc.CardinalSplineAt(pp0, pp1, pp2, pp3, self._tension, lt)

								    newPos.y = 720-newPos.y

									-- print("Cat:ActionCatmullRom.lua [157] newPos.x,newPos.y:", newPos.x,newPos.y, lt)

								-- #if CC_ENABLE_STACKABLE_ACTIONS

								--     -- Support for stacked actions

								--     Node *node = _target;

								--     local diff = node->getPosition() - _previousPosition;

								--     if( diff.x !=0 || diff.y != 0 )

								--         _accumulatedDiff = _accumulatedDiff + diff;

								--         newPos = newPos + _accumulatedDiff;

								--     end

								-- #endif

								    self:updatePosition(newPos)

								end


								function cc.CardinalSplineTo:updatePosition(newPos)

								    if self._target.SetVectorValue then

								        self._target:SetVectorValue(WidgetProperty.Position, newPos.x, newPos.y)

								    elseif self._target.setPosition then

								        self._target:setPosition(newPos.x, newPos.y)

								    end

								    self._previousPosition = newPos

								end


								function cc.CardinalSplineTo:reverse()

								    local pReverse = self._points:reverse()

								    return cc.CardinalSplineTo.New(self._duration, pReverse, self._tension)

								end


								-- function cc.CardinalSplineBy:create(duration, points, tension)


								--     CardinalSplineBy *ret = new (std:nothrow) CardinalSplineBy();

								--     if (ret)


								--         if (ret->initWithDuration(duration, points, tension))


								--             ret->autorelease();

								--         else


								--             CC_SAFE_RELEASE_NULL(ret);

								--         end

								--     end


								--     return ret;

								-- end


								-- CardinalSplineBy:CardinalSplineBy() : _startPosition(0,0)


								-- end


								-- function cc.CardinalSplineBy:updatePosition(cocos2d:Vec2 &newPos)


								--     Vec2 p = newPos + _startPosition;

								--     _target->setPosition(p);

								--     _previousPosition = p;

								-- end


								-- CardinalSplineBy* CardinalSplineBy:reverse() const


								--     PointArray *copyConfig = _points->clone();


								--     //

								--     // convert "absolutes" to "diffs"

								--     //

								--     Vec2 p = copyConfig->getControlPointAtIndex(0);

								--     for (ssize_t i = 1; i < copyConfig->count(); ++i)


								--         Vec2 current = copyConfig->getControlPointAtIndex(i);

								--         Vec2 diff = current - p;

								--         copyConfig->replaceControlPoint(diff, i);


								--         p = current;

								--     end


								--     // convert to "diffs" to "reverse absolute"


								--     PointArray *pReverse = copyConfig->reverse();


								--     // 1st element (which should be 0,0) should be here too


								--     p = pReverse->getControlPointAtIndex(pReverse->count()-1);

								--     pReverse->removeControlPointAtIndex(pReverse->count()-1);


								--     p = -p;

								--     pReverse->insertControlPoint(p, 0);


								--     for (ssize_t i = 1; i < pReverse->count(); ++i)


								--         Vec2 current = pReverse->getControlPointAtIndex(i);

								--         current = -current;

								--         Vec2 abs = current + p;

								--         pReverse->replaceControlPoint(abs, i);


								--         p = abs;

								--     end


								--     return CardinalSplineBy:create(_duration, pReverse, _tension);

								-- end


								-- function cc.CardinalSplineBy:startWithTarget(cocos2d:Node *target)


								--     CardinalSplineTo:startWithTarget(target);

								--     _startPosition = target->getPosition();

								-- end


								-- CardinalSplineBy* CardinalSplineBy:clone() const


								--     // no copy constructor

								--     auto a = new (std:nothrow) CardinalSplineBy();

								--     a->initWithDuration(this->_duration, this->_points->clone(), this->_tension);

								--     a->autorelease();

								--     return a;

								-- end