Unity3D Web Fundamentals with C#

This course is an introduction to Unity3d from a developers point of view. It covers the fundamental developer concepts for developing scalable Unity3d games or applications.
Course info
Rating
(101)
Level
Beginner
Updated
Dec 10, 2013
Duration
3h 34m
Table of contents
Description
Course info
Rating
(101)
Level
Beginner
Updated
Dec 10, 2013
Duration
3h 34m
Description

This course is an introduction to Unity3d from a developers point of view. It covers topics such as proper project organization, understanding the main software extension model for Unity, called MonoBehaviours, working with the Unity web player and how to create shared object models between your client and server. This course has the developer in mind, but is useful for anyone who is looking to gain a more solid framework for building scalable 3D applications.

About the author
About the author

Tracey is co-founder of InContext Solutions, a Chicago based leading global supplier of simulated market research. Most of his career has been spent using Microsoft technologies, and lately the Unity 3D game engine which allows him to mix video games with business.

Section Introduction Transcripts
Section Introduction Transcripts

Coroutine Fundamentals
Hello. This is Tracey Wiedmeyer, and this module is Coroutine Fundamentals. This module is going to cover five important concepts. The first one is an introduction to Unity coroutines. Here we're going to be talking about exactly what coroutines are, and how they should be used. Then we're going to cover a few coroutine demos in terms of how to call them when you're implementing them in your game, or your business application. There're two main ways to implement coroutines, and we'll cover them both. Then we'll cover some practical coroutine uses. How do you typically see them used in video games, or business applications, and then we'll get into how we use those to access the web in Unity. There we'll do an in-depth coverage of the WWW object in Unity, which itself is a coroutine, and gives you access to reading and writing data from remote web services. Lastly we'll talk about the game loop impact that coroutines have, where in that Update loop they're called, and how Unity keeps track of them.

Introduction to the Unity Web Player
Hello. This is Tracey Wiedmeyer, and this module is Intro to the Unity Webplayer. In this module we're going to cover an overview of the Unity Webplayer, including an overview of their plugin architecture. Next, we'll actually install the webplayer and take you through that process. Then we'll build a webplayer with the Unity project that we've been working with throughout the last few modules, including an overview of the output files and how they fit together. Then we'll talk about the security sandbox that the Unity Webplayer forces us to play with. And finally, we'll deploy a webplayer, and take you through that process, allowing you to get your game ready for web play.

Scripting the Unity Webplayer
Hello. I'm Tracey Wiedmeyer, and this module is Scripting the Unity Webplayer with C# and jQuery. So during the last module we talked about what a webplayer was, how do we build it, what are the security restrictions, and how do we actually run it in our browser? During this module we're going to look at some more advanced topics, the first one being how do we pass data into the webplayer from our web page? So, there're oftentimes when you're HTML page needs to notify your game of certain events. This is how we do that. Now I'm going to do that in reverse. We're going to send data into our web page from the game. So if we think about that paradigm, there're certain times when your game needs to notify the web page of certain events, maybe the game is over, maybe it's going to request some data, so we're going to go through that. And lastly we're going to look at some more complex message passing techniques between the browser and the plugin to make that process more streamlined, and a little more maintainable.

Shared Object Technique for Web Services with C#
Hello. I'm Tracey Wiedmeyer, and in this module we'll discuss Shared Object Technique for Web Services with C#. So during this module, we'll give an overview of the shared object technique, which is basically a way to use shared objects between your Unity frontend and your web services backend. We'll talk about how do we actually setup the shared object model, and how do we get Unity and Visual Studio playing nice together with the same object model in mind. We'll show a server side implementation using our ASP. NET MVC Web API project, and then we'll go into the Unity Editor and show our client side implementation.

Complete Unity3D Example
Hello. I'm Tracey Wiedmeyer, and this module covers a Complete Unity3D Game Example. It's taking everything we've learned in the previous modules and putting it all together in an end-to-end example. During this module we're going to cover an overview of our game example. How does our game work? How do we play it? How does it allow us to take the things we've learned in the previous five modules and put those together in an end-to-end example? Through that process we'll look at the workflow of our game. There're four specific workflows we'll cover. Basically, the entry of the game, the game engine startup, game play, and then the game over workflow. And then we'll actually do a demo of our game and see how good we are.