SpriteKit provides everything you'll need to build 2D games with high-performance graphics and engaging gameplay. Check out new APIs for managing a virtual camera and delivering spatial audio. See the all-new timeline-based Actions editor built right into Xcode, and learn about deep integration with Metal, SceneKit, GameplayKit, and more.
TIM ORIOL: Hi and welcome to What's New in SpriteKit.
We have a lot of great new features and enhancements
to tell you about today.
I know that there's a few people in the audience that are new
to SpriteKit and I just wanted to take a few minutes first
to recap what we're all about.
So SpriteKit is Apple's 2D frame work for games and graphics.
And we provide you tools like integrated physics,
particle simulations, actions
and animations and, of course, Sprite.
We set out to design SpriteKit to be both powerful
but also really, really easy to use.
We wanted someone who's maybe even has never written a game
before to be able to come to our platform, pick up SpriteKit
and be up and running in no time.
We really wanted to deliver something that lets you focus
on what you do best and that is making great games.
We designed SpriteKit to work across iPhone iPad and Mac
and in addition to this media you can deliver your app
to multiple platforms, it also means that you can prototype
and test all of your SpriteKit games directly
on the Mac before you even put it on a device.
and with SpriteKit the framework is really only half the story.
Since the beginning we spent a lot of effort on our tools
and we have continued to invest in that year after year
to allow you to edit your particle affects as well
as entire scenes and new this year actions and animations
as well, directly inside
of Xcode before you even write a line of code.
So now lets talk about the new additions to the framework.
The first one was requested by developers quite a bit
and this has to do with the Viewport and the Viewport is
when we're talking about which portion of your scene is visible
in a SpriteKit view at any time.
The way this works now is if you want to move your camera,
you would have to realign every piece of geometry
within your game, or if you wanted to follow along one
of your hero characters through your game world,
you need to do those calculations.
Now this works, but it is not as intuitive as we'd like
and if you're also running physics simulations
on those game entities while you're changing their actual
position, you can get artifacts from that.
We thought we could do something a little bit better.
We would like to introduce SKCameraNode.
With the CameraNode we allow you to simply specify which portion
of your view is going to be visible and the camera does this
by representing the center
of the visible content in your scene.
So now you can move the CameraNode through your scene
with the same logic that you move all
of your other game entities through your scene.
We have a property on SKScene that will allow you
to select the camera you'd like to use so these scenes,
you can have multiple cameras throughout your scene
and you can select the active one via property.
If you leave the property as its default value of nil,
we get the same experiences you have today
and all the SpriteKit rendering is as it was.
But the best feature of all
about SKCameraNode is that it's a node.
And this means that you get access to all the great features
in SpriteKit for nodes.
You have access to our actions library
so you can now run actions on the camera.
You have access to our constraint system
so you can apply constraints to the camera.
You can make it align with game entities,
you can make it always stay within a certain distance
of objects within your game.
Beyond just moving the camera you now have access to rotation
and scale via those properties on the node.
So for example, in a game like this, I may start the camera off
to the side, and I might apply a few move animations
to reveal the bad guys in my scene before centering
on the hero character.
And then I can apply a scale action if I want
to zoom the camera in or out.
I can even use our follow path action if I want
to have the camera follow a Bezier [Unintelligable]
and if I really want to make my user sick I can spin the camera
around and throw it around the scene.
So you really have full control over what part
of your game is visible now in SpriteKit
and I think this is going
to be a great addition to your toolkit.
TIM ORIOL: In addition to camera,
we've also done work with audio.
We're adding an SKAudioNode to allow you to add positional,
environmental sound right in your SpriteKit game.
TIM ORIOL: We're leveraging Apple's powerful AV audio engine
framework that we introduced last year.
If you're not familiar with this,
it lets you specify your tone soundscape
and play sound emitters within that environment
and it will play them back in correspondence
to a listener position that you specify.
In SpriteKit we're going to do all the wiring up for you.
All you have to do is specify the sound asset that you want
to play back via file name or URL
and we'll use the AudioNodes position in your scene,
along with the listener point that you specify,
to wire up the whole audiograph and give you really easy access
to immersive, positional audio in your game.
If you want to dig a little deeper and get your hands-on,
you can access the underlying AVAudioNode as well
from a property on the node and go to town
and set any settings you want on there.
To demonstrate the types of affects you'd be able to add
to your SpriteKit game using this new technology,
I'm going to have an example scene here
where I've got my goblin.
I'm going to make him my listener,
so I set my listener position there.
I have added a fireball to my scene.
This is going to be my sound source,
so I've added it as an SKAudioNode.
When I play this back listen how the audio affects
as the fireball moves around the scene.
You should notice it become richer, more centered and louder
as it gets close to our listener and more one-sided and distant
as it gets to the side of the scene.
Let's take a listen.
TIM ORIOL: So that's pretty cool, right?
TIM ORIOL: Beyond the additional set up I have
to do nothing to update these effects as they move
around the game world, they're completely tied
to the game logic that's driving my game already.
Also this year we focused on referencing and instancing.
We know you spend a lot of time designing high-quality content
and animations for your games and we want you to let you reuse
that content anywhere where you would like to.
We're allowing you to create serialized data files
for your nodes and your actions and then add them
as a reference instead of just loading them into your scene.
This way, every time you make a change to the source asset
that is automatically reflected in the content of your game.
How do I do this for nodes?
For nodes I design part of my scene,
maybe a background element, or some scenery in our editor
with an Xcode and then I can just drag-and-drop those files
into my main scene in Xcode
and it will automatically create a reference
and it is all set up for you.
If you want to do this in code you can as well,
you can manually construct an SKReferenceNode,
assign it a file name or even a URL and when
that content is first presented in your game we'll load
in that content based on the latest version
of the file that's in your bundle.
We can also do the same thing for actions.
With actions go check out our great new action editor
and beyond creating and composing the actions
in Xcode you can give all them names.
These names are the key to using them in your game.
We have added a selector to SKAction called actionNamed.
This works just like it does for SKTexture and textureNamed.
You pass in the name of the action you want.
We're going to automatically look inside of your app bundle
in all of the serialized action files, find the one
with the appropriate name and then surface
that to the application.
Please use this multiple times within your game.
We have done all the work on our side to take care of caching
and we guarantee that the same action will never be loaded
from disk more than once in your game.
Sometimes you have an action that you would want to use more
than once but it will play back faster or slower.
We have added an additional selector that will allow you
to override the duration of the action.
This is a smart scaling of the time,
so even if you have a nested action with nested groups
and sequences, it will dynamically scale it
to the new duration so that each component is the same fractional
size to the original duration.
Those are our utilities for reusable components
that you can use in the same scene in the same game
or across multiple games.
We have also added a couple new actions to the framework.
So now that we have these positional AudioNodes it would
be nice to be able to control the playback via actions.
We have added play, pause, play back rate as well as actions
for volume and stereo panning.
We also are doing a little bit more with frame animations.
We have always had frame-based animations
in SpriteKit via the animate with textures action
but last year we introduced lighting to SpriteKit.
With lighting you're able to either automatically generate
or supply your own normal textures for sprites
within your scene and then we can light them dynamically
at run time by moving the light nodes around your scene.
This works great for elements that don't change,
but if I have a frame-based animation like this guy here,
we want those highlights and shadows to line
up with the current position.
We don't want a specular highlight where the leg used
to be, so we're adding an animate
with normal textures action as well
so you can use this alongside the normal animation
and get both of them in sync for every frame.
If I run that on our character and add lighting to the scene,
you can see that all the highlights, shadows are kept
in sync with every frame, no matter how my character runs.
TIM ORIOL: So those are additional features we added
to the framework, we've also done a lot of work
to integrate well with the rest of the system and take advantage
of new hardware and frameworks
that have been added to our platform.
First I want to talk about Metal.
We're making SpriteKit and we're moving it directly on top
of Metal on iOS and Mac and it will be Metal backed
on any device that supports it and any device
that doesn't will automatically fall back to OpenGL.
This means that you get lower CPU utilization,
it means you get better draw call performance
and better battery life with zero action required
to you as a developer.
TIM ORIOL: We're going
to upgrade all SpriteKit apps automatically, you don't have
to recompile or resubmit.
If it supports Metal we're going to run it.
For those of you that are wondering
about your custom shaders, we've taken care of that as well.
If you have a custom shader in your game, we're supporting
to upgrade almost all of those to a Metal variant
and that will run just fine on Metal devices as well.
TIM ORIOL: Next up is Swift.
We have gone through the entire API
and we've applied nullability qualifiers
and we've adopted Objective-C generics on any array types
that are used for paramaters or return types
and this will allow you to access the full power
of SpriteKit from Swift without any hassle.
This will also give you enhanced type safety
within your application whether you're using Swift
or Objective C.
Now I would like to talk a bit about SceneKit.
With SceneKit in case you don't know, we allow you
to render SpriteKit content in SceneKit
and SceneKit content in SpriteKit.
This year we're allowing you to go a little bit further
and use all the SpriteKit transitions that you know
and love directly in your SceneKits games
and you don't even have to be using SpriteKit to do it.
You can use transitions like the doorway one here, clip,
or even the core image based transition effects
for your SceneKit game and that all works fine.
SceneKit has also done work
to support Metal backed context for this release.
We take care of automatically matching that.
If you have a SceneKit game that's running Metal backed
and you have SpriteKit content
in there we'll render using Metal.
If you have a SceneKit game that's GL backed
and you have SpriteKit in there, we'll render using OpenGL.
You never have additional overhead for us
to translate between the two APIs.
This year we've also announced a brand-new framework
This is really cool, it provides you the building blocks you need
to build your game Logic like Entity/Component systems as well
as state machines and also provides great utilities
like AI opponents and deterministic random sources.
One of my favorite ones here, is its ability
to provide a pathfinding solution for your game.
I think a lot of SpriteKit developers are going
to be interested in this.
The way Pathfinding works
in GameplayKit is you would specify a navigation graph
of the traversable areas within your game world.
Then you would make connections between those nodes
and give them an associated cost.
Once you have this graph,
GameplayKit will then calculate the optimal path
between any two points in the graph.
How would I set one of these up for a game?
If I have this SpriteKit game here, and I've got my hero
in the lower corner, I have --
maybe I want him to move to a certain destination.
I'll then specify a couple of obstacles in my scene
that are non-traversable regions.
Giving just this to GameplayKit and a buffer radius
around my character that I want it to pass through,
GameplayKit will take that buffer radius into account,
automatically expand all of the obstacles so we never get
within that radius of any of the obstacles
and then create the valid connections
and only the valid connections within that graph,
so you're never traversing through the obstacles.
You can then use this to perform any pathfinding operations
within your game.
It is not specific to SpriteKit,
so you can use GameplayKits features with SceneKit,
SpriteKit, OpenGL, Metal, any kind of game scenario you want.
If you are doing it with SpriteKit we made it easier.
You don't even need to create the obstacles.
You can create the obstacles directly from a sprite's bounds,
you can create the obstacles from a physics body
that you may have set on the sprite or even
from the alpha transparency information
in the texture that's associated with that sprite in your game.
This gives you really easy access to harness the power
of GameplayKits pathfinding from your SpriteKit app.
TIM ORIOL: As I said before,
the framework really is only half the story.
We have a number of really cool enhancements
to our tools this year and I'd like to turn it over to Norman
to tell you all about it.
NORMAN WANG: Thanks, Tim.
Building games is a complex and iteration process.
Various parts of the game needs to be iterated like game play,
making sure a game is fun, animation,
making sure the character movement is fluid,
or art assets, making sure that the pixels
on the screen really pop.
In addition to the iteration problem you also,
as a game developer, face the scalability problem.
How do I replicate a current design across multiple levels.
At Apple when we first set
out to design SpriteKit we wanted not only to provide you
with a high performance and easy to use API but also the tools
to help you with scalability and iteration so that we can focus
on just building the game.
Ever since day one release
of the SpriteKit framework we have created
and continuously added multiple tools as part of Xcode.
Let me give you a quick tour of what are the tools available
for you as a SpriteKit user.
The first thing I want to talk about is texture atlas.
One of the main benefits
of using texture atlas is performance improvement.
SpriteKit uses texture atlas to minimize the amount
of draw calls sent out to the GPU to optimize the efficiency.
We don't want to force our users to adopt a manual process
by manually building these texture atlas, [unintelligible]
and every time when the source acts as a change,
this manual process will have to be kickedoff again.
Therefore it builds an automatic texture atlas generator right
inside the Xcode.
To build one of these atlas is as simple
as dragging a folder into your workspace.
And we'll do something like this automatically at build time.
Each of the source images is automatically going
through a complex post processing stage.
For example, we trim the alpha transparent pixels for the image
that doesn't really contribute anything to the screen.
We rotate the image up to 90Â° if they result a tighter fit
or result a smaller texture atlas.
For each of the source images, we also introspect each
of the edges on the image
and if they're fully opaque we'll perform extrusion
on the edge.
So when you tile these images on your scene,
you will not see any seams,
that's automatic texture atlas generation.
This year we have made that even better.
Now you can generate texture atlas instead of asset catalog.
There are two major benefits
of generating texture atlas using asset catalog.
Number one, you have precise control
of the targeted device resolutions matching
with your image names.
You have freedom to not follow the post-fix in your image names
like add 2X or add 2X to the iPhone,
all of that can be designed right in the UI.
The second benefit is we support [unintelligible] now inside the
Each group of the target resolution are going
to be generated by their device independent textures.
When the user goes to the App Store
and downloads your SpriteKit enabled games,
only the texture atlas that's relevant to his
or her device will get downloaded,
not only does this minimize the amount of bandwidth as well
as install time for the app to get on the users phone
but also minimizes the amount of storage overhead on the app.
In addition, texture atlas supports on-demand resources.
On-demand resources is a brand-new API that enables you
to stream in art assets over the network in the background
when the game is running.
SpriteKit builds that support right in.
These assets are identified by tags.
Here, for example, my background elements in Xcode
in Inspector I can specify what are the tags associated with it.
I'm calling it level 1 and background.
These are the tags, you can use either of these tags
to retrieve this asset and start background streaming
when your application requests it.
Particle effects really help you set up the game right.
We provide SKEmitterNode as a very powerful and flexible APIs
in the framework for you to use.
The downside of being powerful and flexible is
that it also comes with 49 properties for you to set.
To set a combination of permutations
of these 49 properties to match with the look and feel
that you're going after is time consuming.
Therefore we build a particle editor right inside of Xcode
that uses the same SpriteKit rendering engine
that gives you the visual look right inside of your work space
so that you can tweak and change any of these 49 properties
without ever having to write any lines
of code or rebuild your game.
These particles are going to be exported
as a really small data file that can be serialized and deployed
across multiple levels or across multiple projects.
SpriteKit also supports Quick Look.
Here for example I'm trying to learn the new Swift.
I create a brand-new playground and try to play
around with the SpriteKit API using the new Swift
What I'm doing here is I'm creating a bad guy character,
called bad guy, which is a sprite node,
it copied a single texture called the car hood,
and in addition I create two children node that appear
under this bad guy, one has the texture of the roof,
the other one has the texture of the trunk.
What's happening here, SpriteKit will do a partial off-screen
rendering of this subterrain when you try
to introspect the sprite node
and it will provide the result right inside of the playground
for you so that every step along the way when you try
to learn a new language or make changes to the object,
you will see the live changes right inside of the playground.
In addition the Quicklook in SpriteKit also supported
when you debug your applications whether they're in Swift,
Objective-C, whether they are running on iOS devices
or running on Mac OS X.
So here I'm trying to debug an application that I have written,
I trigger a break point,
the target process is actually paused, but we're still able
to wrap the partial screen rendering of the current texture
and show that in the debugger.
So you know exactly what that texture is before I go ahead
and grab it to assign to an SKSpriteNode.
Last year in iOS 8 we announced a visual scene editor
which will allow you to set up a full scene layout without having
to write any lines of code.
Not only you can set up the position, rotation and scale
on each of the available nodes that are in the scene,
but you can also define its physics properties like setting
up a graphic, gravities, mass, frictions,
you can also perform live simulations
of these physics simulations without having
to launch your game or rebuild the application.
SpriteKit will support some advanced rendering techniques
like custom shaders.
Here in my level the waterfall in the background and the fog
on the bottom I actually implement using two
To add the shaders, it is a matter of --
it is as simple as opening up the assist editor,
it automatically shows you the current scene
with the shader that's being rendering
and it will show you the assistant editor
with the shader source code.
Any live changes you make
in the assistant editor will automatically recompile the
shader, open up to OpenGL or Metal and provide you
with a real realtime preview rather than having
to build a game, go through the level,
go through the certain spots and trigger the event
to see whether I'm sending this stream to OpenGL or Metal,
whether it compiles successfully or not.
It saves a lot of iteration time.
This year we have made a lot of enhancements
to the visual scene editor.
The number one requested feature is custom classes.
Now in the level my hero character I can specify its
class is called main character class.
When the scene is de-serialized at runtime,
whether your application is written in Objective-C
or Swift the correct class will be instantiated and created
when the scene is running and loaded on the scene.
In addition we have been very busy adding the support
from day one of the brand-new SKNodes.
Now you can design your scene with the Camera nodes,
position AudioNode and as well
as the ReferenceNode right inside of the editor.
It is really cool to be able to see the camera sending
up the correct scale, the zoom factor as well
as run actions right inside of the scene editor rather
than having to rebuild your game.
You can also set up the position of the SKAudioNode,
move them around and hear the actual sound change to make sure
that your effect is set up correctly on your scene.
Now this year, one of the most exciting features
on the tools front is to have the ability
to design complex actions.
You can design a really complex action
by using the fundamental building blocks
that we've provided as part of SpriteKit action runtime.
It is timeline based, also just like any other editors we have
in Xcode it provides live visualization.
You can use not only to create 2D actions,
you can also create 3D animations
for SceneKit, it's the same editor.
You can also create cinematic animations
which will be the animations saved out as part of scene
when the scene is loaded that automatically gets run
for any node that has action in a scene.
You can also create interactive animations like running cycle
or jump animations, falling off from a ledge
and trigger these animations with one or two lines of code
at different game play scenarios.
Here I have a scene, I designed to move the camera around,
I focus on the main character,
the main character starts animating,
running the walk cycle, and walk
across the scene, that's my opening.
You can do that in less than 5 minutes of your time.
Now another major focus this year on the tools front
for both 2D and 3D is to have the ability
of doing referencing and instancing.
On SpriteKit side with support references on the actions
as well as references on the node which is your art assets
in your scene, these are reusable components
and they are data files that can be shared
across multiple projects,
multiple persons or multiple levels.
To use these reference files,
you don't have to write any code.
To create the reference animation is really easy,
we provide a brand new SK action file template in Xcode 7
and you can a pure animation file,
in there design all your complex animation, give it out a name,
each of these actions can be retrieved with the SKAction,
actionNamed selector to create the right instance
and to add it to your scene.
Any of the referenced actions, automatically will be picked out
and reside in object library.
If you want to have the actions reused
across multiple intro scenes
in different levels it is just a matter of drag-n-drop these
from the object library.
Creating reference nodes is also easier.
It is just as simple as dragging another SKS file
from your work space to your scene.
These references, we automatically
in the editor create SKReferenceNode instances
and set up correct URL for you.
You can also use it, the API to build a custom collection
of the nodes, for example, if I have a bird house that I'm going
to be using as a level prop
across multiple levels I can just build that and have
that instance in multiple levels and any changes
to the original design
of the bird house will automatically get reflected
in each of the instances that use the reference.
Here you can also manually change
and update the reference file in the editor as well.
Next, I like to invite Tyler on stage to give you a quick demo
of these great new features in Xcode.
TYLER CASELLA: Thank you Norman.
As you see, we have a lot of great new additions to SpriteKit
and Xcode 7, and I'd like to show you how they'll integrate
in your development workflow by showing you a quick demo
of creating a simple level, adding a cut scene to it,
and then creating some interactive game play.
Well see here, I just started a game project
and I've started a level within this project.
I've got a player sprite as well as some platforms.
The first thing I want to do is to create the environment in it
by adding a background and some foreground elements.
Previously I would do this directly into the scene
and then create copies for each instance that I needed.
This quickly becomes cumbersome if I need to make changes
because I need to make the change in many different spots.
It is not easy to reuse.
We have addressed that with the ReferenceNode.
So see here in a separate file I've created all
of my elements for our environment.
I've got a nice background with the waterfall as well
as a nice foreground fog effect.
What I can do to reference the contents
of this file is simply drag it into our level.
Now we've automatically created a ReferenceNode
with all those elements.
You will notice even the foreground Z value is preserved
as we add it into our scene.
So go ahead and create a few copies of these to fill
out our level and you'll notice that I'm creating copies
of the ReferenceNode itself
and not the actual individual elements
within our reference scene.
What's great about that is, later on in my project when I,
for example, want to change the background texture
because it doesn't quite match
with the platforms I've got here, I don't have to make
that change on the three instances I have.
Instead I can go to our single source
and make this change only once and that change is echoed to all
of our instances within our level.
TYLER CASELLA: Next I'd
like to create a cut scene within our level.
I'll do that by using our new action editor
that we've introduced.
Previously you could only create actions in code
which is very difficult to visualize so we wanted
to create an editor that was easy to create complex actions
from and give you realtime previews
of what you're creating.
To access the action editor,
you just click the disclosure button here
in the bottom-left corner and you'll see you're presented
with all of the nodes in your scene as well as the timeline
of all of the actions they contain.
We'll see here our player has one action on it,
which is an animate with textures action,
and we've got our idle frames within it.
So now when I click animate,
we'll see that our player is running this animate action
within our scene.
Let's go ahead and make a cut scene within our level,
we're going to make the player run across the level.
To do that, I'll start by filtering
down to just our player interaction editor
and to just the actions within our object library.
We provide you a set of building block actions to use
to create your more complex actions
which is exactly what I'm going to do.
We'll start by adding a move action into our cut scene.
All I have to do is drag it
from the object library into our timeline.
Now for this movement I'll go 850 units in the X direction
and we're going to ease in for more natural motion.
Now when I click animate we'll see
that the player is running that action.
That was a bit quick, so let's change the duration
by just dragging out the action to about 2 seconds.
I'm going to adjust the scale so now when we run,
the movement has a much better velocity.
Now I'm going to also make the player run as he moves
across the screen so I'll add in an animate with textures action.
To define what animation we're going to be playing,
I can just go into the media library and filter
down to our run frames.
I can select them and simply drag them into our action.
Now when we run we'll see that the player plays that animation.
But of course we're only playing it once so we're going
to add a loop so that we can span the whole time
of our movement.
I can create a loop by clicking this loop button here
in the corner and I'm presented
with all the controls for looping.
I can increase the number of iterations, I can decrease
or I can loop indefinitely.
In our case I'm going to only want to loop twice
and then I'll adjust the duration to match our movement.
Now we have the player running across the scene.
Next we've got two gaps within the level
so let's make the player jump over them.
In the action editor we're able to scrub to specific times
within our action so I can scrub to just before we reach the gap
and we'll add another movement action.
We'll snap right to where we're scrubbed.
For this movement we'll move in the Y direction 100 units
and I'll ease out so that we slow down as we get
to the top of our jump.
Then I'll scrub once again towards the middle of our gap
and I'll adjust the duration so that we reach the top
of our jump right there in the center of the gap.
Then I'll copy the first part of our action and simply reverse it
to get our full motion of the jump.
That last step for our jump is I'm going
to create one more animation which is going
to have our jump frames so I'll follow the same process going
to our media library, filter down to our jump frames
and add them to our action
and now we've got the player jumping over that first gap.
Of course we have one more gap so one option I have is
to simply copy these actions I have just added
and displace them, but then we run into the same issue we had
with the background where if I want it make changes to it,
I'm going to have to do it to every instance I have copied.
It very likely I'm going to want to reuse these actions
in different levels
or potentially even a different project.
We've addressed this the same way
with the background allowing you to reference actions.
To do that we've introduced a new file in Xcode
which is the SpriteKit action file.
This is a file where you can place these actions with a name
that you can then reference across scenes,
projects, and in code.
Let's go ahead, make one of those files
by right clicking our selected actions and we're going
to convert it to a reference.
I'm prompted to give it a name, so I'll name it jump
and we can select an action file to put this in,
and in our case we'll create the new file.
So I'll name this file player actions because I'm going
to put all the actions related to the player into this file.
The file is added to our project
and you will see now those actions that we created
for the jump are within our file under the name jump
and within our scene we're simply referencing
So now all the actions that you put
into this file are completely independent of any scene
or project but you're going to often want to edit them
in the context of some scene.
We allow you to set a preview screen that you can assign any
of the actions in your file on any of the nodes in your scene.
So for example, I can preview my jump on any node in this scene
or I can set up my own scene
with different orientations of the player.
For example, I can preview what this jump action will look
like on the left and right orientations of my player.
So now on our level I'll go ahead and scrub back
to our next gap and in our object library we automatically
populate it with all of the actions
that are available to reference.
So that jump action that I just created is automatically
in our object library and I can just drag it in.
So now we've got our finished cut scene.
Let's take a look.
That looks great.
Now I want to show you how you can use these actions
within code itself instead of just a cut scene.
What I want to do is create a named action for every state
that the player can be in and then reference those in code.
I will create a reference, a referencable action called run
that has our animation and I'll do the same for our idle.
I'll go ahead and delete these
because we'll do this interactively now
and you can see in our action file we now have the three
states present within this file.
Now to use these within code all you have
to do is use the new selectors we have introduced,
the action name selectors providing them
with the names we have just created the actions with,
idle, run, and jump.
Now when I run our game you can see the actions
that I have just created are being used in the game itself.
The real power of this comes when you want
to make a change to your actions.
I can go in my action file and let's
for example make the player do a flip when we jump.
I can go in here and I can add a rotate action to the jump,
give it a value of negative 360, ease in and out
and now I run the game without even recompiling our game,
we can see the changes
that I have made are now applied to our player.
TYLER CASELLA: So now the level looks pretty good
so the last thing I want
to do is create a nice cinematic opening
to really introduce the player to the level.
I can do that by creating an SKCameraNode and into our scene.
The camera node let's us define a Viewport within it
and we can go ahead and assign our scene
to use the camera I've just added.
For our cinematic opening I'm going to start us off
in the corner here and I'll have the camera zoomed in.
I'm going to zoom in on the fog over here.
What's great is, because it is just an SKNode I can apply
actions to the camera.
I'll filter down to just our camera
and then I'll add a move 2 action.
What I'm going to do for our cinematic opening is pan the
camera over to the center of our level
and zoom out at the same time.
For our move 2 I'll use this platforms X value as our center,
507, and I'll also want to center it in the Y
which is 384 units and we're going
to want this to ease in and out.
I'm going to move our action to start about half a second
after we begin our scene and I'm going
to have it take three seconds to pan over.
I'll also add a scale 2 action and give it a half second offset
from our move and have it end at the same time as our movement.
Now within that short amount
of time we have created the cinematic opening,
and we have finished our level,
so let's take a look at how it looks.
So that's just a taste of what you're able to do
with SpriteKit and Xcode 7 now.
TYLER CASELLA: And with that, I would like to hand it off back
to Tim to summarize for you.
TIM ORIOL: Thanks, Tyler.
That is really, really cool stuff.
I think as you all can see,
it is going to be an extremely exciting year
for SpriteKit developers.
We've added the AudioNode, we've added the CameraNode,
we have reference actions and nodes,
we have a brand-new timeline based action editor built right
We have integrated our texture atlases with the Asset Catalog
to give you access to new features
like On-Demand Resources and app thinning
and we have also made SpriteKit Metal backed on every device
that supports it and provides you easy access
to the new GamePlayKit framework.
If you need any more information, please check
out our great developer site or for general inquiries,
contact our graphics evangelist Allan Schaffer, there's a couple
of related sessions if you want to find out more
about GamePlayKit or SceneKit.
We also have a few labs,
the first of which is the SpriteKit lab
which is starting right now.
So, feel free to follow us downstairs and we'd be happy
to answer any questions you may have.
Thank you very much.
Please enjoy your conference.
Looking for something specific? Enter a topic above and jump straight to the good stuff.
An error occurred when submitting your query. Please check your Internet connection and try again.