Creating a Node Based Editor in Unity 3D
4.3 (38 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
171 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Creating a Node Based Editor in Unity 3D to your Wishlist.

Add to Wishlist

Creating a Node Based Editor in Unity 3D

Learn how to build your own custom Node Based editor directly inside of the Unity Editor, step by step.
4.3 (38 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
171 students enrolled
Created by Gametutor :-)
Last updated 12/2015
English
Price: $20
30-Day Money-Back Guarantee
Includes:
  • 4.5 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Learn to create a visual node editor in Unity 3D
  • Learn to build custom Editor UI's with ease!
  • Learn to build your own Custom Editor Windows in Unity 3D
  • Understand how to create and save data created in your custom editor
  • Actually understand how to create visual nodes in a custom editor that can be hooked up into other nodes to produce logic.
View Curriculum
Requirements
  • You'll need a copy of Unity 3D
  • Basic Understanding of C#
  • Familiar with Unity and its interface
Description

Game development requires the involvement of many different types of disciplines and people to complete. Often times the Game engine or software used to make the game, is very technical making it difficult for some disciplines to work efficiently in. This is where the creation of artist / designer tools come into play. As a unity developer, learning how to create Visual Editor Tools for artists and designers is crucial to the productivity of your game development production.

This course will guide you through the process of developing your first visual node based editor that can be used for any sort of game development task. It will give you the underlying knowledge of saving out your nodes data, giving the user the ability to connect nodes, create nodes, and delete nodes. By the end of this course you will have a fully functional node based editor that you can extend to meet the needs of your game development project.

Who is the target audience?
  • This course is intended for anyone wanting to create their own custom game tools and editors within the Unity 3D game engine. Having a basic understanding of C# in Unity is all you will need to take this course.
  • If you are just starting out with Unity then it is recommended that you explore more of the C# language and understand how to create basic custom editors in Unity3D.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
Expand All 21 Lectures Collapse All 21 Lectures 04:26:57
+
Introduction
2 Lectures 06:58

In this first lecture we are simply going to walk through the final Node Based Editor that we are going to create!

Preview 02:02

With any new tool development or project, it is always a good idea to isolate out your development environment in a new unity project. So let's create our new Unity project and get our folder structure stubbed in and ready for coding.

Preview 04:56
+
Building up the Base Editor
6 Lectures 01:13:58

With our new Unity project set up, we will now start the coding process by creating all the scripts we will need. By the end of this lesson we will have each empty script ready for us to fill in with our actual code.

Preview 04:36

The first step in our Node Based editor development, is to get the editor window, where the user will interact with nodes, drawing so we can further develop the different views that we will need.

Getting the Editor Window Running
08:24

This lesson will focus on creating a more flexible view system through the process of class inheritance. We will develop a base class that all editor views will have, then extend that base class to include only the specific functions that each view will have to do. This will give us the flexibility to create many different types of views, and remove the process of duplicating code.

Developing our View System
20:45

With our view system coded and our class structures working, let's now get our views to actually draw some GUI in the Editor Window.

Drawing Views
16:00

In order for users to interact with the editor, we will need to read in input events from the mouse and keyboard. By the end of this course we will have working input events we can use to develop rich user interaction.

Editor Events
11:47

With the meat of our editor up and running, let's start to lay in the foundation to style the editor GUI, so we can really customize the look of our Node Based tool.

Creating the GUISkin
12:26
+
Creating Data
6 Lectures 01:35:04

Now that we have our Editor window and views drawing, let's get our data structure up and running. We will need this data structure to save and house all the nodes data so we never lose our graphs that we create in the Node Editor.

Developing our Data Structure
20:09

Understanding how to work with Scriptable objects and the Asset Database, we will be able to serialize all our graph and node data. This lesson will walk you through the steps necessary to get your data created and saved between user sessions. By the end, you will have working graphs ready to have nodes added to them.

Creating Data
11:36

Giving artists and designers the ability to work quickly is key to an efficient pipeline. The use of context menus allows users to quickly access graph and node functionality from the right mouse button. Ultimately this allows anyone to the ability to create new nodes and graphs without having to navigate to a menu.

Context Menus
20:45

With context menus we can perform all sorts of operations that allow users to quickly get work done. This lesson will walk you through how to Load and Un-Load a graph from the database.

Loading and Un-Loading
10:46

This lesson will now take us through the process of adding new nodes to our graph data. We will learn how to utilize the Asset Database to add sub-objects to our graph asset.

Creating Nodes
16:40

Now that we are able to add nodes to our graph, as a data representation, let's learn how we can get our nodes to draw in the Editor Window.

Displaying Nodes
15:08
+
Refining the Nodes
5 Lectures 01:21:17

When developing a node based editor, we have to make sure we are keeping track of which node is selected, which node we are editing and whether or not we are in a node connection mode. By the end of this lesson, we will be able to select nodes, edit them, giving us a nice framework to manage our nodes.

Node Management
18:13

No node editor would be complete without inputs and outputs. Throughout this lesson we are going to look at how we construct inputs and outputs on our nodes, so that we can begin to connect them together.

Inputs and Outputs
19:26

Now the real fun comes into play. We have all these great nodes drawing in our Editor Window, we can move them around, select them, and deselect them. So let's learn how we set up our code to allow user to connect nodes together.

Node Connections
20:21

This lesson will finalize the nodes system, by showing you how to delete nodes, and show their properties in the property view, completing the Node editor in general.

Completing Nodes Part 1
11:18

In the second part of the completing Nodes lecture we are going to cover how to take the information in the nodes themselves and display them in the properties window.

Completing Nodes Part 2
11:59
+
Final Touches
2 Lectures 09:40

Any good node based editor has a larger space to work with the nodes, and also has a nice grid background to fill in the space. Throughout this lesson we will create a way in which we can pan the graph view, as well as draw a grid in the background.

Drawing the Grid
07:26

In our final lesson of the Node Based Editor course, we will review what we have learned and talk about where to go next with your Unity tools programming adventures!

Conclusion
02:14
About the Instructor
Gametutor :-)
4.4 Average rating
112 Reviews
450 Students
6 Courses
Teaching Game Development and Technical Art since 2013!

Gametutor teaches the latest in game development and technical art for Unity 3D, Houdini 14, Houdini Engine, C#, and Substance Designer. Gametutor has been teaching industry professionals, online, for over a year and a half, and continues to push the boundaries of game development education.

Noah Kaarbo (Co-Creator / Designer / Entrepreneur), has worked in the Game Industry for over 14 years. He has helped ship over 20 AAA titles, ranging from Halo Reach to countless Forza, Call of Duty, and infamous franchises. He is proud to be contributing his skill sets to Gametutor.

Kenny Lammers (Co-Creator / Instructor / Programmer / Technical Artist) has worked in the Game Industry for over 14 years, for large game companies such as Microsoft Games Studios, Activision Blizzard, Surreal Software, Eline Media and Amazon. He has a deep knowledge of C# programming, Shader Development for Games, General Technical Art Techniques, Modeling, Texturing, and Teaching. He has taught course online, for Digipen, and for the University of Washington.

Our Goal with Gametutor is to bring the highest quality Technical Art and Programming training, to the masses, and show how awesome game development can be!