mirror of https://github.com/axmolengine/axmol.git
1198 lines
37 KiB
Lua
1198 lines
37 KiB
Lua
local itemTagBasic = 1000
|
|
local armaturePerformanceTag = 20000
|
|
local frameEventActionTag = 10000
|
|
local winSize = cc.Director:getInstance():getWinSize()
|
|
local scheduler = cc.Director:getInstance():getScheduler()
|
|
local ArmatureTestIndex =
|
|
{
|
|
TEST_ASYNCHRONOUS_LOADING = 1,
|
|
TEST_DIRECT_LOADING = 2,
|
|
TEST_COCOSTUDIO_WITH_SKELETON = 3,
|
|
TEST_DRAGON_BONES_2_0 = 4,
|
|
TEST_PERFORMANCE = 5,
|
|
TEST_PERFORMANCE_BATCHNODE = 6,
|
|
TEST_CHANGE_ZORDER = 7,
|
|
TEST_ANIMATION_EVENT = 8,
|
|
TEST_FRAME_EVENT = 9,
|
|
TEST_PARTICLE_DISPLAY = 10,
|
|
TEST_USE_DIFFERENT_PICTURE = 11,
|
|
TEST_ANCHORPOINT = 12,
|
|
TEST_ARMATURE_NESTING = 13,
|
|
TEST_ARMATURE_NESTING_2 = 14,
|
|
}
|
|
local armatureSceneIdx = ArmatureTestIndex.TEST_ASYNCHRONOUS_LOADING
|
|
|
|
local ArmatureTestScene = class("ArmatureTestScene")
|
|
ArmatureTestScene.__index = ArmatureTestScene
|
|
|
|
function ArmatureTestScene.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, ArmatureTestScene)
|
|
return target
|
|
end
|
|
|
|
function ArmatureTestScene:runThisTest()
|
|
armatureSceneIdx = ArmatureTestIndex.TEST_ASYNCHRONOUS_LOADING
|
|
self:addChild(restartArmatureTest())
|
|
end
|
|
|
|
function ArmatureTestScene.create()
|
|
local scene = ArmatureTestScene.extend(cc.Scene:create())
|
|
local bg = cc.Sprite:create("armature/bg.jpg")
|
|
bg:setPosition(VisibleRect:center())
|
|
|
|
local scaleX = VisibleRect:getVisibleRect().width / bg:getContentSize().width
|
|
local scaleY = VisibleRect:getVisibleRect().height / bg:getContentSize().height
|
|
|
|
bg:setScaleX(scaleX)
|
|
bg:setScaleY(scaleY)
|
|
|
|
scene:addChild(bg)
|
|
return scene
|
|
end
|
|
|
|
function ArmatureTestScene.toMainMenuCallback()
|
|
ccs.ArmatureDataManager:purgeArmatureSystem()
|
|
end
|
|
|
|
local ArmatureTestLayer = class("ArmatureTestLayer")
|
|
ArmatureTestLayer.__index = ArmatureTestLayer
|
|
ArmatureTestLayer._backItem = nil
|
|
ArmatureTestLayer._restarItem = nil
|
|
ArmatureTestLayer._nextItem = nil
|
|
|
|
function ArmatureTestLayer:onEnter()
|
|
|
|
end
|
|
|
|
function ArmatureTestLayer.title(idx)
|
|
if ArmatureTestIndex.TEST_ASYNCHRONOUS_LOADING == idx then
|
|
return "Test Asynchronous Loading"
|
|
elseif ArmatureTestIndex.TEST_DIRECT_LOADING == idx then
|
|
return "Test Direct Loading"
|
|
elseif ArmatureTestIndex.TEST_COCOSTUDIO_WITH_SKELETON == idx then
|
|
return "Test Export From CocoStudio With Skeleton Effect"
|
|
elseif ArmatureTestIndex.TEST_DRAGON_BONES_2_0 == idx then
|
|
return "Test Export From DragonBones version 2.0"
|
|
elseif ArmatureTestIndex.TEST_PERFORMANCE == idx then
|
|
return "Test Performance"
|
|
elseif ArmatureTestIndex.TEST_PERFORMANCE_BATCHNODE == idx then
|
|
return "Test Performance of using BatchNode"
|
|
elseif ArmatureTestIndex.TEST_CHANGE_ZORDER == idx then
|
|
return "Test Change ZOrder Of Different Armature"
|
|
elseif ArmatureTestIndex.TEST_ANIMATION_EVENT == idx then
|
|
return "Test Armature Animation Event"
|
|
elseif ArmatureTestIndex.TEST_FRAME_EVENT == idx then
|
|
return "Test Frame Event"
|
|
elseif ArmatureTestIndex.TEST_PARTICLE_DISPLAY == idx then
|
|
return "Test Particle Display"
|
|
elseif ArmatureTestIndex.TEST_USE_DIFFERENT_PICTURE == idx then
|
|
return "Test One Armature Use Different Picture"
|
|
elseif ArmatureTestIndex.TEST_ANCHORPOINT == idx then
|
|
return "Test Set AnchorPoint"
|
|
elseif ArmatureTestIndex.TEST_ARMATURE_NESTING == idx then
|
|
return "Test Armature Nesting"
|
|
elseif ArmatureTestIndex.TEST_ARMATURE_NESTING_2 == idx then
|
|
return "Test Armature Nesting 2"
|
|
end
|
|
end
|
|
|
|
function ArmatureTestLayer.subTitle(idx)
|
|
if ArmatureTestIndex.TEST_ASYNCHRONOUS_LOADING == idx then
|
|
return "current percent :"
|
|
elseif ArmatureTestIndex.TEST_PERFORMANCE == idx then
|
|
return "Current Armature Count : "
|
|
elseif ArmatureTestIndex.TEST_PERFORMANCE_BATCHNODE == idx then
|
|
return "Current Armature Count : "
|
|
elseif ArmatureTestIndex.TEST_PARTICLE_DISPLAY == idx then
|
|
return "Touch to change animation"
|
|
elseif ArmatureTestIndex.TEST_USE_DIFFERENT_PICTURE == idx then
|
|
return "weapon and armature are in different picture"
|
|
elseif ArmatureTestIndex.TEST_ARMATURE_NESTING_2 == idx then
|
|
return "Move to a mount and press the ChangeMount Button."
|
|
else
|
|
return ""
|
|
end
|
|
end
|
|
|
|
function ArmatureTestLayer.create()
|
|
local layer = ArmatureTestLayer.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
|
|
return layer
|
|
end
|
|
|
|
function ArmatureTestLayer.backCallback()
|
|
local newScene = ArmatureTestScene.create()
|
|
newScene:addChild(backArmatureTest())
|
|
cc.Director:getInstance():replaceScene(newScene)
|
|
end
|
|
|
|
function ArmatureTestLayer.restartCallback()
|
|
local newScene = ArmatureTestScene.create()
|
|
newScene:addChild(restartArmatureTest())
|
|
cc.Director:getInstance():replaceScene(newScene)
|
|
end
|
|
|
|
function ArmatureTestLayer.nextCallback()
|
|
local newScene = ArmatureTestScene.create()
|
|
newScene:addChild(nextArmatureTest())
|
|
cc.Director:getInstance():replaceScene(newScene)
|
|
end
|
|
|
|
function ArmatureTestLayer:createMenu()
|
|
local menu = cc.Menu:create()
|
|
|
|
self._backItem = cc.MenuItemImage:create(s_pPathB1, s_pPathB2)
|
|
self._backItem:registerScriptTapHandler(self.backCallback)
|
|
menu:addChild(self._backItem,itemTagBasic)
|
|
self._restarItem = cc.MenuItemImage:create(s_pPathR1, s_pPathR2)
|
|
self._restarItem:registerScriptTapHandler(self.restartCallback)
|
|
menu:addChild(self._restarItem,itemTagBasic)
|
|
self._nextItem = cc.MenuItemImage:create(s_pPathF1, s_pPathF2)
|
|
menu:addChild(self._nextItem,itemTagBasic)
|
|
self._nextItem:registerScriptTapHandler(self.nextCallback)
|
|
|
|
local size = cc.Director:getInstance():getWinSize()
|
|
self._backItem:setPosition(cc.p(size.width / 2 - self._restarItem:getContentSize().width * 2, self._restarItem:getContentSize().height / 2))
|
|
self._restarItem:setPosition(cc.p(size.width / 2, self._restarItem:getContentSize().height / 2))
|
|
self._nextItem:setPosition(cc.p(size.width / 2 + self._restarItem:getContentSize().width * 2, self._restarItem:getContentSize().height / 2))
|
|
|
|
menu:setPosition(cc.p(0, 0))
|
|
|
|
self:addChild(menu)
|
|
end
|
|
|
|
function ArmatureTestLayer.toExtensionMenu()
|
|
ccs.ArmatureDataManager:destoryInstance()
|
|
local scene = CocoStudioTestMain()
|
|
if scene ~= nil then
|
|
cc.Director:getInstance():replaceScene(scene)
|
|
end
|
|
end
|
|
|
|
function ArmatureTestLayer:createToExtensionMenu()
|
|
cc.MenuItemFont:setFontName("Arial")
|
|
cc.MenuItemFont:setFontSize(24)
|
|
local menuItemFont = cc.MenuItemFont:create("Back")
|
|
menuItemFont:setPosition(cc.p(VisibleRect:rightBottom().x - 50, VisibleRect:rightBottom().y + 25))
|
|
menuItemFont:registerScriptTapHandler(ArmatureTestLayer.toExtensionMenu)
|
|
|
|
local backMenu = cc.Menu:create()
|
|
backMenu:addChild(menuItemFont)
|
|
backMenu:setPosition(cc.p(0, 0))
|
|
self:addChild(backMenu,10)
|
|
end
|
|
|
|
function ArmatureTestLayer:creatTitleAndSubTitle(idx)
|
|
local title = cc.LabelTTF:create(ArmatureTestLayer.title(idx),"Arial",18)
|
|
title:setColor(cc.c3b(0,0,0))
|
|
self:addChild(title, 1, 10000)
|
|
title:setPosition( cc.p(VisibleRect:center().x, VisibleRect:top().y - 30))
|
|
local subTitle = nil
|
|
if "" ~= ArmatureTestLayer.subTitle(idx) then
|
|
local subTitle = cc.LabelTTF:create(ArmatureTestLayer.subTitle(idx), "Arial", 18)
|
|
subTitle:setColor(cc.c3b(0,0,0))
|
|
self:addChild(subTitle, 1, 10001)
|
|
subTitle:setPosition( cc.p(VisibleRect:center().x, VisibleRect:top().y - 60) )
|
|
end
|
|
end
|
|
|
|
local TestAsynchronousLoading = class("TestAsynchronousLoading",ArmatureTestLayer)
|
|
TestAsynchronousLoading.__index = TestAsynchronousLoading
|
|
|
|
function TestAsynchronousLoading.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestAsynchronousLoading)
|
|
return target
|
|
end
|
|
|
|
function TestAsynchronousLoading:onEnter()
|
|
self._backItem:setEnabled(false)
|
|
self._restarItem:setEnabled(false)
|
|
self._nextItem:setEnabled(false)
|
|
|
|
local title = cc.LabelTTF:create(ArmatureTestLayer.title(1),"Arial",18)
|
|
title:setColor(cc.c3b(0,0,0))
|
|
self:addChild(title, 1, 10000)
|
|
title:setPosition( cc.p(VisibleRect:center().x, VisibleRect:top().y - 30))
|
|
local subTitle = nil
|
|
if "" ~= ArmatureTestLayer.subTitle(1) then
|
|
local subInfo = ArmatureTestLayer.subTitle(1) .. 0.0
|
|
local subTitle = cc.LabelTTF:create(subInfo, "Arial", 18)
|
|
subTitle:setColor(cc.c3b(0,0,0))
|
|
self:addChild(subTitle, 1, 10001)
|
|
subTitle:setPosition( cc.p(VisibleRect:center().x, VisibleRect:top().y - 60) )
|
|
end
|
|
|
|
local function dataLoaded(percent)
|
|
local label = self:getChildByTag(10001)
|
|
if nil ~= label then
|
|
local subInfo = ArmatureTestLayer.subTitle(1) .. (percent * 100)
|
|
label:setString(subInfo)
|
|
end
|
|
if percent >= 1 and nil ~= self._backItem and nil ~= self._restarItem and nil ~= self._nextItem then
|
|
self._backItem:setEnabled(true)
|
|
self._restarItem:setEnabled(true)
|
|
self._nextItem:setEnabled(true)
|
|
end
|
|
end
|
|
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/knight.png", "armature/knight.plist", "armature/knight.xml", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/weapon.png", "armature/weapon.plist", "armature/weapon.xml", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/robot.png", "armature/robot.plist", "armature/robot.xml", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/cyborg.png", "armature/cyborg.plist", "armature/cyborg.xml", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/Dragon.png", "armature/Dragon.plist", "armature/Dragon.xml", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/Cowboy.ExportJson", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/hero.ExportJson", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/horse.ExportJson", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/bear.ExportJson", dataLoaded)
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfoAsync("armature/HeroAnimation.ExportJson", dataLoaded)
|
|
|
|
end
|
|
|
|
function TestAsynchronousLoading.restartCallback()
|
|
ccs.ArmatureDataManager:destoryInstance()
|
|
local newScene = ArmatureTestScene.create()
|
|
newScene:addChild(restartArmatureTest())
|
|
cc.Director:getInstance():replaceScene(newScene)
|
|
end
|
|
|
|
function TestAsynchronousLoading.create()
|
|
local layer = TestAsynchronousLoading.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
end
|
|
|
|
return layer
|
|
end
|
|
|
|
local TestDirectLoading = class("TestDirectLoading",ArmatureTestLayer)
|
|
TestDirectLoading.__index = TestDirectLoading
|
|
|
|
function TestDirectLoading.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestDirectLoading)
|
|
return target
|
|
end
|
|
|
|
function TestDirectLoading:onEnter()
|
|
ccs.ArmatureDataManager:getInstance():removeArmatureFileInfo("armature/bear.ExportJson")
|
|
ccs.ArmatureDataManager:getInstance():addArmatureFileInfo("armature/bear.ExportJson")
|
|
local armature = ccs.Armature:create("bear")
|
|
armature:getAnimation():playByIndex(0)
|
|
armature:setPosition(cc.p(VisibleRect:center()))
|
|
self:addChild(armature)
|
|
end
|
|
|
|
function TestDirectLoading.create()
|
|
local layer = TestDirectLoading.extend(cc.Layer:create())
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
return layer
|
|
end
|
|
|
|
|
|
local TestCSWithSkeleton = class("TestCSWithSkeleton",ArmatureTestLayer)
|
|
TestCSWithSkeleton.__index = TestCSWithSkeleton
|
|
|
|
function TestCSWithSkeleton.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestCSWithSkeleton)
|
|
return target
|
|
end
|
|
|
|
function TestCSWithSkeleton:onEnter()
|
|
local armature = ccs.Armature:create("Cowboy")
|
|
armature:getAnimation():playByIndex(0)
|
|
armature:setScale(0.2)
|
|
armature:setAnchorPoint(cc.p(0.5, 0.5))
|
|
armature:setPosition(cc.p(winSize.width / 2, winSize.height / 2))
|
|
self:addChild(armature)
|
|
end
|
|
|
|
function TestCSWithSkeleton.create()
|
|
local layer = TestCSWithSkeleton.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
|
|
return layer
|
|
end
|
|
|
|
local TestDragonBones20 = class("TestDragonBones20",ArmatureTestLayer)
|
|
TestDragonBones20.__index = TestDragonBones20
|
|
|
|
function TestDragonBones20.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestDragonBones20)
|
|
return target
|
|
end
|
|
|
|
function TestDragonBones20:onEnter()
|
|
local armature = ccs.Armature:create("Dragon")
|
|
armature:getAnimation():playByIndex(1)
|
|
armature:getAnimation():setSpeedScale(0.4)
|
|
armature:setPosition(cc.p(VisibleRect:center().x, VisibleRect:center().y * 0.3))
|
|
armature:setScale(0.6)
|
|
self:addChild(armature)
|
|
end
|
|
|
|
function TestDragonBones20.create()
|
|
local layer = TestDragonBones20.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
return layer
|
|
end
|
|
|
|
local TestPerformance = class("TestPerformance",ArmatureTestLayer)
|
|
TestPerformance.__index = TestPerformance
|
|
TestPerformance._armatureCount = 0
|
|
TestPerformance._frames = 0
|
|
TestPerformance._times = 0
|
|
TestPerformance._lastTimes = 0
|
|
TestPerformance._generated = false
|
|
|
|
function TestPerformance.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestPerformance)
|
|
return target
|
|
end
|
|
|
|
function TestPerformance:refreshTitile()
|
|
local subTitleInfo = ArmatureTestLayer.subTitle(5) .. self._armatureCount
|
|
local label = tolua.cast(self:getChildByTag(10001),"LabelTTF")
|
|
label:setString(subTitleInfo)
|
|
end
|
|
|
|
function TestPerformance:addArmatureToParent(armature)
|
|
self:addChild(armature, 0, armaturePerformanceTag + self._armatureCount)
|
|
end
|
|
|
|
function TestPerformance:removeArmatureFromParent(tag)
|
|
self:removeChildByTag(armaturePerformanceTag + self._armatureCount, true)
|
|
end
|
|
|
|
function TestPerformance:addArmature(num)
|
|
for i = 1, num do
|
|
self._armatureCount = self._armatureCount + 1
|
|
local armature = ccs.Armature:create("Knight_f/Knight")
|
|
armature:getAnimation():playByIndex(0)
|
|
armature:setPosition(50 + self._armatureCount * 2, 150)
|
|
armature:setScale(0.6)
|
|
self:addArmatureToParent(armature)
|
|
end
|
|
|
|
self:refreshTitile()
|
|
end
|
|
|
|
function TestPerformance:onEnter()
|
|
|
|
local function onIncrease(sender)
|
|
self:addArmature(20)
|
|
end
|
|
|
|
local function onDecrease(sender)
|
|
if self._armatureCount == 0 then
|
|
return
|
|
end
|
|
|
|
for i = 1, 20 do
|
|
self:removeArmatureFromParent(armaturePerformanceTag + self._armatureCount)
|
|
self._armatureCount = self._armatureCount - 1
|
|
self:refreshTitile()
|
|
end
|
|
end
|
|
|
|
cc.MenuItemFont:setFontSize(65)
|
|
local decrease = cc.MenuItemFont:create(" - ")
|
|
decrease:setColor(cc.c3b(0,200,20))
|
|
decrease:registerScriptTapHandler(onDecrease)
|
|
|
|
local increase = cc.MenuItemFont:create(" + ")
|
|
increase:setColor(cc.c3b(0,200,20))
|
|
increase:registerScriptTapHandler(onIncrease)
|
|
|
|
local menu = cc.Menu:create(decrease, increase )
|
|
menu:alignItemsHorizontally()
|
|
menu:setPosition(cc.p(VisibleRect:getVisibleRect().width/2, VisibleRect:getVisibleRect().height-100))
|
|
self:addChild(menu, 10000)
|
|
|
|
self._armatureCount = 0
|
|
self._frames = 0
|
|
self._times = 0
|
|
self._lastTimes = 0
|
|
self._generated = false
|
|
|
|
self:addArmature(100)
|
|
end
|
|
|
|
function TestPerformance.create()
|
|
local layer = TestPerformance.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
layer:onEnter()
|
|
end
|
|
return layer
|
|
end
|
|
|
|
local TestPerformanceBatchNode = class("TestPerformanceBatchNode",TestPerformance)
|
|
TestPerformanceBatchNode.__index = TestPerformanceBatchNode
|
|
TestPerformanceBatchNode._batchNode = nil
|
|
|
|
function TestPerformanceBatchNode.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestPerformanceBatchNode)
|
|
return target
|
|
end
|
|
|
|
function TestPerformanceBatchNode:addArmatureToParent(armature)
|
|
self._batchNode:addChild(armature, 0, armaturePerformanceTag + self._armatureCount)
|
|
end
|
|
|
|
function TestPerformanceBatchNode:removeArmatureFromParent(tag)
|
|
self._batchNode:removeChildByTag(armaturePerformanceTag + self._armatureCount, true)
|
|
end
|
|
|
|
function TestPerformanceBatchNode:onEnter()
|
|
self._batchNode = ccs.BatchNode:create()
|
|
self:addChild(self._batchNode)
|
|
|
|
local function onIncrease(sender)
|
|
self:addArmature(20)
|
|
end
|
|
|
|
local function onDecrease(sender)
|
|
if self._armatureCount == 0 then
|
|
return
|
|
end
|
|
|
|
for i = 1, 20 do
|
|
self:removeArmatureFromParent(armaturePerformanceTag + self._armatureCount)
|
|
self._armatureCount = self._armatureCount - 1
|
|
self:refreshTitile()
|
|
end
|
|
end
|
|
|
|
cc.MenuItemFont:setFontSize(65)
|
|
local decrease = cc.MenuItemFont:create(" - ")
|
|
decrease:setColor(cc.c3b(0,200,20))
|
|
decrease:registerScriptTapHandler(onDecrease)
|
|
|
|
local increase = cc.MenuItemFont:create(" + ")
|
|
increase:setColor(cc.c3b(0,200,20))
|
|
increase:registerScriptTapHandler(onIncrease)
|
|
|
|
local menu = cc.Menu:create(decrease, increase )
|
|
menu:alignItemsHorizontally()
|
|
menu:setPosition(cc.p(VisibleRect:getVisibleRect().width/2, VisibleRect:getVisibleRect().height-100))
|
|
self:addChild(menu, 10000)
|
|
|
|
self._armatureCount = 0
|
|
self._frames = 0
|
|
self._times = 0
|
|
self._lastTimes = 0
|
|
self._generated = false
|
|
|
|
self:addArmature(100)
|
|
end
|
|
|
|
function TestPerformanceBatchNode.create()
|
|
local layer = TestPerformanceBatchNode.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
layer:onEnter()
|
|
end
|
|
return layer
|
|
end
|
|
|
|
local TestChangeZorder = class("TestChangeZorder",ArmatureTestLayer)
|
|
TestChangeZorder.__index = TestChangeZorder
|
|
TestChangeZorder.currentTag = -1
|
|
|
|
function TestChangeZorder.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestChangeZorder)
|
|
return target
|
|
end
|
|
|
|
function TestChangeZorder:onEnter()
|
|
self.currentTag = -1
|
|
|
|
local armature = ccs.Armature:create("Knight_f/Knight")
|
|
armature:getAnimation():playByIndex(0)
|
|
armature:setPosition(cc.p(winSize.width / 2, winSize.height / 2 - 100 ))
|
|
armature:setScale(0.6)
|
|
self.currentTag = self.currentTag + 1
|
|
self:addChild(armature, self.currentTag, self.currentTag)
|
|
|
|
armature = ccs.Armature:create("Cowboy")
|
|
armature:getAnimation():playByIndex(0)
|
|
armature:setScale(0.24)
|
|
armature:setPosition(cc.p(winSize.width / 2, winSize.height / 2 - 100))
|
|
self.currentTag = self.currentTag + 1
|
|
self:addChild(armature, self.currentTag, self.currentTag)
|
|
|
|
armature = ccs.Armature:create("Dragon")
|
|
armature:getAnimation():playByIndex(0)
|
|
armature:setPosition(cc.p(winSize.width / 2, winSize.height / 2 - 100))
|
|
armature:setScale(0.6)
|
|
self.currentTag = self.currentTag + 1
|
|
self:addChild(armature, self.currentTag, self.currentTag)
|
|
|
|
local function changeZorder(dt)
|
|
local node = self:getChildByTag(self.currentTag)
|
|
node:setZOrder(math.random(0,1) * 3)
|
|
self.currentTag = (self.currentTag + 1) % 3
|
|
end
|
|
|
|
schedule(self,changeZorder, 1)
|
|
end
|
|
|
|
function TestChangeZorder.create()
|
|
local layer = TestChangeZorder.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
return layer
|
|
end
|
|
|
|
--UNDO callback
|
|
local TestAnimationEvent = class("TestAnimationEvent",ArmatureTestLayer)
|
|
TestAnimationEvent.__index = TestAnimationEvent
|
|
|
|
function TestAnimationEvent.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestAnimationEvent)
|
|
return target
|
|
end
|
|
|
|
function TestAnimationEvent:onEnter()
|
|
local armature = ccs.Armature:create("Cowboy")
|
|
armature:getAnimation():play("Fire")
|
|
armature:setScaleX(-0.24)
|
|
armature:setScaleY(0.24)
|
|
armature:setPosition(cc.p(VisibleRect:left().x + 50, VisibleRect:left().y))
|
|
|
|
local function callback1()
|
|
armature:runAction(cc.ScaleTo:create(0.3, 0.24, 0.24))
|
|
armature:getAnimation():play("FireMax", 10)
|
|
end
|
|
|
|
local function callback2()
|
|
armature:runAction(cc.ScaleTo:create(0.3, -0.24, 0.24))
|
|
armature:getAnimation():play("Fire", 10)
|
|
end
|
|
|
|
local function animationEvent(armatureBack,movementType,movementID)
|
|
local id = movementID
|
|
if movementType == ccs.MovementEventType.LOOP_COMPLETE then
|
|
if id == "Fire" then
|
|
local actionToRight = cc.MoveTo:create(2, cc.p(VisibleRect:right().x - 50, VisibleRect:right().y))
|
|
armatureBack:stopAllActions()
|
|
armatureBack:runAction(cc.Sequence:create(actionToRight,cc.CallFunc:create(callback1)))
|
|
armatureBack:getAnimation():play("Walk")
|
|
elseif id == "FireMax" then
|
|
local actionToLeft = cc.MoveTo:create(2, cc.p(VisibleRect:left().x + 50, VisibleRect:left().y))
|
|
armatureBack:stopAllActions()
|
|
armatureBack:runAction(cc.Sequence:create(actionToLeft, cc.CallFunc:create(callback2)))
|
|
armatureBack:getAnimation():play("Walk")
|
|
end
|
|
end
|
|
end
|
|
|
|
armature:getAnimation():setMovementEventCallFunc(animationEvent)
|
|
|
|
self:addChild(armature)
|
|
end
|
|
|
|
function TestAnimationEvent.create()
|
|
local layer = TestAnimationEvent.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
return layer
|
|
end
|
|
|
|
local TestFrameEvent = class("TestFrameEvent",ArmatureTestLayer)
|
|
TestFrameEvent.__index = TestFrameEvent
|
|
|
|
function TestFrameEvent.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestFrameEvent)
|
|
return target
|
|
end
|
|
|
|
function TestFrameEvent:onEnter()
|
|
local armature = ccs.Armature:create("HeroAnimation")
|
|
armature:getAnimation():play("attack")
|
|
armature:getAnimation():setSpeedScale(0.5)
|
|
armature:setPosition(cc.p(VisibleRect:center().x - 50, VisibleRect:center().y -100))
|
|
|
|
local function onFrameEvent( bone,evt,originFrameIndex,currentFrameIndex)
|
|
if (not self:getActionByTag(frameEventActionTag)) or (not self:getActionByTag(frameEventActionTag):isDone()) then
|
|
self:stopAllActions()
|
|
local action = cc.ShatteredTiles3D:create(0.2, cc.size(16,12), 5, false)
|
|
action:setTag(frameEventActionTag)
|
|
self:runAction(action)
|
|
end
|
|
end
|
|
|
|
armature:getAnimation():setFrameEventCallFunc(onFrameEvent)
|
|
|
|
self:addChild(armature)
|
|
|
|
local function checkAction(dt)
|
|
if self:getNumberOfRunningActions() == 0 and self:getGrid() ~= nil then
|
|
self:setGrid(nil)
|
|
end
|
|
end
|
|
|
|
self:scheduleUpdateWithPriorityLua(checkAction,0)
|
|
|
|
local function onNodeEvent(tag)
|
|
if "exit" == tag then
|
|
self:unscheduleUpdate()
|
|
end
|
|
end
|
|
end
|
|
|
|
function TestFrameEvent.create()
|
|
local layer = TestFrameEvent.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
layer:onEnter()
|
|
end
|
|
return layer
|
|
end
|
|
|
|
local TestParticleDisplay = class("TestParticleDisplay",ArmatureTestLayer)
|
|
TestParticleDisplay.__index = TestParticleDisplay
|
|
TestParticleDisplay.animationID = 0
|
|
TestParticleDisplay.armature = nil
|
|
|
|
function TestParticleDisplay.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestParticleDisplay)
|
|
return target
|
|
end
|
|
|
|
function TestParticleDisplay:onEnter()
|
|
self:setTouchEnabled(true)
|
|
self.animationID = 0
|
|
|
|
self.armature = ccs.Armature:create("robot")
|
|
self.armature:getAnimation():playByIndex(0)
|
|
self.armature:setPosition(VisibleRect:center())
|
|
self.armature:setScale(0.48)
|
|
self:addChild(self.armature)
|
|
|
|
local p1 = cc.ParticleSystemQuad:create("Particles/SmallSun.plist")
|
|
local p2 = cc.ParticleSystemQuad:create("Particles/SmallSun.plist")
|
|
|
|
local bone = ccs.Bone:create("p1")
|
|
bone:addDisplay(p1, 0)
|
|
bone:changeDisplayByIndex(0, true)
|
|
bone:setIgnoreMovementBoneData(true)
|
|
bone:setZOrder(100)
|
|
bone:setScale(1.2)
|
|
self.armature:addBone(bone, "bady-a3")
|
|
|
|
bone = ccs.Bone:create("p2")
|
|
bone:addDisplay(p2, 0)
|
|
bone:changeDisplayByIndex(0, true)
|
|
bone:setIgnoreMovementBoneData(true)
|
|
bone:setZOrder(100)
|
|
bone:setScale(1.2)
|
|
self.armature:addBone(bone, "bady-a30")
|
|
|
|
local function onTouchBegan(x, y)
|
|
self.animationID = (self.animationID + 1) % self.armature:getAnimation():getMovementCount()
|
|
self.armature:getAnimation():playByIndex(self.animationID)
|
|
return false
|
|
end
|
|
|
|
local function onTouch(eventType, x, y)
|
|
if eventType == "began" then
|
|
return onTouchBegan(x,y)
|
|
end
|
|
end
|
|
|
|
self:registerScriptTouchHandler(onTouch)
|
|
end
|
|
|
|
function TestParticleDisplay.create()
|
|
local layer = TestParticleDisplay.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
|
|
return layer
|
|
end
|
|
|
|
local TestUseMutiplePicture = class("TestUseMutiplePicture",ArmatureTestLayer)
|
|
TestUseMutiplePicture.__index = TestUseMutiplePicture
|
|
TestUseMutiplePicture.displayIndex = 0
|
|
TestUseMutiplePicture.armature = nil
|
|
|
|
function TestUseMutiplePicture.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestUseMutiplePicture)
|
|
return target
|
|
end
|
|
|
|
function TestUseMutiplePicture:onEnter()
|
|
self:setTouchEnabled(true)
|
|
self.displayIndex = 1
|
|
|
|
self.armature = ccs.Armature:create("Knight_f/Knight")
|
|
self.armature:getAnimation():playByIndex(0)
|
|
self.armature:setPosition(cc.p(VisibleRect:left().x + 70, VisibleRect:left().y))
|
|
self.armature:setScale(1.2)
|
|
self:addChild(self.armature)
|
|
|
|
local weapon =
|
|
{
|
|
"weapon_f-sword.png",
|
|
"weapon_f-sword2.png",
|
|
"weapon_f-sword3.png",
|
|
"weapon_f-sword4.png",
|
|
"weapon_f-sword5.png",
|
|
"weapon_f-knife.png",
|
|
"weapon_f-hammer.png",
|
|
}
|
|
|
|
local i = 1
|
|
for i = 1,table.getn(weapon) do
|
|
local skin = ccs.Skin:createWithSpriteFrameName(weapon[i])
|
|
self.armature:getBone("weapon"):addDisplay(skin, i - 1)
|
|
end
|
|
|
|
local function onTouchBegan(x, y)
|
|
self.displayIndex = (self.displayIndex + 1) % (table.getn(weapon) - 1)
|
|
self.armature:getBone("weapon"):changeDisplayByIndex(self.displayIndex, true)
|
|
return false
|
|
end
|
|
|
|
local function onTouch(eventType, x, y)
|
|
if eventType == "began" then
|
|
return onTouchBegan(x,y)
|
|
end
|
|
end
|
|
|
|
self:registerScriptTouchHandler(onTouch)
|
|
end
|
|
|
|
function TestUseMutiplePicture.create()
|
|
local layer = TestUseMutiplePicture.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
|
|
return layer
|
|
end
|
|
|
|
local TestAnchorPoint = class("TestAnchorPoint",ArmatureTestLayer)
|
|
TestAnchorPoint.__index = TestAnchorPoint
|
|
|
|
function TestAnchorPoint.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestAnchorPoint)
|
|
return target
|
|
end
|
|
|
|
function TestAnchorPoint:onEnter()
|
|
local i = 1
|
|
for i = 1 , 5 do
|
|
local armature = ccs.Armature:create("Cowboy")
|
|
armature:getAnimation():playByIndex(0)
|
|
armature:setPosition(VisibleRect:center())
|
|
armature:setScale(0.2)
|
|
self:addChild(armature, 0, i - 1)
|
|
end
|
|
|
|
self:getChildByTag(0):setAnchorPoint(cc.p(0,0))
|
|
self:getChildByTag(1):setAnchorPoint(cc.p(0,1))
|
|
self:getChildByTag(2):setAnchorPoint(cc.p(1,0))
|
|
self:getChildByTag(3):setAnchorPoint(cc.p(1,1))
|
|
self:getChildByTag(4):setAnchorPoint(cc.p(0.5,0.5))
|
|
end
|
|
|
|
function TestAnchorPoint.create()
|
|
local layer = TestAnchorPoint.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
|
|
return layer
|
|
end
|
|
|
|
local TestArmatureNesting = class("TestArmatureNesting",ArmatureTestLayer)
|
|
TestArmatureNesting.__index = TestArmatureNesting
|
|
TestArmatureNesting.weaponIndex = 0
|
|
TestArmatureNesting.armature = nil
|
|
|
|
function TestArmatureNesting.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestArmatureNesting)
|
|
return target
|
|
end
|
|
|
|
function TestArmatureNesting:onEnter()
|
|
self:setTouchEnabled(true)
|
|
self.weaponIndex = 0
|
|
|
|
self.armature = ccs.Armature:create("cyborg")
|
|
self.armature:getAnimation():playByIndex(1)
|
|
self.armature:setPosition(VisibleRect:center())
|
|
self.armature:setScale(1.2)
|
|
self.armature:getAnimation():setSpeedScale(0.4)
|
|
self:addChild(self.armature)
|
|
|
|
local function onTouchBegan(x, y)
|
|
self.weaponIndex = (self.weaponIndex + 1) % 4
|
|
self.armature:getBone("armInside"):getChildArmature():getAnimation():playByIndex(self.weaponIndex)
|
|
self.armature:getBone("armOutside"):getChildArmature():getAnimation():playByIndex(self.weaponIndex)
|
|
return false
|
|
end
|
|
|
|
local function onTouch(eventType, x, y)
|
|
if eventType == "began" then
|
|
return onTouchBegan(x,y)
|
|
end
|
|
end
|
|
|
|
self:registerScriptTouchHandler(onTouch)
|
|
end
|
|
|
|
function TestArmatureNesting.create()
|
|
local layer = TestArmatureNesting.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:onEnter()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
end
|
|
|
|
return layer
|
|
end
|
|
|
|
local Hero = class("Hero")
|
|
Hero.__index = Hero
|
|
Hero._mount = nil
|
|
Hero._layer = nil
|
|
|
|
function Hero.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, Hero)
|
|
return target
|
|
end
|
|
|
|
function Hero:changeMount(armature)
|
|
if nil == armature then
|
|
--note
|
|
self:retain()
|
|
|
|
self:playByIndex(0)
|
|
self._mount:getBone("hero"):removeDisplay(0)
|
|
self._mount:stopAllActions()
|
|
self:setPosition(self._mount:getPosition())
|
|
self._layer:addChild(self)
|
|
self:release()
|
|
self._mount = armature
|
|
else
|
|
self._mount = armature
|
|
self:retain()
|
|
self:removeFromParentAndCleanup(false)
|
|
local bone = armature:getBone("hero")
|
|
bone:addDisplay(self, 0)
|
|
bone:changeDisplayByIndex(0, true)
|
|
bone:setIgnoreMovementBoneData(true)
|
|
self:setPosition(cc.p(0,0))
|
|
self:playByIndex(1)
|
|
self:setScale(1)
|
|
self:release()
|
|
end
|
|
end
|
|
|
|
function Hero:playByIndex(index)
|
|
self:getAnimation():playByIndex(index)
|
|
if nil ~= self._mount then
|
|
self._mount:getAnimation():playByIndex(index)
|
|
end
|
|
end
|
|
|
|
function Hero.create(name)
|
|
local hero = Hero.extend(ccs.Armature:create(name))
|
|
return hero
|
|
end
|
|
|
|
|
|
|
|
local TestArmatureNesting2 = class("TestArmatureNesting",ArmatureTestLayer)
|
|
TestArmatureNesting2.__index = TestArmatureNesting2
|
|
TestArmatureNesting2._hero = nil
|
|
TestArmatureNesting2._horse = nil
|
|
TestArmatureNesting2._horse2 = nil
|
|
TestArmatureNesting2._bear = nil
|
|
TestArmatureNesting2._touchedMenu = nil
|
|
|
|
function TestArmatureNesting2.extend(target)
|
|
local t = tolua.getpeer(target)
|
|
if not t then
|
|
t = {}
|
|
tolua.setpeer(target, t)
|
|
end
|
|
setmetatable(t, TestArmatureNesting2)
|
|
return target
|
|
end
|
|
|
|
function TestArmatureNesting2:onEnter()
|
|
|
|
self:setTouchEnabled(true)
|
|
|
|
local function onTouchesEnded(tableArray)
|
|
local x,y = tableArray[1],tableArray[2]
|
|
local armature = self._hero._mount and self._hero._mount or self._hero
|
|
if x < armature:getPositionX() then
|
|
armature:setScaleX(-1)
|
|
else
|
|
armature:setScaleX(1)
|
|
end
|
|
|
|
local move = cc.MoveTo:create(2, cc.p(x,y))
|
|
armature:stopAllActions()
|
|
armature:runAction(cc.Sequence:create(move))
|
|
end
|
|
|
|
local function onTouch(eventType, tableArray)
|
|
if eventType == "ended" then
|
|
return onTouchesEnded(tableArray)
|
|
end
|
|
end
|
|
|
|
self:registerScriptTouchHandler(onTouch,true)
|
|
|
|
local function changeMountCallback(sender)
|
|
self._hero:stopAllActions()
|
|
|
|
if nil ~= self._hero._mount then
|
|
self._hero:changeMount(nil)
|
|
else
|
|
if cc.pGetDistance(cc.p(self._hero:getPosition()),cc.p(self._horse:getPosition())) < 20 then
|
|
self._hero:changeMount(self._horse)
|
|
elseif cc.pGetDistance(cc.p(self._hero:getPosition()),cc.p(self._horse2:getPosition())) < 20 then
|
|
self._hero:changeMount(self._horse2)
|
|
elseif cc.pGetDistance(cc.p(self._hero:getPosition()),cc.p(self._bear:getPosition())) < 30 then
|
|
self._hero:changeMount(self._bear)
|
|
end
|
|
end
|
|
end
|
|
|
|
self._touchedMenu = false
|
|
local label = cc.LabelTTF:create("Change Mount", "Arial", 20)
|
|
local menuItem = cc.MenuItemLabel:create(label)
|
|
menuItem:registerScriptTapHandler(changeMountCallback)
|
|
local menu = cc.Menu:create(menuItem)
|
|
menu:setPosition(cc.p(0,0))
|
|
menuItem:setPosition( cc.p( VisibleRect:right().x - 67, VisibleRect:bottom().y + 50) )
|
|
self:addChild(menu, 2)
|
|
|
|
self._hero = Hero.create("hero")
|
|
self._hero._layer = self
|
|
self._hero:playByIndex(0)
|
|
self._hero:setPosition(cc.p(VisibleRect:left().x + 20, VisibleRect:left().y))
|
|
self:addChild(self._hero)
|
|
|
|
self._horse = self:createMount("horse", VisibleRect:center())
|
|
|
|
self._horse2 = self:createMount("horse", cc.p(120, 200))
|
|
self._horse2:setOpacity(200)
|
|
|
|
self._bear = self:createMount("bear", cc.p(300,70))
|
|
end
|
|
|
|
function TestArmatureNesting2:createMount(name,pt)
|
|
local armature = ccs.Armature:create(name)
|
|
armature:getAnimation():playByIndex(0)
|
|
armature:setPosition(pt)
|
|
self:addChild(armature)
|
|
return armature
|
|
end
|
|
|
|
function TestArmatureNesting2.create()
|
|
local layer = TestArmatureNesting2.extend(cc.Layer:create())
|
|
|
|
if nil ~= layer then
|
|
layer:createMenu()
|
|
layer:createToExtensionMenu()
|
|
layer:creatTitleAndSubTitle(armatureSceneIdx)
|
|
layer:onEnter()
|
|
end
|
|
|
|
return layer
|
|
end
|
|
|
|
|
|
local armatureSceneArr =
|
|
{
|
|
TestAsynchronousLoading.create,
|
|
TestDirectLoading.create,
|
|
TestCSWithSkeleton.create,
|
|
TestDragonBones20.create,
|
|
TestPerformance.create,
|
|
TestPerformanceBatchNode.create,
|
|
TestChangeZorder.create,
|
|
TestAnimationEvent.create,
|
|
TestFrameEvent.create,
|
|
TestParticleDisplay.create,
|
|
TestUseMutiplePicture.create,
|
|
TestAnchorPoint.create,
|
|
TestArmatureNesting.create,
|
|
TestArmatureNesting2.create,
|
|
}
|
|
|
|
function nextArmatureTest()
|
|
armatureSceneIdx = armatureSceneIdx + 1
|
|
armatureSceneIdx = armatureSceneIdx % table.getn(armatureSceneArr)
|
|
if 0 == armatureSceneIdx then
|
|
armatureSceneIdx = table.getn(armatureSceneArr)
|
|
end
|
|
return armatureSceneArr[armatureSceneIdx]()
|
|
end
|
|
|
|
function backArmatureTest()
|
|
armatureSceneIdx = armatureSceneIdx - 1
|
|
if armatureSceneIdx <= 0 then
|
|
armatureSceneIdx = armatureSceneIdx + table.getn(armatureSceneArr)
|
|
end
|
|
|
|
return armatureSceneArr[armatureSceneIdx]()
|
|
end
|
|
|
|
function restartArmatureTest()
|
|
return armatureSceneArr[armatureSceneIdx]()
|
|
end
|
|
|
|
local function addFileInfo()
|
|
|
|
end
|
|
|
|
function runArmatureTestScene()
|
|
local scene = ArmatureTestScene.create()
|
|
scene:runThisTest()
|
|
cc.Director:getInstance():replaceScene(scene)
|
|
end
|