Related
I'm new to VR development, I am a bit confused what's the differnce and the relationship between Cardboard Sdk and Oculus Sdk, if I want to develop an App which can play 360 VR video or photos, then which one is better I should to choose?
By Oculus SDK, I assume you mean the mobile SDK for GearVR since you mention cardboard. If you're talking about the SDK for PC, then the question is Oculus vs SteamVR vs OpenVR vs Morpheus :)
The major choice for which to develop for I think probably comes down to what your timeline and audience is.
GearVR is the best quality device out there right now and it is SIGNIFICANTLY more polished than cardboard, and it requires specific expensive hardware (Note 4 or S6, soon the Note 5). It has a store that people are buying things off of (even if it's not much yet). But since GearVR apps in development need to be signed, you will only have an audience if you can commit to at least a demo that will be accepted on the Samsung store. (the alternative is to have every user use the developer-signing system, which means you'll get tens of people instead of thousands to see it probably)
Cardboard is a very short-term experience. There are no head-straps on cardboard for a reason - it's intended to be something you hold up for only a minute or two at a time. Most of the audience is people interested in tech demos, but many more people will be able to try out your app. Google is working on stuff behind the scenes, so there may be more meat on it in the future - a non-cardboard VR device I've heard rumors of, and they're pushing cardboard pretty hard for classroom experiences. And in a couple years, every phone MIGHT have sensors good enough to give a GearVR-level experience.
Both SDKs will give you the basic two-eye 3d stereo rendering framework. Oculus' is a little more fleshed out with some built in scene loading (it converts from FBX format which is made by MODO, which is expensive) and a UI library (I'm not very happy with it though).
Either way, most of the work you do will likely be independent of the SDK you use, so I don't think you'll be boxing yourself in whichever one you choose.
Now that unity natively support Virtual Reality you can use both of them in your project but it is a bit tricky.
Have a look at this tutorial that show how to compile for both the Cardboard SDK and the Unity Virtual Reality Supported option:
https://github.com/ludo6577/VrMultiplatform
If it's a web based project a-frame might be all you need.
A friend of mine has developed an excellent game using the starling framework. He is now wondering if he could port the game to FirefoxOS before he launches. The game is written in actionscript 3 and the starling framework project can build mobile packages for android and ios. It also can generate the flash file for the web (using flash player). Are there any paths for porting the game to FirefoxOS?
Someone suggested using shumway. If you know about this way, or any other path, please give a bief account of advantages/disadvantages. I am specially concerned about the performance, since the game in question has very high quality graphics. I think it needs to run in a GPU accelerated environment.
EaselJS uses a similar syntax to ActionScript; it has a Display List, Stage, Graphics and even Filters, this will make working with the canvas easier for us Flash developers.
I suggest you to port that game to EaselJS and TweenJS (both from CreateJS), I have used it to develop games for Firefox OS and worked quite well.
An advantage is that CreateJS now uses a WebGL renderer, but it also has a fall back to Context2D rendering if WebGL is not available. That would make your device more widely supported.
You will find all its features very explained in the following post from Mozilla Hacks. It has also some cool benchmarks to try it.
WebGL and CreateJS for FirefoxOS
You often see that a new game will be released on Xbox 360, PS3 and Windows PC.
How do gaming companies do this? Is it a common source code compiled using different compilers? Are different source codes actually required?
There's an example of this phenomenon described in this news article.
Generally speaking, the vast majority of multiplatform "triple-A" titles are implemented on top of an engine such as Unreal, Source, or other smaller engines. Each of these engines is custom-implemented and optimized for each platforms and may use a lower-level API such as DirectX/OpenGL which in turn uses the console. Each of these engines also has plug-ins for platform specific stuff (e.g., motion controls) that interact with the official drivers or APIs of the hardware.
Many of these engines support their own scripting languages or hooks for many things, so it is write once.
For example, take a look at the unreal engine:
http://www.unrealtechnology.com/technology.php
Most of the biggest engines, like Unreal are so flexible and robust that they allow developers to write all kinds of games. For instance, the Unreal engine was used not only for shooters, but also for shooter-RPGs like Mass Effect.
Remember that most of the manpower in making games is devoted to graphics, set designers, audio design, level design, etc., and there are custom editors for all of that. Many of the set pieces are usually programmed via scripting languages. Only a small portion of folks in gaming companies actually write code in low-level languages like C.
The engine takes care of this by providing a platform independence layer.
Things that varies between platforms for instance graphics library. threading, clock and filesystem etc; are implemented for each platform in the game engine.
I can make a call to the engine to render a 3D model consisting of triangles.
The engine in turn render this model by calling down into the platform independence layer which uses an implementation for the currently used platform.
There are two ways game companies do this:
1) Writing/using a multiplatform engine
2) Porting a game
A multiplatform engine will feature abstractions for platform-specific actions (making a Windows API call, rendering in DirectX vs OpenGL, etc etc) so that all of the work can be done once, then built for both machines. Usually it's a matter of writing simple wrapper methods for things like Direct3D calls and what not. Most newer game engines are being built from the ground up with multiplatform support. Others are adding multiplatform support.
If a game engine isn't multiplatform, it has to be converted to run on the target platform. This is usually a two-part operation. First, all of the API calls and interfaces with the hardware need to be redone for the target platform. The second part involves debugging and optimizing the game for performance. Typically a direct port will not perform very well, as the code will feature platform specific optimizations that do not apply to the new target platform.
For various reasons, ported games can suffer from performance issues, usually in spite of watered down visuals. Take a look at The Orange Box on PS3 or CoD: Modern Warfare for the Wii to see two examples of ports gone wrong. For the OB, Valve outsourced the task of porting the game(s) to EA. In the second instance, Activision decided that it made more sense to port a game on an engine designed for more powerful hardware over to a weaker platform instead of building the game on top of a new engine designed to get the most out of the Wii.
Many places will have separate teams responsible for different versions. That is why you always see some small differences. However, if a portable language is chosen, these teams may be able to trade code around.
If the company as produced a game engine, developers can just develop on top of that, leaving the engine to handle the cross platform specifics.
I'm guessing that the art/media department is that same for all platforms.
Actually, there are some frameworks that are meant to be able to run on multiple platforms.
For example:
The XNA Framework can run on Windows, Xbox, and Windows Phone with almost the same code base. (About 90% the same C# code can run on all of the platforms.)
Unity 3D supports PC, MAC, browsers, the iPhone, Wii, and it will soon support Android, too.
There are other such frameworks as well.
Also, most of the popular game engines (eg. Unreal, etc) are ported across multiple platforms.
This is often accomplished with a virtual machine that handles non-time-critical game mechanics and an abstraction layer for time-critical but platform-specific operations.
The particular methods are highly proprietary, secret, and are the among the most valuable assets of the game maker.
I remember reading an interview (or perhaps it was a .plan file/blog) John Carmack gave a few years ago. He was discussing developing for multiple platforms. (If memory serves this was around the time they were releasing titles for mobile platforms) The advice he gave was to always target the platform with the lowest system specs you plan on supporting first. His reasoning was that it is far easier to scale up than down. If you focus on the latest high end graphics you're likely to wind up depending on features only available on the high end. Making it very difficult to scale back for mainstream and lower end systems. Anyway, I thought it was pretty good advice.
This is all a guess because I don't work for a company that makes console games, but speaking from experience as a software developer what I imagine happens a lot of times is that external libraries are used against source code that's written in a common language, such as C++ or something. A lot of the core game code (game loop, physics stuff, etc.) can be used because the syntax is the same with the library across platforms.
However, there is a large degree of code that has to be written (and tested) that is unique to the platform. For example, most (if not ALL) graphics card-related code would have to be different for the Xbox 360 vs the PS3.
This allows for a large degree of portability on core functions and then the UI stuff and graphics-related stuff is platform-specific (not always for the UI).
Also, large game companies have 100s of developers working on a project, so they have a lot more resources than some indie developers might.
It's never perfect though. You always have to port SOME code. Unless you're using Adobe AIR, but your game is for consoles (and who uses Adobe AIR to develop REAL games?)
Game companies use commercial middleware, like RenderWare which do not come cheap. Most game platforms also support a C++ environment for code to get compiled on. Additionaly, most consoles come with a Development version (Playstations do) and there are simulators to test most code on. This middleware is now owned by EA (which is like the giant player on the field). Creating 3D games aren't just framework. Most of the game comes from a design document, which documents the flow of the game and game play. The artwork is done in other software (Maya and Lightwave for example) and the 'models' which are the game characters.
Even though it might look horrific a lot of work, when it comes to coding, it isn't that big of a deal. Writing the core functionality takes a week or eight, the rest is more in design and planning. Just remember that 3D is only 10% of the overall game. These are my two cents as a former game developer.
Not necessarily video game related, but the best walk through I've seen for doing multi-platform software was in GOF (http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612). Read the case study on the windowing system.
I would say "largely they don't." All the money is in Windows or in consoles and a lot of the consoles want an exclusive license. I have seen a few ports but they're always a separate code base branched from a previous version.
Very often they use #define (for example in C++ code) so before the compilation for the specified platform the proper code is included or used. In bigger projects sometimes the parts of a game are totally different and written in different IDE's and compiled in different (platform specific) compilers.
Example from my experience:
When I was working on a game for Nintendo Wii, we were using Torque game engine. We were programming on PC's and compiling code for PC's. When some functionality was ready we used Metrowerks CodeWarrior (with special set of libraries etc.) to compile it for Nintendo Wii, send it to the devkit and then run from the Nintendo Wii console.
This question is directed to anyone out there that is just starting in hobby game development. The first thing that comes to ones mind is:
Which language/framework should I use?
List of solutions:
Adobe Flash -> done
Allegro
Apocalyx
Blender Game Engine
Blitz3D
Devkit Pro
Game Maker
Gosu
IndieLib
jMonkey Engine -> done
Microsoft Silverlight
Microsoft XNA -> done
Multimedia Fusion / Games Factory
OGRE -> done
pygame -> done
pyglet -> done
RubygGame
SDL -> done
SFML
Torque 3D
Unity 3D
Custom -> done
Answer template:
Framework Name (Linked)
Pros:
Pro1
Pro2
...
Cons:
Con1
Con2
...
Microsoft XNA Game Studio
Pros:
Uses .NET languages; managed memory, ease of the Visual Studio environment, etc.
Good mix of high-level and low-level
Supports both 2D and 3D very well
Is proven; look at the Xbox Live Arcade, all of those games are made with XNA
Games can be easily run on a networked Xbox
Cons:
Uses .NET languages; can't use Java, C++, etc.
Not too many resources (i.e. books) out yet, though it is easy to learn and use so that may not be an issue
Windows-only. Mono (on Linux) doesn't support XNA at all.
XNA 3.0 was released less than a year after 2.0, and now we're at 3.1; frequent changes like these can hinder documentation, i.e. books get outdated quickly and many things break when upgrading a 2.0 game to a 3.0 game.
As of 2014, discontinued.
If you have the time, do it all yourself. It's worth the experience and you'll learn a lot, instead of how to work with framework X . ;^)
Pros
Full Control
Strong Learning Experience
Consistent code between game engine and program
Tends to be well-suited towards the application it is applied towards.
Supports any language/environment
Cons
High difficulty
No online documentation
Generally, less generic. Harder to apply to other games.
Harder for other people to use.
Probably buggier than more popular frameworks.
Not well-tested.
Harder to get help.
jMonkeyEngine
Pros
Uses Java; managed memory, highly supported in many mature IDE's (Eclipse, NetBeans, etc.), highly portable
Good mix and high-level and low-level
Modern 3D scenegraph
Built atop LWJGL, a very mature and well-working game library
Very lightweight; doesn't add very much overhead
Built in 3D model loading in a variety of formats.
Built in modern node-based 3D scenegraph.
Easy to use.
Open source; constantly evolving and improving.
Includes culling, collision checking, etc.
Has the option to save and read its own ultra-compact, ultra-fast binary model format.
Full list.
Cons
Uses Java, so compiles JIT and can therefore be a bit slower than C++ and other options.
Hasn't been used in many commercial apps (and therefore not as "proven").
Has no attached editor of any kind, everything must be done in pure code.
Difficult to do 2D games (for that you could try Slick).
pygame
Pros:
Easy to get started and create something visible.
Cross-platform.
Lots of open source games available to inspect the source.
Python language's pros (flexibility, dynamic typing, strings/arrays/tuples, etc.).
Cons:
Performance-wise does not scale to very large games (which hobby game development rarely is).
Mostly suited for 2D, although 3D is possible.
Difficult to distribute as closed source.
Also SDL could be inserted as pros and/or cons.
OGRE (Object-Oriented Graphics Engine)
Pros:
Tons of 3D features
Cross-platform, uses DirectX or OpenGL
Plugin architecture for even more features
Does not try to be an everything-engine, only a graphics engine (doesn't even try to handle input, as many graphics libraries tend to do)
Cons:
Uses the Singleton pattern
Very hard to do 2D or primitive rendering (individual polygons, lines, etc)
Tons of code makes the learning curve quite steep
pyglet
Pros:
Low difficulty
Cross-platform
OpenGL accelerated graphics by default
Further OpenGL graphical enhancements easy to add
Python language
Cons:
Less well-known than pygame
Game 'loop' is a bit unconventional
OpenGL knowledge required for advanced graphics and to maximise performance
SDL
Pros
SDL officially supports Windows, Mac OS X, Linux, iOS, and Android
It is used by video playback software, emulators, and popular games including Valve's award winning catalog and many Humble Bundle games.
Open source
SDL is written in C, works natively with C++, and there are bindings available for several other languages, including C# and Python.
Cons
No special IDE like Unity
A bit low-level
The pros of any framework (gaming, web, etc.) is that they remove the unnecessary boilerplate code you'd have to normally write.
The cons often come up later on, once you want to go beyond the capabilities of the framework it can become very difficult. With many of the more complex frameworks, extending their functionality to make it do something it wasn't designed to will results in you having to write a lot of your own boilerplate code.
just starting in hobby game development
You should program a few games before attempting your own framework, otherwise you don't know what to put in it and how to write it. You'll end up endlessly rewriting it to "get it right", when really there are lots of good (and bad) ways of doing it, depending on what it is used for.
"Frameworks" can also be a pain, as they offer a partial solution to a problem. E.g. you just extend a few classes and boom, you have a game. But if your game doesn't suit the framework design you just end up fighting with it and hacking it. The "toolbox" approach tends to be a better approach as it just supplied functionality without forcing you too much into how you should use it. E.g. the standard C libraries are are toolbox and don't force you to structure your code in a certain way.
To start off with you have to ask yourself:
what sort of games you'd like to write.
what you'd like to develop for?
Web browser?
Facebook?
PC?
PC and Mac? i.e. cross platform
Console?
iPhone and iPad?
which language you'd like to use (but this may be set by the platform you chose)
The learning curve for writing games can be quite steep as you might have to learn:
how to program in a new language
how a new API works
how to do the graphics and sound
how to debug it
perhaps how to hook it into other system
Don't be put off it this sounds like a lot of work! The key to writing good games is sticking it out and having the determination to carry on and finish. Have you seen the film, Indie?
My advice:
Start simple - There is a lot to learn, if you take on too much to start with you will be scared off and think it is to hard. So...
Easy language - You'll hear lots of people ranting on the internet about how great certain languages are. Well, they all have their pros and cons. Some are easier to learn that others. E.g. Python or Lua are quite easy to learn. They are scripting languages, which are a lot more forgiving and less complicated to games together with. They don't have things like pointers, memory allocation, etc to worry about.
Python tutorial.
Lua has a tutorial (which I wrote!)
Just make a game! - You'll hear other people talking about patterns and singletons and data driven design etc. None of that matters when you start out. You aren't trying to impress anyone with your code. People will judge you on the end result not the code! Trust me, some of the best games you've played on console etc have terrible code!
Use a small, well maintained library. I'll make it easy, there are other choices, but:
if you want to choose Python (a good choice!) use pygame. Use Eclipse (for Java Dev) with PyDev. Magic and free!
if you want to use Lua (a good choice!) use Love
Look for other game examples - Pygame has tons of examples and games using it. Check the license and if you are allowed, just rip the code. Patch, splice, but put a comment about where you got the code, it is polite, and may be necessary according to the license. Don't ignore the licensing.
Look at Ludum Dare. Tons of great examples and source code to see how it is done quickly.
Then once you have made a few games consider the more complicated libraries and languages. Then you can ask more specific questions about how to solve certain problems. Have fun!
Flash
Flash is a great tool for those who have limited programming or art experience, but want to start cranking out a game.
Pros:
Symbols make graphical creation and manipulation very easy
Symbols have built-in bounding boxes; bounding boxes have built-in collision detection
Ports easily to web
Built-in layers and display architecture make displaying content simple
Lots of support, documentation, libraries
Vector art is easy to create
Cons:
Relatively slow
No method or operator overloading
Requires a purchase, either Creative Cloud or buying Flash outright
Pixel art must be ported in, which can be aggravating
I highly recommend flash if you have access to it, its one of the programs I use most often.
Pro's for XNA in my opinion are that XNA apps can run on Xbox360 in addition to PC, and you can pick your favorite language from anything supported by the .NET Framework - which is quite many.
i've been making web app's and working with various server side language like php, ruby, perl for a while now. I've always been curious about game development, it's actually what I set out to do but I ended up in web development. I am trying to transition in to GD, but I cannot help see games from a web development POV.
GD = Game Development
WD = Web Development
Technical Questions.
How do you design UI in games? in WD you have CSS, and need minimal graphics to create a quick menu. are there similar tools or concepts in GD ?
How do you deal with storing data ? Do you use flat text files? Or is there something like MySQL or sqlite that you use to store information about objects, users, and etc ?
What game engines is commonly used ? Are there any that use scripting languages ? I only know VB and basic understanding of C.
With the proliferation of Iphone and Android, is J2ME being phased out for mobile phones ?
open 3D web is coming. What is your thoughts on having 3d applications running natively from your browser ?
What tools make it easy for creating 3D objects, levels, game environment, and animating characters and so on ?
Where can I find out more about how server/client, client/client, and MMORPG networking works ?
Where can I get or find generic or commonly used game flows ? for multiplayer ?
How do you deal with physics? Is there freely available algorithm or library that you can use ?
How are real time cutscenes made in games ?
Market Questions.
Which market should you enter? Mobile, iphone, wii, PSP, DS, android , ps3, PC etc.
Shouldn't you always enter mobile market, as it is easy to make small games on your own yet sell a lot ? Are there any resources where i can find more about each markets ?
What is your thought on Steam content distribution ? Is it the distribution model of the future ? Whats wrong with the traditional publisher/distributor model ? How does the traditional model work exactly ?
How big is the web games market? ex) Flash games.
How is game development different from any other software development or web development ?
I have a lot more....but those are the ones that I have been thinking about lately.
Thank you very much for reading !
UI Development
Depends on the game- is it animated, or a board-style game? Generally, UI assets are created as images, sprites, or storyboards.
Data
Again, depends on the game type. Realtime games need FAST access, so you want to store your data in a local database and cache it as much as possible. Local file-based databases tend to be the norm, either custom or off-the-shelf, such as SQLLite.
Engines
There are tons of engines out there for 3D, board, etc. Popcap has made their C++ game engine open source. Others include Unity, Ogre3D...
J2ME
I wouldn't target this platform for games.
Don't know much about "Open 3D Web" but it sounds very browser-dependent, so mileage may vary across browsers.
You can play with 3D with Google Sketchup and Caligari Truespace. Truespace was bought by Microsoft and made free.
Again, tons of engines out there for networking. Example: Microsoft's XNA framework has some networking bits you can leverage.
Not sure what you mean there.
There are physics engines built into some of the gaming engines I've mentioned, and external ones you can use.
Once upon a time, realtime custscenes were pre-rendered with 3D Studio Max or Maya. These days in-game rendering is often good enough for cutscenes: look at the latest Halo 3:ODST game. All cutscenes use the in-game engine.
Market
I looked into game development earlier this year. Casual games look to me like a growth industry- high volume, relatively low development cost. Big Fish Games for the PC is a good example there- they publish a few titles and resell most.
I think mobile game development is a huge potential market but the barriers to entry are high because it will be a crowded space. iPhone games are the 800lb gorilla but Android is coming up. PSP and others have a limited audience and are notoriously difficult.
The most important thing I learned in my research is that game development is a labor of love. It's hugely multi-disciplinary: you need programming, art, concept, production. It's more like making a movie than anything else. It's also rough to make a profit because of all that overhead. If you want to get into it, I recommend joining a game developer to learn the business. Once you have experience you can carry it forward to larger gigs at larger publishers. Eventually you can get to work on a major AAA title, after which you can really write your own ticket.
I'll stick to answering the technical questions:
1 - UIs are usually completely bespoke, with nothing resembling a standard in the same way that HTML/CSS is a web development standard. Some people use ScaleForm which is based on Flash but that is by no means common.
2 - Data is often stored in flat files - rarely text, more commonly binary. Again, these are almost always completely bespoke formats. Sometimes they are aggregated into archive files which use the zip format or something similar however. Occasionally, some programs might use sqlite, and online games often use SQL databases.
3 -There are many game engines used, although the definition of 'common' is vague. There are well-known ones like the Unreal or Source engines, down to lesser known ones like Panda3D or Torque. Some of these are heavily focused on 3D and leave much of the rest of the functionality to other packages (or the game developer themselves). Most are able to be used with scripting languages, or come with one built-in. (eg. UnrealScript).
4 - J2ME - couldn't say, that's not the sector I work in.
5 - 3D web will be interesting when it's ready, but cutting edge games currently require gigabytes of client-side data. Running the application in the browser doesn't get around that download, so it's not a great benefit. Nor is it likely to be as high performing as a dedicated 3D game renderer for quite some time. So while it opens many doors, it doesn't significantly change the state of play for gaming just yet.
6 - 3D art assets are usually made with 3D Studio Max or Maya, although there are several other related tools.
7 - MMORPG networking firstly requires understanding of basic networking (ie. strip away all the HTTP fluff and get right down to the socket level). Start with Beej, work up. From there, you're best off reading talks given at conferences and reading the Massively Multiplayer Game Development books, coupling that with anything you can find on traditional game networking. 2 good starting points are the Source Multiplayer Networking docs, and Gaffer's Networking for Games Programmers. Don't expect to understand everything the first time you read it, either. And bear in mind this is a field with ongoing research and the problems are far from solved yet. And that it's also a field where "if you have to ask, you can't do it yet". Emphasis on yet.
8 - I don't know what you mean by game flow - it's not a term I've heard used before.
9 - There are several physics libraries available, including Havok, ODE, Bullet, PhysX, Box2D, etc. Some are free, some are not. You can also write your own physics for simple games, as it's not all that hard, and indeed that is what everybody did until relatively recently.
10 - Real time cutscenes are typically either pre-animated in something like 3D Studio Max, or scripted to run within the game engine.
It depends very much on the platform you are developing for. some game engines, or platforms, have built in platform specific means of creating UI systems. An example is developing for the 360 where there is a proprietary UI system provided with the SDK tools.
However, systems like these tie you to a particular platform and this can be undesirable.
Another alternative is cross platform libraries like Scaleform, which provide game-side libraries for displaying UI elements, and a common way of editing and creating UI systems across different platforms.
The complexity of UIs in videogames varies wildly. Look at something like Peggle, compared to something like Codemaster's Dirt or EA's Dead Space. Each system is therefore implemented differently.
Some use 3D packages and the standard game engine to animate and render UIs. Others implement Flash. Others roll their own custom solutions. There's no easy choice or a standard like CSS I'm afraid!
Hope this helps,
-Tom