Rozhraní API her pro iOS v Xamarin. iOSiOS Gaming APIs in Xamarin.iOS

Tento článek popisuje nová herní vylepšení poskytovaná iOS 9, která se dají použít ke zlepšení grafických a zvukových funkcí her Xamarin. iOS.This article covers the new gaming enhancements provided by iOS 9 that can be used to improve your Xamarin.iOS game's graphics and audio features.

Společnost Apple provedla několik technologických vylepšení herních rozhraní API v iOS 9, které usnadňují implementaci herních grafik a zvuku v aplikaci Xamarin. iOS.Apple has made several technological improvements to the gaming APIs in iOS 9 that make it easier to implement game graphics and audio in a Xamarin.iOS app. Mezi ně patří jednoduchost vývoje prostřednictvím špičkových architektur a využití síly GPU zařízení s iOS pro lepší rychlost a grafické schopnosti.These include both ease of development through high-level frameworks and harnessing the power of the iOS device's GPU for improved speed and graphic abilities.

Příklad spouštěného hejna aplikaceAn example of an app running flocking

Patří mezi ně GameplayKit, ReplayKit, model I/O, MetalKit a shadery pro výkon kovů společně s novými, vylepšenými funkcemi kovů, SceneKit a SpriteKit.This includes GameplayKit, ReplayKit, Model I/O, MetalKit and Metal Performance Shaders along with new, enhanced features of Metal, SceneKit and SpriteKit.

Tento článek přináší všechny způsoby, jak vylepšit hru Xamarin. iOS s novými vylepšeními her pro iOS 9:This article will introduce all of the ways to improve your Xamarin.iOS game with iOS 9's new gaming enhancements:

Představujeme GameplayKitIntroducing GameplayKit

Nová GameplayKit architektura společnosti Apple poskytuje sadu technologií, které usnadňují vytváření her pro zařízení se systémem iOS pomocí omezení množství opakujícího se běžného kódu, který je nezbytný k implementaci.Apple's new GameplayKit framework provides a set of technologies that makes it easy to create games for iOS devices by reducing the amount of repetitive, common code required for implementation. GameplayKit poskytuje nástroje pro vývoj herních prostředků, které se dají snadno kombinovat s grafickým strojem (jako je SceneKit nebo SpriteKit), aby se mohla rychle doručovat dokončená hra.GameplayKit provides tools for developing the game mechanics that can then be easily combined with a graphic engine (such as SceneKit or SpriteKit) to quickly deliver a completed game.

GameplayKit zahrnuje několik běžných algoritmů hry pro hraní her, jako například:GameplayKit includes several, common, game play algorithms such as:

  • Na základě chování, simulace agenta, která umožňuje definovat přesuny a cíle, které bude AI automaticky sledovat.A behavior based, agent simulation that allows you to define movements and goals that the AI will automatically pursue.
  • Minmax umělá logika pro hraní her na báziA minmax artificial intelligence for turn-based game play.
  • Systém pravidel pro herní logiku řízenou daty s přibližnými důvody pro zajištění emergentho chování.A rule system for data-driven game logic with fuzzy reasoning to provide emergent behavior.

Kromě toho GameplayKit přebírá přístup k vývoji her pomocí modulární architektury, která poskytuje následující funkce:Additionally, GameplayKit takes a building block approach to game development by using a modular architecture that provides the following features:

  • Stavový počítač pro zpracování složitých systémů založených na kódu při hraní her.State machine for handling complex, procedural code based systems in game play.
  • Nástroje pro poskytování náhodného hraní her a nepředvídatelnéosti, aniž by došlo k potížím s laděním.Tools for providing randomized game play and unpredictability without causing debugging issues.
  • Opakovaně použitelná architektura založená na komponentách.A reusable, componentized entity based architecture.

Další informace o GameplayKit najdete v tématu Příručka programování GameplayKit společnosti Apple a referenční dokumentace k rozhraní GameplayKit.To learn more about GameplayKit, please see Apple's Gameplaykit Programming Guide and GameplayKit Framework Reference.

Příklady GameplayKitGameplayKit Examples

Pojďme se podívat na implementaci některých jednoduchých herních ovladačů v aplikaci Xamarin. iOS pomocí hry hra Play.Let's take a quick look at implementing some simple game play mechanics in a Xamarin.iOS app using game play kit.

PathfindingPathfinding

Pathfinding je schopnost hry AI ve hře najít svůj způsob, jak se na hrací desce pohybovat.Pathfinding is the ability for an AI element of a game to find its way around the game board. Například 2D Enemy vyhledá svůj způsob prostřednictvím bludiště nebo trojrozměrného znaku prostřednictvím první osoby-Shooter světa.For example, an 2D enemy finding its way through a maze or a 3D character through a first-person-shooter world terrain.

Vezměte v úvahu následující mapu:Consider the following map:

Příklad mapy pathfindingAn example pathfinding map

Použití pathfinding tohoto kódu v jazyce C# může na mapě najít způsob:Using pathfinding this C# code can find a way through the map:

var a = GKGraphNode2D.FromPoint (new Vector2 (0, 5));
var b = GKGraphNode2D.FromPoint (new Vector2 (3, 0));
var c = GKGraphNode2D.FromPoint (new Vector2 (2, 6));
var d = GKGraphNode2D.FromPoint (new Vector2 (4, 6));
var e = GKGraphNode2D.FromPoint (new Vector2 (6, 5));
var f = GKGraphNode2D.FromPoint (new Vector2 (6, 0));

a.AddConnections (new [] { b, c }, false);
b.AddConnections (new [] { e, f }, false);
c.AddConnections (new [] { d }, false);
d.AddConnections (new [] { e, f }, false);

var graph = GKGraph.FromNodes(new [] { a, b, c, d, e, f });

var a2e = graph.FindPath (a, e); // [ a, c, d, e ]
var a2f = graph.FindPath (a, f); // [ a, b, f ]

Console.WriteLine(String.Join ("->", (object[]) a2e));
Console.WriteLine(String.Join ("->", (object[]) a2f));

Klasický systém expertůClassical Expert System

Následující fragment kódu jazyka C# ukazuje, jak lze GameplayKit použít k implementaci klasického odborníka na systém:The following snippet of C# code shows how GameplayKit can be used to implement a classical expert system:

string output = "";
bool reset = false;
int input = 15;

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    /*
    If reset is true, clear the output and set reset to false
    */
    var clearRule = GKRule.FromPredicate ((rules) => reset, rules => {
        output = "";
        reset = false;
    });
    clearRule.Salience = 1;

    var fizzRule = GKRule.FromPredicate (mod (3), rules => {
        output += "fizz";
    });
    fizzRule.Salience = 2;

    var buzzRule = GKRule.FromPredicate (mod (5), rules => {
        output += "buzz";
    });
    buzzRule.Salience = 2;

    /*
    This *always* evaluates to true, but is higher Salience, so evaluates after lower-salience items
    (which is counter-intuitive). Print the output, and reset (thus triggering "ResetRule" next time)
    */
    var outputRule = GKRule.FromPredicate (rules => true, rules => {
        System.Console.WriteLine(output == "" ? input.ToString() : output);
        reset = true;
    });
    outputRule.Salience = 3;

    var rs = new GKRuleSystem ();
    rs.AddRules (new [] {
        clearRule,
        fizzRule,
        buzzRule,
        outputRule
    });

    for (input = 1; input < 16; input++) {
        rs.Evaluate ();
        rs.Reset ();
    }
}

protected Func<GKRuleSystem, bool> mod(int m)
{
    Func<GKRuleSystem,bool> partiallyApplied = (rs) => input % m == 0;
    return partiallyApplied;
}

V závislosti na dané sadě pravidel ( GKRule ) a známé sadě vstupů vytvoří expertský systém ( GKRuleSystem ) předvídatelný výstup ( fizzbuzz pro náš příklad výše).Based on a given set of rules (GKRule) and a known set of inputs, the expert system (GKRuleSystem) will create predictable output (fizzbuzz for our example above).

HejnumFlocking

Hejna umožňuje, aby se skupina herních jednotek řízených AI chovala jako hejno, kde skupina reaguje na přesuny a akce entity potenciálního zákazníka, jako je hejno ptáků v letu nebo ve škole ryby.Flocking allows a group of AI controlled game entities to behave as a flock, where the group responds to the movements and actions of a lead entity like a flock of birds in flight or a school of fish swimming.

Následující fragment kódu jazyka C# implementuje chování při hejnu pomocí GameplayKit a SpriteKit pro zobrazení grafiky:The following snippet of C# code implements flocking behavior using GameplayKit and SpriteKit for the graphics display:

using System;
using SpriteKit;
using CoreGraphics;
using UIKit;
using GameplayKit;
using Foundation;
using System.Collections.Generic;
using System.Linq;
using OpenTK;

namespace FieldBehaviorExplorer
{
    public static class FlockRandom
    {
        private static GKARC4RandomSource rand = new GKARC4RandomSource ();

        static FlockRandom ()
        {
            rand.DropValues (769);
        }

        public static float NextUniform ()
        {
            return rand.GetNextUniform ();
        }
    }

    public class FlockingScene : SKScene
    {
        List<Boid> boids = new List<Boid> ();
        GKComponentSystem componentSystem;
        GKAgent2D trackingAgent; //Tracks finger on screen
        double lastUpdateTime = Double.NaN;
        //Hold on to behavior so it doesn't get GC'ed
        static GKBehavior flockingBehavior;
        static GKGoal seekGoal;

        public FlockingScene (CGSize size) : base (size)
        {
            AddRandomBoids (20);

            var scale = 0.4f;
            //Flocking system
            componentSystem = new GKComponentSystem (typeof(GKAgent2D));
            var behavior = DefineFlockingBehavior (boids.Select (boid => boid.Agent).ToArray<GKAgent2D>(), scale);
            boids.ForEach (boid => {
                boid.Agent.Behavior = behavior;
                componentSystem.AddComponent(boid.Agent);
            });

            trackingAgent = new GKAgent2D ();
            trackingAgent.Position = new Vector2 ((float) size.Width / 2.0f, (float) size.Height / 2.0f);
            seekGoal = GKGoal.GetGoalToSeekAgent (trackingAgent);
        }

        public override void TouchesBegan (NSSet touches, UIEvent evt)
        {
            boids.ForEach(boid => boid.Agent.Behavior.SetWeight(1.0f, seekGoal));
        }

        public override void TouchesEnded (NSSet touches, UIEvent evt)
        {
            boids.ForEach (boid => boid.Agent.Behavior.SetWeight (0.0f, seekGoal));
        }

        public override void TouchesMoved (NSSet touches, UIEvent evt)
        {
            var touch = (UITouch) touches.First();
            var loc = touch.LocationInNode (this);
            trackingAgent.Position = new Vector2((float) loc.X, (float) loc.Y);
        }

        private void AddRandomBoids (int count)
        {
            var scale = 0.4f;
            for (var i = 0; i < count; i++) {
                var b = new Boid (UIColor.Red, this.Size, scale);
                boids.Add (b);
                this.AddChild (b);
            }
        }

        internal static GKBehavior DefineFlockingBehavior(GKAgent2D[] boidBrains, float scale)
        {
            if (flockingBehavior == null) {
                var flockingGoals = new GKGoal[3];
                flockingGoals [0] = GKGoal.GetGoalToSeparate (boidBrains, 100.0f * scale, (float)Math.PI * 8.0f);
                flockingGoals [1] = GKGoal.GetGoalToAlign (boidBrains, 40.0f * scale, (float)Math.PI * 8.0f);
                flockingGoals [2] = GKGoal.GetGoalToCohere (boidBrains, 40.0f * scale, (float)Math.PI * 8.0f);

                flockingBehavior = new GKBehavior ();
                flockingBehavior.SetWeight (25.0f, flockingGoals [0]);
                flockingBehavior.SetWeight (10.0f, flockingGoals [1]);
                flockingBehavior.SetWeight (10.0f, flockingGoals [2]);
            }
            return flockingBehavior;
        }

        public override void Update (double currentTime)
        {
            base.Update (currentTime);
            if (Double.IsNaN(lastUpdateTime)) {
                lastUpdateTime = currentTime;
            }
            var delta = currentTime - lastUpdateTime;
            componentSystem.Update (delta);
        }
    }

    public class Boid : SKNode, IGKAgentDelegate
    {
        public GKAgent2D Agent { get { return brains; } }
        public SKShapeNode Sprite { get { return sprite; } }

        class BoidSprite : SKShapeNode
        {
            public BoidSprite (UIColor color, float scale)
            {
                var rot = CGAffineTransform.MakeRotation((float) (Math.PI / 2.0f));
                var path = new CGPath ();
                path.MoveToPoint (rot, new CGPoint (10.0, 0.0));
                path.AddLineToPoint (rot, new CGPoint (0.0, 30.0));
                path.AddLineToPoint (rot, new CGPoint (10.0, 20.0));
                path.AddLineToPoint (rot, new CGPoint (20.0, 30.0));
                path.AddLineToPoint (rot, new CGPoint (10.0, 0.0));
                path.CloseSubpath ();

                this.SetScale (scale);
                this.Path = path;
                this.FillColor = color;
                this.StrokeColor = UIColor.White;

            }
        }

        private GKAgent2D brains;
        private BoidSprite sprite;
        private static int boidId = 0;

        public Boid (UIColor color, CGSize size, float scale)
        {
            brains = BoidBrains (size, scale);
            sprite = new BoidSprite (color, scale);
            sprite.Position = new CGPoint(brains.Position.X, brains.Position.Y);
            sprite.ZRotation = brains.Rotation;
            sprite.Name = boidId++.ToString ();

            brains.Delegate = this;

            this.AddChild (sprite);
        }

        private GKAgent2D BoidBrains(CGSize size, float scale)
        {
            var brains = new GKAgent2D ();
            var x = (float) (FlockRandom.NextUniform () * size.Width);
            var y = (float) (FlockRandom.NextUniform () * size.Height);
            brains.Position = new Vector2 (x, y);

            brains.Rotation = (float)(FlockRandom.NextUniform () * Math.PI * 2.0);
            brains.Radius = 30.0f * scale;
            brains.MaxSpeed = 0.5f;
            return brains;
        }

        [Export ("agentDidUpdate:")]
        public void AgentDidUpdate (GameplayKit.GKAgent agent)
        {
        }

        [Export ("agentWillUpdate:")]
        public void AgentWillUpdate (GameplayKit.GKAgent agent)
        {
            var brainsIn = (GKAgent2D) agent;
            sprite.Position = new CGPoint(brainsIn.Position.X, brainsIn.Position.Y);
            sprite.ZRotation = brainsIn.Rotation;
            Console.WriteLine ($"{sprite.Name} -> [{sprite.Position}], {sprite.ZRotation}");
        }
    }
}

Potom Implementujte tuto scénu v kontroleru zobrazení:Next, implement this scene in a view controller:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();
        // Perform any additional setup after loading the view, typically from a nib.
        this.View = new SKView {
        ShowsFPS = true,
        ShowsNodeCount = true,
        ShowsDrawCount = true
    };
}

public override void ViewWillLayoutSubviews ()
{
    base.ViewWillLayoutSubviews ();

    var v = (SKView)View;
    if (v.Scene == null) {
        var scene = new FlockingScene (View.Bounds.Size);
        scene.ScaleMode = SKSceneScaleMode.AspectFill;
        v.PresentScene (scene);
    }
}

Když se spustí, trochu animovaná "Boids" se zachová kolem našeho prstu:When run, the little animated "Boids" will flock around our finger taps:

Trochu animovaného Boidsu se kolem klepnutí prstu zachová.The little animated Boids will flock around the finger taps

Další příklady AppleOther Apple Examples

Kromě výše uvedených ukázek vám společnost Apple poskytovala následující ukázkové aplikace, které je možné překódovat do C# a Xamarin. iOS:In addition to the samples presented above, Apple has provided the following sample apps that can be transcoded to C# and Xamarin.iOS:

MetalMetal

V systému iOS 9 provedl společnost Apple několik změn a dodávání materiálu, které poskytuje slabý přístup k GPU.In iOS 9, Apple has made several changes and additions to Metal to provide low-overhead access to the GPU. Pomocí metalu můžete maximalizovat grafiku a výpočetní potenciál aplikací pro iOS.Using Metal you can maximize the graphics and computing potential of your iOS apps.

Kovové rozhraní obsahuje následující nové funkce:The Metal framework includes the following new features:

  • Nové textury pro předlohu v soukromém a hloubkovém vzorníku pro OS X.New private and depth stencil textures for OS X.
  • Vylepšená kvalita stínu s použitím sekrytí hloubky a oddělených hodnot z front-end vzorníkuImproved shadow quality with depth clamping and separate front and back stencil values.
  • Vylepšení jazyka kovového stínování a standardní knihovny na kovové úrovniMetal Shading Language and Metal Standard Library improvements.
  • Výpočetní shadery podporují širší rozsah formátů pixelů.Computational shaders support a wider range of pixel formats.

MetalKit FrameworkThe MetalKit Framework

MetalKit Framework poskytuje sadu tříd nástrojů a funkcí, které snižují množství práce potřebné k používání kovu v aplikaci pro iOS.The MetalKit framework provides a set of utility classes and features that reduce the amount of work required to use Metal in an iOS app. MetalKit poskytuje podporu ve třech klíčových oblastech:MetalKit provides support in three key areas:

  1. Asynchronní načítání textury z nejrůznějších zdrojů, včetně běžných formátů, jako jsou PNG, JPEG, KTX a PVR.Asynchronous texture loading from a variety of sources including common formats such as PNG, JPEG, KTX and PVR.
  2. Snadný přístup k prostředkům na základě vstupně-výstupních operací modelu pro zpracování specifických modelů kovů.Easy access of Model I/O based assets for Metal specific model handling. Tyto funkce byly vysoce optimalizované pro zajištění efektivního přenosu dat mezi oky v/v modelu a vyrovnávací pamětí kovů.These features have been highly optimized to provide efficient data transfer between Model I/O meshes and Metal buffers.
  3. Předdefinovaná zobrazení kovů a správa zobrazení, která významně omezují množství kódu potřebného k zobrazení vykreslování grafiky v rámci aplikace pro iOS.Predefined Metal views and view management that greatly reduce the amount of code required to display graphic renderings within an iOS app.

Další informace o MetalKit najdete v tématu Referenční příručka k rozhraní MetalKitpro společnost Apple, Průvodce programovánímv kovovém prostředí a Příručka pro jazyk kovového stínování.To learn more about MetalKit, please see Apple's MetalKit Framework Reference, Metal Programming Guide, Metal Framework Reference and Metal Shading Language Guide.

Rozhraní shaderů pro výkon kovůMetal Performance Shaders Framework

Rozhraní shader Performance shader nabízí vysoce optimalizovanou sadu grafických a výpočetních shaderů pro použití v aplikacích pro iOS založených na metalu.The Metal Performance Shader framework provides a highly-optimized set of graphics and computational based shaders for use in your Metal based iOS apps. Jednotlivé shadery v rozhraní shader Performance shader byly speciálně vyladěny tak, aby poskytovaly vysoký výkon pro procesory s podporou GPU iOS.Each shader in the Metal Performance Shader framework has been specifically tuned to provide high performance on Metal supported iOS GPUs.

Pomocí tříd shaderu výkonu kovů můžete dosáhnout nejvyššího možného výkonu u každého konkrétního GPU iOS bez nutnosti cílit a spravovat jednotlivé základy kódu.By using Metal Performance Shader classes, you can achieve the highest performance possible on each specific iOS GPU without having to target and maintain individual code bases. Shadery výkonu kovů lze použít s libovolným kovovým prostředkem, jako jsou textury a vyrovnávací paměti.Metal Performance Shaders can be used with any Metal resource such as textures and buffers.

Rozhraní shader Performance shader poskytuje sadu běžných shaderů, například:The Metal Performance Shader framework provides a set of common shaders such as:

  • Gaussovské rozostření ( MPSImageGaussianBlur )Gaussian Blur (MPSImageGaussianBlur)
  • Detekce hran Sobel ( MPSImageSobel )Sobel Edge Detection (MPSImageSobel)
  • Histogram obrázků ( MPSImageHistogram )Image Histogram (MPSImageHistogram)

Další informace najdete v příručce k jazyku pro kovové stínováníod společnosti Apple.For more information, please see Apple's Metal Shading Language Guide.

Představujeme vstupně-výstupní operace modeluIntroducing Model I/O

Vstupně-výstupní rozhraní modelu společnosti Apple poskytuje podrobné informace o 3D materiálech (například o modelech a jejich souvisejících prostředcích).Apple's Model I/O framework provides a deep understanding of 3D assets (such as models and their related resources). I/O modelu poskytuje vaše hry pro iOS své hry s využitím fyzických materiálů, modelů a osvětlení, které je možné používat s GameplayKit, metalem a SceneKit.Model I/O provides your iOS games with physical-based materials, models and lighting that can be used with GameplayKit, Metal and SceneKit.

I/O modelu můžete podporovat následující typy úloh:With Model I/O, you can support the following types of tasks:

  • Z nejrůznějších oblíbených formátů softwaru a herních strojů importujte data o osvětlení, materiálech, mřížkách, nastaveních kamery a dalších informacích založených na scéně.Import lighting, materials, mesh data, camera settings and other scene-based information from a variety of popular software and game engine formats.
  • Zpracujte nebo generujte informace na základě scény, jako je například vytvoření procedurálních textur na nebeích nebe Domes nebo zanesli do sítě.Process or generate scene-based information such as create procedurally textured sky domes or bake lighting into a mesh.
  • Spolupracuje s MetalKit, SceneKit a GLKit pro efektivní načtení herních prostředků do vyrovnávací paměti GPU pro vykreslování.Works with MetalKit, SceneKit and GLKit to efficiently load game assets into GPU buffers for rendering.
  • Exportujte informace na základě scény do nejrůznějších oblíbených formátů softwaru a herních strojů.Export scene-based information to a variety of popular software and game engine formats.

Další informace o vstupně-výstupních operacích modelů najdete v referenčních informacích k modelu i/o rozhraní společnosti Apple.To learn more about Model I/O, please see Apple's Model I/O Framework Reference

Představujeme ReplayKitIntroducing ReplayKit

Nové rozhraní ReplayKit společnosti Apple umožňuje snadno přidat záznam hry do hry pro iOS a umožnit uživateli rychle a jednoduše upravit a sdílet toto video v rámci aplikace.Apple's new ReplayKit framework allows you to easily add recording of game play to your iOS game and allow the user to quickly and easily edit and share this video from within the app.

Další informace najdete v článku o informování sociálních sítí pomocí ReplayKit a Game Center videa a jejich DemoBots: vytvoření hry pro různé platformy s využitím ukázkové aplikace SpriteKit a GameplayKit.For more information, please see Apple's Going Social with ReplayKit and Game Center video and their DemoBots: Building a Cross Platform Game with SpriteKit and GameplayKit sample app.

SceneKitSceneKit

Scéna je grafické rozhraní API pro 3D scénu, které zjednodušuje práci s 3D grafikou.Scene Kit is a 3D scene graph API that simplifies working with 3D graphics. Byla poprvé zavedena v OS X 10,8 a nyní přicházía do systému iOS 8.It was first introduced in OS X 10.8, and has now come to iOS 8. Se sadou scéna, která vytváří moderní prostorové vizualizace a občasné 3D hry, nevyžaduje v OpenGL odbornost.With Scene Kit creating immersive 3D visualizations and casual 3D games does not require expertise in OpenGL. Sada scény se sestavuje na běžných konceptech grafu scény, protože se nejedná o složitosti OpenGL a OpenGL ES, což usnadňuje přidávání 3D obsahu do aplikace.Building on common scene graph concepts, Scene Kit abstracts away the complexities of OpenGL and OpenGL ES, making it very easy to add 3D content to an application. Pokud jste však odborníkem na OpenGL, sada scény nabízí skvělou podporu pro vázání přímo s OpenGL také.However, if you are an OpenGL expert, Scene Kit has great support for tying in directly with OpenGL as well. Obsahuje také mnoho funkcí, které doplňují 3D grafiku, jako je například fyzika, a integrují velmi dobře do několika dalších rozhraní Apple, jako je základní animace, základní image a Sprite.It also includes numerous features that complement 3D graphics, such as physics, and integrates very well with several other Apple frameworks, such as Core Animation, Core Image and Sprite Kit.

Další informace najdete v naší dokumentaci k SceneKit .For more information, please see our SceneKit documentation.

SceneKit změnySceneKit Changes

Společnost Apple přidala do SceneKit pro iOS 9 tyto nové funkce:Apple has added the following new features to SceneKit for iOS 9:

  • Xcode nyní poskytuje editor scény, který umožňuje rychle vytvářet hry a interaktivní 3D aplikace úpravou scén přímo v rámci Xcode.Xcode now provides a Scene Editor that allows you to quickly build games and interactive 3D apps by editing scenes directly from within Xcode.
  • SCNViewTřídy a se SCNSceneRenderer dají použít k povolení vykreslování kovů (na podporovaných zařízeních s iOS).The SCNView and SCNSceneRenderer classes can be used to enable Metal rendering (on supported iOS devices).
  • SCNAudioPlayerTřídy a SCNNode lze použít k přidání prostorových audio efektů, které automaticky sledují polohu přehrávače v aplikaci pro iOS.The SCNAudioPlayer and SCNNode classes can be used to add spatial audio effects that automatically track a player position to an iOS app.

Další informace najdete v naší dokumentaci k SceneKit a Referenční příručce k SceneKit Framework společnosti Apple a Fox: vytvoření hry SceneKit s ukázkovým projektem editoru Xcode scény .For more information, please see our SceneKit Documentation and Apple's SceneKit Framework Reference and Fox: Building a SceneKit Game with the Xcode Scene Editor sample project.

SpriteKitSpriteKit

Sada Sprite, rozhraní 2D Game Framework od společnosti Apple, má některé zajímavé nové funkce v iOS 8 a OS X Yosemite.Sprite Kit, the 2D game framework from Apple, has some interesting new features in iOS 8 and OS X Yosemite. Patří mezi ně integrace se sadou scén, podpora shaderů, osvětlení, stíny, omezení, normální generování mapy a vylepšení fyziky.These include integration with Scene Kit, shader support, lighting, shadows, constraints, normal map generation, and physics enhancements. Zejména nové funkce fyziky usnadňují přidávání realistických efektů do hry.In particular, the new physics features make it very easy to add realistic effects to a game.

Další informace najdete v naší dokumentaci k SpriteKit .For more information, please see our SpriteKit documentation.

SpriteKit změnySpriteKit Changes

Společnost Apple přidala do SpriteKit pro iOS 9 tyto nové funkce:Apple has added the following new features to SpriteKit for iOS 9:

  • Prostorový zvukový efekt, který automaticky sleduje polohu přehrávače pomocí SKAudioNode třídy.Spatial audio effect that automatically track the player's position with the SKAudioNode class.
  • Xcode nyní obsahuje editor scény a editor akcí pro snadnou tvorbu 2D her a aplikací.Xcode now features a Scene Editor and Action Editor for easy 2D game and app creation.
  • Snadná posouvaný podpora her s novými objekty kamery ( SKCameraNode )Easy scrolling game support with new Camera Nodes (SKCameraNode) objects.
  • V zařízeních se systémem iOS, která podporují kov, ji SpriteKit automaticky použije pro vykreslování, i když už používáte vlastní shadery OpenGL ES.On iOS devices that support Metal, SpriteKit will automatically use it for rendering, even if you were already using custom OpenGL ES shaders.

Další informace najdete v dokumentaci k SpriteKit společnosti Apple SpriteKit Framework a jejich DemoBots: vytváření her pro různé platformy s ukázkovou aplikací SpriteKit a GameplayKit .For more information, please see our SpriteKit Documentation Apple's SpriteKit Framework Reference and their DemoBots: Building a Cross Platform Game with SpriteKit and GameplayKit sample app.

ShrnutíSummary

Tento článek pojednává o nových herních funkcích, které iOS 9 poskytuje pro vaše aplikace Xamarin. iOS.This article has covered the new Gaming features that iOS 9 provides for your Xamarin.iOS apps. Představil GameplayKit a model I/O; Hlavní vylepšení kovů; a nové funkce SceneKit a SpriteKit.It introduced GameplayKit and Model I/O; the major enhancements to Metal; and the new features of SceneKit and SpriteKit.