Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
9. June 2014

 

 

I’ve done a number of these walk through type tutorials using many different languages/libraries and there is one common traffic trend.  People LOVE reading about graphics.  In every single example the post I do about graphics always seems to draw the most traffic.  I guess we just love drawing stuff on screen.  Now for the good part, Phaser is good at it and makes it really all quite easy.

 

Loading and adding a sprite

 

Back in the previous post I actually jumped the gun a bit and showed preloading and rendering sprites.  Since so many people jump ahead straight to the graphics post, I’ll review the process.

 

/// <reference path="phaser.d.ts"/>
class SimpleGame {
    game: Phaser.Game;
    titleScreenImage: Phaser.Sprite;

    constructor() {
        this.game = new Phaser.Game(800, 600, Phaser.AUTO, 'content', { create: this.create, preload: this.preload });
    }
    preload() {
        this.game.load.image("title", "TitleScreen.png");
    }
    create() {
        this.titleScreenImage = this.game.add.sprite(0, 0, "title");
    }
}

window.onload = () => {
    var game = new SimpleGame();
};

 

The key concepts to be aware of here is preloading assets using game.load methods, where you pass in the filename as well as a unique string key that you will use to access the asset.  Then in create you can see this in action, where we add a sprite to the game using game.add.sprite, using the key “title” to access it.  In this case our “sprite” was a full screen image.  Now let’s look at how you can work with a sprite, this time using a slightly smaller image.

Working with sprites

 

For this section I am going to work with this sprite ( created in this tutorial series ):

jet

 

Add it to your project’s root directory.  In my case I’ve called it jet.png.  Using the above code, simply replace “TitleScreen.png” with “jet.png” and “title” with “jet” and you should see:

 

image

 

 

As you can see, our sprite is drawn at the top left corner of the screen.  That is because the value (0,0) in Phaser refers to the top left corner of the screen by default.  Let’s instead center our sprite using the following code:

 

/// <reference path="phaser.d.ts"/>
class SimpleGame {
    game: Phaser.Game;
    jetSprite: Phaser.Sprite;

    constructor() {
        this.game = new Phaser.Game(800, 600, Phaser.AUTO, 'content', { create: this.create, preload: this.preload });
    }
    preload() {
        var loader = this.game.load.image("jet", "jet.png");
    }
    create() {
        var image = <Phaser.Image>this.game.cache.getImage("jet");
        
        this.jetSprite = this.game.add.sprite(
            this.game.width / 2 - image.width / 2,
            this.game.height / 2 - image.height / 2,
            "jet");
    }
}

window.onload = () => {
    var game = new SimpleGame();
};

 

Run this code and:

image

 

We are now nicely centered, both to the window and sprite.

We have one major challenge with centering the image.  Until the sprite is created, it doesn’t have a width or height.  However, when you create the sprite you can set it’s position.  Of course it would be possible to create then move the sprite but that is hackish and could have unintended graphical problems.  Instead we can get the image we loaded using this.game.cache.getImage() then access the images dimensions.  One line of code might stand out for you here:

 

var image = <Phaser.Image>this.game.cache.getImage("jet");

 

This is TypeScript’s way of typecasting.  If you’ve worked in Java, C# or C++ you’ve no doubt encountered typescasting.  If your experience was mostly in JavaScript ( a mostly typeless language ), this might be new to you.  Basically what you are saying is “we promise the value returned by getImage() is of the type <Phaser.Image>, so make image a Phaser.Image”.  If you try to access a value or method in image that doesn’t exist in Phaser.Image, TypeScript will give you an error.

 

Positioning items in Phaser

 

When using a sprite, by default, transformations happen relative to the top left corner of the sprite.  This is why we had to subtract half to the width and height of the sprite when positioning it in the center of the screen.  Otherwise the top left corner of the sprite would be centered to the screen like this:

image

 

Sometimes however you would rather transform the sprite relative to a different point, commonly the very middle or occasionally the bottom left corner.   Fortunately there is an option for this, the anchor.  The anchor tells Phaser where to draw your Sprite relative to.  Here we set the anchor to the center of the sprite then draw it at (0,0) like so:

 

    create() {
        var image = <Phaser.Image>this.game.cache.getImage("jet");
        
        this.jetSprite = this.game.add.sprite(
            this.game.width / 2 - image.width / 2,
            this.game.height / 2 - image.height / 2,
            "jet");

        this.jetSprite.anchor.set(0.5,0.0)
        this.jetSprite.position.x = this.jetSprite.position.y = 0.0;
    }

 

And the result:

image

As you can see, draw calls for the sprite now position relative to it’s center.  Positioning sprites relative to their center is incredibly handy when it comes to rotation, while anchoring at the bottom is useful for platformers where you are aligning the sprite’s feet to the ground.  What you chose is entirely up to you.  The values passed in to anchor might be a bit confusing, as they are normalized, meaning they go from 0 to 1.  The values are all relative to the sprite itself, while (0,0) is the top left corner of the sprite, while (1,1) is the bottom right corner.  (1,0) would be the bottom left, while (0,1) would be the top right.

 

There is one important thing to be aware of here.  Anchor works relative to the source image, not the sprite itself.  Therefore if you intend to scale your sprites, instead of using anchor, you are going to want to use pivot instead.  (Until recently pivot was broken, but it appears to work now).  Pivot sets the center point of the sprite, not the image that composes the sprite.  Setting the pivot looks like this:

        this.jetSprite.pivot.x = this.jetSprite.width / 2;
        this.jetSprite.pivot.y = this.jetSprite.height / 2;

 

Again, you don’t have to set the anchor at all, but it can be useful.  Unlike anchor, pivot uses relative pixel coordinates within the sprite itself.  Therefore the mid-point is at (width/2,height/2).  Once again, (0,0) is the top left corner.

 

Simple Graphics

 

Sometimes you just want to draw primitive graphics on screen… lines, circles, boxes, that kind of stuff.  Fortunately Phaser has that built in as well in the form of the Graphics object.

 

/// <reference path="phaser.d.ts"/>
class SimpleGame {
    game: Phaser.Game;
    jetSprite: Phaser.Sprite;

    constructor() {
        this.game = new Phaser.Game(800, 600, Phaser.AUTO, 'content', { create: this.create, preload: this.preload });
    }
    preload() {
        var loader = this.game.load.image("jet", "jet.png");
    }
    create() {
        // Add a graphics object to our game
        var graphics = this.game.add.graphics(0, 0);

        // Create an array to hold the points that make up our triangle
        var points: Phaser.Point[] = [];
        // Add 4 Point objects to it
        points.push(new Phaser.Point());
        points.push(new Phaser.Point());
        points.push(new Phaser.Point());

        // Position one top left, top right and botto mmiddle
        points[0].x = 0;
        points[0].y = 0;

        points[1].x = this.game.width;
        points[1].y = 0;

        points[2].x = this.game.width/2;
        points[2].y = this.game.height;

        // set fill color to red in HEX form.  The following is equal to 256 red, 0 green and 0 blue.  
        // Do at 50 % alpha, meaning half transparent
        graphics.beginFill(0xff0000, 0.5);
        
        // Finally draw the triangle, false indicates not to cull ( remove unseen values )
        graphics.drawTriangle(points, false);

        // Now change colour to green and 100% opacity/alpha
        graphics.beginFill(0x00ff00, 1.0);

        // Draw circle about screen's center, with 200 pixels radius
        graphics.drawCircle(this.game.width / 2, this.game.height / 2, 200);
        
    }
}

window.onload = () => {
    var game = new SimpleGame();
};

 

The code is pretty heavily commented so should be self explanatory.  When you run it you should see:

image

 

 

A look behind the scenes

 

Let’s take a quick look at how graphics drawing works in Phaser.  That involves going back to this line:

this.game = new Phaser.Game(800, 600, Phaser.AUTO, 'content', {});

Here you are passing in a lot of important information.  First (and second) are the resolution of your game.  Next is the type of Renderer that Phaser should use.  We mentioned this briefly in the prior tutorial.  You have the option of WEBGL or Canvas rendering ( or headless, which means no rendering at all and is used for server side programming ).  Which you chose depends heavily on the device you are supporting.  For example, currently no iOS devices support WebGL and only the most recent version of Internet Explorer work.  By selecting AUTO you let Phaser decide based on the device you are running on.  Finally ‘content’ is the HTML ID of the DIV to render our game in.

 

You may notice scattered throughout Phaser’s code/documentation are references to PIXI.  Pixi.js is a popular WebGL 2D renderer that is able to fallback on Canvas rendering when WebGL is unavailable.  Pixi is the renderer that Phaser uses, so you will occasionally see Pixi classes inside Phaser code.

 

There is one final thing to cover about graphics before moving on, full screen and handling multiple resolutions.

 

Going Full Screen

 

Now let’s take a look at an application that can go full screen:

 

/// <reference path="phaser.d.ts"/>
class SimpleGame {
    game: Phaser.Game;
    jetSprite: Phaser.Sprite;

    constructor() {
        this.game = new Phaser.Game(640, 480, Phaser.AUTO, 'content', { create: this.create, preload: this.preload });
    }
    preload() {
        var loader = this.game.load.image("jet", "jet.png");
    }

    // This function is called when a full screen request comes in
    onGoFullScreen() {
        // tell Phaser how you want it to handle scaling when you go full screen
        this.game.scale.fullScreenScaleMode = Phaser.ScaleManager.EXACT_FIT;
        // and this causes it to actually do it
        this.game.scale.refresh();
    }
    goFullScreen() {

    }
    create() {
        var image = <Phaser.Image>this.game.cache.getImage("jet");

        // Draw the jet image centered to the screen
        this.jetSprite = this.game.add.sprite(
            this.game.width / 2 - image.width / 2,
            this.game.height / 2 - image.height / 2,
            "jet");

        // Set background to white to make effect clearer
        this.game.stage.backgroundColor = 0xffffff;

        // Add a function that will get called when the game goes fullscreen
        this.game.scale.enterFullScreen.add(SimpleGame.prototype.onGoFullScreen, this);

        // Now add a function that will get called when user taps screen.
        // Function declared inline using arrow (=>) function expression
        // Simply calls startFullScreen().  True specifies you want anti aliasing.
        // Unfortunately you can only make full screen requests in desktop browsers in event handlers
        this.game.input.onTap.add(
            () => { this.game.scale.startFullScreen(true); },
            this);
    }

}

window.onload = () => {
    var game = new SimpleGame();
};

 

The comments cover most of what’s going on, but I thought I would touch on a couple things in the above example.  First you cant simply request to go fullScreen in Desktop browsers for security reasons.  This means your game can’t simply start in full screen, you need to make the call to startFullScreen() inside an event handler.  Most commonly this will be in the form of a “Click here for FullScreen” button or link.

 

Next is the ()=> syntax, known in TypeScript as an arrow function expression (if you’ve used C#, this syntax is going to look awfully familiar to you!) and is something that should be coming in the next JavaScript version (ECMAScript 6).  It is simply a more compact form of a function expression ( no need for the word function ) that is automatically scoped to “this”.  You could have created a function like onGoFullScreen like we did for enterFullScreen.  ( Coincidentally we could have also handled enterFullScreen using an arrow function.

 

The last thing to look at is the scale mode.  In this example we used Phaser.ScaleManager.EXACT_FIT, which scales the scene up to match your resolution.  There are two other options, SHOW_ALL and NO_SCALE.  Here is the result of running the code above using each setting:

 

Phaser.ScaleManager.EXACT_FIT

EXACT_FIT

 

Phaser.ScaleManager.NO_SCALE

NO_SCALE

 

Phaser.ScaleManager.SHOW_ALL 

SHOW_ALL

 

If you have an HDTV, you can think about them this way.  EXACT_FIT is the same as Stretch mode.  It scales the scene to use as much of the screen as possible, but can result in some distortion.  NO_SCALE does nothing, it simply shows the scene un-altered, centered to the screen.  SHOW_ALL is about the equivalent of Letterbox.  Basically it fits as well as it can while maintaining the aspect ration of your original scene. 

 

Don’t worry, that’s not it for graphics, we have all kinds of things coming up…  spritesheets, effects, particles, animation, etc…  That’s just it for the foundations.

 

Programming


9. June 2014

 

I just received the following email from Autodesk:

 

SAN FRANCISCO, June 9, 2014 -- Autodesk, Inc. (Nasdaq: ADSK) has acquired Stockholm-based Bitsquid AB, the creator of the Bitsquid game engine. The acquisition brings to Autodesk expertise in 3D game development and proven technology that will enable Autodesk to supercharge its portfolio of tools for game makers through the development of a new 3D game engine. Multiple game developers have used the modern and flexible Bitsquid engine to create 3D games for next-generation consoles and PCs, and Autodesk will continue to work with many of these companies to develop the new 3D game engine. Terms of the acquisition were not disclosed.

"Bitsquid has been a key success factor for Fatshark, as we’ve been able to produce high quality games with short development times,” said Martin Wahlund, CEO, Fatshark. "We are excited to see how Bitsquid evolves now that it is part of Autodesk.”

In addition to acquiring the Bitsquid game engine, the acquisition of the Bitsquid team and technology will enable Autodesk to create new tools that push the limits of real-time 3D visualization for architects and designers, many of whom face challenges placing design data into real world contexts. The new technology will also be incorporated into solutions for customers outside of the games industry, including architecture, manufacturing, construction, and film. Autodesk plans to create new types of design exploration tools that allow visualization and contextualization of designs using the same fluid control and immediate feedback that exist today in modern console and PC games.

"Autodesk's acquisition of Bitsquid will revolutionize real-time exploration of complex data. Imagine being able to walk through and explore any type of design, from buildings to cars, with the same freedom you experience in the open world of a next-generation console game. Game engine technologies will be an increasingly critical part of the workflow, not only for creating games, but also for designing buildings or solving complex urban infrastructure challenges," said Chris Bradshaw, senior vice president, Autodesk Media & Entertainment. "The Bitsquid acquisition brings to Autodesk both the expertise and the technology that will enable us to deliver a groundbreaking new approach to 3D design animation tools, and we welcome the team and community to Autodesk."

Additional information on the new Autodesk 3D game engine, which will compliment Autodesk's industry leading games portfolio of middleware tools and 3D animation software including Autodesk Maya LT, Autodesk Maya and Autodesk 3ds Max, will be available later this year.

 

In that press release, it sounds like a relatively minor acquisition, they could simply be rolling the technology in to one of their existing products.  However, if you read this site, they obviously have bigger plans:

 

More than just games – This is going to be BIG

With the acquisition of Bitsquid, Autodesk is bringing expertise in 3D game development and proven game engine technology in house. We are significantly expanding our portfolio of game making tools, complementing our middleware and 3D animation tools: Autodesk® 3ds Max®, Autodesk® Maya®, and Autodesk® Maya LT™ software. Across Autodesk, this technology will fuel new product development in our Media & Entertainment business, and enable a new class of design animation tools.

Tools for Game Makers

Later this year, Autodesk will introduce a modern and flexible 3D game engine based on the Bitsquid engine. By introducing a game engine, Autodesk can offer game makers a more complete game creation workflow from concept to release.

A New Era in Design Animation

Many of our manufacturing, architecture, building, and construction customers are also excited about game engine technology– but not because they are making games. Instead, they are looking for new ways to visualize and interact with design data with the same level of control and feedback of modern console or PC games. With the acquisition of Bitsquid, Autodesk will begin exploring the creation of a new interactive design exploration platform, integrated with our design tools, which will help designers contextualize their ideas.

In Film and Television

Autodesk will also be looking at how Bitsquid technology may be applied to workflows such as pre-vizualization and interactive compositing.

 

Bolded portion mine.  So Autodesk is clearly entering the game engine space and building it around BitSquid.  Ever heard of it?  Yeah, me neither.  It is however the engine powering Magicka:Wizard Wars:

2.jpg (1920×1080)

 

Their site is fairly minimal, but describes the BitSquid engine as:

 

Fast

Bitsquid is a new high-end game engine, built from the ground up to focus on excellent multicore performance, cache friendly data layouts and advanced rendering techniques.

Dynamic

Bitsquid supports immediate reload of all resources, both scripts and content. You can also test run levels instantly, on PCs, consoles, phones and tablets.

Flexible

The engine is completely data driven, making it easy to create a highly scalable rendering pipe that shines on both the latest DX11 GPU and mobile devices, just by changing configuration files. And any game or simulation can be authored using just Lua and visual scripting. Of course you can use C as well, where you need the speed.

Lightweight

Written with a minimalistic modular design philosophy the entire engine is less than 200 KLOC and easy to modify.

 

The technical blog however makes for an interesting read.

 

Autodesk entering the game space isn’t really a huge shock.  They actually dipped their toe in the pond when they released Scaleform as an Indie game engine.  Considering their heavy role in the game development pipeline ( due mostly to Max and Maya ), this move does make sense.  The question is, will this alienate their existing partners?

 

EDIT: One thing I didn’t mention in the original post.  Autodesk also announced the lowering of the monthly cost of Maya LT from $50 a month to $30 a month.  Additionally they have made Mudbox available for $10 a month.  This seems like a much better price point to me.  You can now get Photoshop ($30), Maya LT ($30) and Unreal (19$), a complete game development package for less than $80 a month.  Compare that to prices a few years ago and it is simply mind blowing!

 

Additionally, Develop have published an interview with Autodesk’s Frank Delise discussing the acquisition. 

News


6. June 2014

Marmalade header

Marmalade just released version 7.3 of their cross platform gaming library, highlights of the update are:

 

  • Enhanced support for Windows Store platform 
  • Multi-touch support for Windows Desktop platform
  • OpenGL ES 3.0 support for iOS, Android and Windows Desktop platforms
  • OpenGL ES 2.0 and OpenAL 1.1 support for Marmalade Juice
  • GCC 4.8 support for building x86 and ARM application binaries
  • Hub support for simultaneous x86 and ARM deployment packaging on Android platform
  • iOS 7.1 framework support
  • ARM architecture variant support

 

Of course, the biggest news with this release is, you can now use Marmalade completely free.  Of course you say, there must be a catch!  You would be right, but it’s a pretty fair one.  From a Marmalade engineer doing an AMA on Reddit, he said:

 

  • Marmalade C++ - for C++ development using your preferred IDE
  • Marmalade Juice - for porting iOS projects to Android
  • Marmalade Quick - for rapid application development with the Lua scripting language
  • Marmalade Web - HTML5 development for web and hybrid apps

With the free version, you are able to deploy your projects to the following platforms using a single common codebase:

  • iOS
  • Android
  • Windows Phone 8
  • Windows Store
  • Tizen
  • BlackBerry

There are restrictions on the free version (you knew it was coming... :P)

  • Splash screen when your app starts
  • You are limited to the pre-integrated extensions that are included (these include billing and IAP APIs for all major app stores, advertising, social and analytics services)

 

He missed another major missing feature in that summary, on device debugging.  This one is somewhat critical when it comes time to ship.

So, a no device debugging, splash screen and limited to the included extensions.  If these limits are too much for you, you can obviously upgrade to a paid option.  For the $15/150 (month/year) tier, you can replace the splash screen.  For $499/year ( no monthly option ) you can get on device debugging and full access to native extensions.  The next two tiers ( $1500 and $3500 ) are mostly about support and source access.


5. June 2014

 

The following email just landed in my inbox.

 

Unreal Engine 4.2 is Here!

 

In this update we’re shipping 269 new additions, 163 changes and 107 fixes. That's 539 updates in 6 weeks. Here are a few ways you can do more with Unreal Engine 4 for only $19 per month. If you haven’t signed up yet, please do!

Vehicle Template

Get our feature-rich vehicle support! 4.2 ships with a vehicle template in C++ and Blueprint form, plus our vehicle sample game to help you ramp up.

Read More

 

 

 

 

 

 

Tappy Chicken Demo

Explore Tappy Chicken, recently released for iOS, Android and HTML5, to learn how to make a small, simple app that deploys over the air in less than 30MB. Mobile enhancements include leaderboards, achievements and ad support.

Read More

 

 

 

 

 

Unreal Tournament

Join our new Unreal Tournament open development project for PC, Mac and Linux.

Read More

 

 

 

 

 

 

New Features for 4.2 Release

Get new features like camera animation system, Blueprint cut/copy/paste, and more!

Read More

 

 

 

 

Metal API, iOS 8 and UE4 Developers!

 

Zen Gardens

This week we were a part of Apple’s WWDC keynote revealing Zen Garden, a beautiful environment built in Unreal Engine 4 to demonstrate the kinds of vibrant dynamic scenes and enormous vistas made possible by the new Metal API for iOS 8. We’re bringing the latest technology to UE4 developers.

Read More

 

 

 

 

Download all the free, pretty content on Marketplace!

Here are just two recent additions.

SciFi-Hallway

Quixel’s stunning Sci-Fi Hallway

Read More

stylized Demo

Epic's Stylized Demo

Read More

 

 

We’re just getting started! Check out the UE4 Roadmap and vote for features you want to see in future releases.

If you have any questions or feedback you’d like to share, please visit the forums or join our live broadcasts at Twitch.tv every Thursday at 2pm ET, which you can always go back and view at YouTube.com.

Thank you for being a part of this adventure. As you can see at unrealengine.com, there are many exciting efforts in progress at Epic and throughout the Unreal ecosystem.

We hope to see you around.

 

 

I am downloading the update now.  It appears the download weighs in at 2.6GB.  Unreal continue to bring new features at a pretty good pace.

News


4. June 2014

 

I’ve noticed since Apple announced Medal at the WWDC a number of people are quite confused over exactly what Metal is.  This post is an attempt to clear that up without having to dig through marketing speak or fanboy drivel.

Metal

 

There is one very important thing to start with…  Metal is not going to cause OpenGL to go away or for Apple to stop supporting OpenGL.  If you are developing a game using OpenGL today, don’t worry, absolutely nothing about your world changes!  Metal is an alternative to OpenGL, but they push different buttons, we will cover that shortly.

 

So, what exactly is Metal?  It’s a low level, less portable more optimized graphics layer for doing the same kind of things you would use OpenGL ( and OpenCL ) or Direct3D for.  That is 3D graphics rendering and parallel GPU programming.  Metal attempts to lower the amount of overhead required for performance reasons as well as reduce CPU bottlenecks ( right now GPUs are spending a lot of time waiting around for CPUs and this is bad mkay? ).  Think about it this way, if you took OpenGL or Direct3D and took away years of cruft and supported only a subset of modern hardware, do you think you could make things faster?  Of course you could, assuming programming ability of course.  That is essentially exactly what Metal does.

 

There is one other very important thing to realize here.  Metal is Apple only!  This may seem obvious, but it really needs to be pointed out.  With DirectX works across a number of video cards and OpenGL works across a number of video cards AND platforms.  Metal on the other hand works only on the newest iOS devices, specifically those with A7 processors ( and assumedly A8, A9 etc… ).  Metal doesn’t even work on Mac OS, but assume all future devices ( such as a console or TV ) from Apple to support Metal.

 

The idea of Metal is hardly anything new.  In some strange ways it’s actually a throwback to the way things used to be in the bad ‘ole days, where each vendor would ship a custom API to take advantage of their 3D hardware.  Voodoo Graphic’s GLIDE API was probably the most popular example.  It was common for game developers to create versions of their games for specific hardware.  Eventually general APIs like D3D and OpenGL won out as it was a pain in the ass supporting all these different render paths… what’s old is new again!  That said, Apple is hardly the only vendor leading us down this road, AMD recently released Mantle, which is basically the exact same thing ( a low overhead GPU API ) targeting AMD/ATI hardware.  Even Microsoft plans to go lower level in DirectX 12, but unlike Metal, it will still support a number of GPUs.

 

So, from a Programmer’s perspective, what is Metal?  It’s a new API that is part of the iOS 8 SDK.  It consists of two parts, the ObjectiveC based SDK and a scripting language creatively known as Metal Shading Language.  The Metal shading language is based on C++11 and is used to write code that will run on the GPU.

 

Should I work with Metal?

I suppose the most important question is… should you care?  To the rank and file indie game programmer truth of the matter is Metal is a bit of a non-issue.  Is it worth re-writing your code to work with Metal?  Probably not.  If you are working cross platform, almost certainly not.  Metal is just too small of a portion of the market to really justify the investment.

 

However...

 

Will you benefit from Metal?  Yes, you probably will.  While you writing a renderer that takes advantage of Metal to run as fast as possible on A7 iOS devices really doesn’t make a lot of sense, for middleware providers, that isn’t the case.  Already Unreal Engine, CryEngine and Unity have announced future support for Metal and expect most other iOS game engines to follow suit.  So, if you are using a game engine, there are almost nothing but upsides to Metal’s announcement.  If you are a middleware provider, well, yeah… Apple just created more work for you.

 

Is there a downside?

 

Well, other than the work it generates for middleware/engine providers, there is certainly one possible downside to Medal.  Until now, especially with the success/clout of iOS, Apple has been a major influencer on the development of OpenGL.  Now that they have their own vendor locked alternative, and let’s not forget Apple LOVES vendor lock in when they are the vendor, it is possible OpenGL's development becomes much less of a priority to them.  At the end of the day though, Apple simply can’t dump OpenGL as the most likely result would be a mass of people dumping Apple.

 

The only other major downside I can think of is in regards to shader programming.  Right now most game engines simply use HLSL or GLSL shader languages.  Therefore when Unity, Unreal, CryEngine, et al.  finally do add Metal support, I will be interested in seeing how they handle shaders.  This is one area of work that could be thrust back on the poor indie developers.  In this regard, only time will tell.


AppGameKit Studio

See More Tutorials on DevGa.me!

Month List