Is There a Way to Upload Unity Project Into Github

In this how-to guide nosotros show you how to gear up upwards a Unity projection for version command using GitHub.

Pre-requisites

To follow along with this guide you will need the post-obit:

• Unity

  Y'all can download and install unlike versions of Unity using Unity Hub which is bachelor hither. Information technology is worth getting a recent version of Unity because they have better support for version control. We used 2019.3.3f1 to write this guide.

• Git Client

  Nosotros'll be using the command line client in this tutorial. You lot download it, or alternatively a visual client, hither

• GitHub account

  A free account is fine to get started with. Y'all can sign-up here.

Step 1 - Create the project

• Open Unity Hub
• Click the Add button in the top correct.
• Choose the version of Unity. (we used 2019.3.3f1)
• Select the path where your new project's directory will be created.
• Requite your project a meaningful proper noun.
  • Information technology's best to avert spaces and special characters as Unity will create a directory from the projection name.
• Click Create to create your project.

Step 2 - Project settings for version control

At that place are two important settings that your Unity projection needs to have before you use it with git:

• Version Control Mode set to Visible Meta Files
  • Instructions here.
• Asset Serialization Mode gear up to Force Text
  • Instructions here.

In mod versions of Unity, these settings are the default, but it is worth checking them if your project originated in an older version of Unity.

Step three - Initialize the projection for git

• Open a Command Line Window (PC) or a Last (Mac)
• cd into your new projection's directory
• Run git init to add git conifiguration to your projection
  • This creates a hidden binder .git within the project directory to hold the files git needs to version control the projection
• Run git status to run across how git sees our project. You should meet something similar this:

            ➜  unity-meta-file-test git:(master) ✗ git status On branch chief  No commits yet  Untracked files:   (use "git add <file>..." to include in what will be committed) 	Assets/ 	Library/ 	Logs/ 	Packages/ 	ProjectSettings/  zilch added to commit only untracked files present (use "git add" to track)                      

Step 4 - Have a look inside your new project

We can run into that our new project directory contains a agglomeration of directories that Unity has created for us.

These directories contain files falling in to one of 3 broad categories:

Source files

These directories contain the files that your project is built from.

Examples of source files are the Scenes, textures, models, source code, etc. stored in the Avails/ directory.

Transient files

These files are created by Unity as you utilise it to create and build your project.

Typically they don't contain anything that can't exist created from the source files to a higher place. Examples are the asset cache in Library/ and the log files in Logs/

Local settings

These files incorporate settings that are local to you and your machine.

These files contain things like your personal preferences for window layout and the similar. Examples are files in the /UserSettings/ folder.

Stride 5 - What to commit? What to ignore?

Central indicate: This is ane of the most mutual causes of confusion when setting upward a Unity project for employ with a version control system.

In order to collaborate on your project, your teammates merely need a subset of the files from the project directory. Specifically, the Source files in the first category higher up.

Everything else tin can either by re-created from the source files or is of no interest to anyone but y'all. Nosotros need to tell Git to ignore these files so that they never get considered for version control.

Adding .gitignore

Nosotros exercise this past adding a file chosen .gitignore containing details of the files that should exist ignored.

Once we have created this file, nosotros'll add it version control so that our team mates tin share information technology. That way anybody volition have the same "clean" view of the project that excludes all of the transient and local setting files.

GitHub provide a great template .gitignore file for use with Unity projects here

If you accept gyre installed you tin can download the template direct into your project directory like this:

            curl https://raw.githubusercontent.com/github/gitignore/main/Unity.gitignore --output .gitignore                      

Alternatively, create a new file with your text editor, paste in the contents of the template from the in a higher place URL and save it as .gitignore in the root of your project directory.

Heads up: Employ GitHub's Raw button to get a view of the file that is suitable for copy and pasting.

Step 6 - Checking our .gitignore

Now, when we run git status once more nosotros should see only the files and directories that need to be added to git, with the rest beingness quietly ignored thanks to our .gitignore file.

            ➜  unity-meta-file-test git:(principal) ✗ git condition On co-operative master  No commits nevertheless  Untracked files:   (utilize "git add together <file>..." to include in what will be committed) 	.gitignore 	Assets/ 	Packages/ 	ProjectSettings/  naught added to commit just untracked files present (apply "git add" to track)                      

The directories containing transient and local setting files (like Library/) have been omitted.

Step 7 - Staging files for commit

The process of saving a prepare of changes to git is known as a commiting. We're at present fix to commit our project for the get-go time.

The commencement thing we have to practice is tell git which files we want to commit. This is known as staging the files for commit.

We run the git add together . command to phase files for commit. In this example we specify "." to add everything in the electric current directory.

One time you have staged the files, run git condition to see what has happened.

            ➜  unity-meta-file-examination git:(master) ✗ git status On co-operative chief  No commits yet  Changes to be committed:   (use "git rm --cached <file>..." to unstage) 	new file:   .gitignore 	new file:   Assets/Scenes.meta 	new file:   Assets/Scenes/SampleScene.unity 	new file:   Assets/Scenes/SampleScene.unity.meta 	new file:   Packages/manifest.json 	new file:   ProjectSettings/AudioManager.asset 	new file:   ProjectSettings/ClusterInputManager.asset 	new file:   ProjectSettings/DynamicsManager.asset 	new file:   ProjectSettings/EditorBuildSettings.asset 	new file:   ProjectSettings/EditorSettings.nugget 	new file:   ProjectSettings/GraphicsSettings.asset 	new file:   ProjectSettings/InputManager.nugget 	new file:   ProjectSettings/NavMeshAreas.asset 	new file:   ProjectSettings/Physics2DSettings.asset 	new file:   ProjectSettings/PresetManager.nugget 	new file:   ProjectSettings/ProjectSettings.nugget 	new file:   ProjectSettings/ProjectVersion.txt 	new file:   ProjectSettings/QualitySettings.nugget 	new file:   ProjectSettings/TagManager.asset 	new file:   ProjectSettings/TimeManager.asset 	new file:   ProjectSettings/UnityConnectSettings.nugget 	new file:   ProjectSettings/VFXManager.asset 	new file:   ProjectSettings/XRSettings.asset                      

You'll see that everything in our source directories have been moved to the Changes to exist comitted department at the pinnacle of the output.

Step 8 - Committing the staged files

Now we specified which files we volition be committing past staging them, let's go ahead and commit them to Git with:

            git commit -m "Kickoff commit, empty projection and .gitignore"                      

The -m option lets usa add a message describing what we have committed.

It is a skillful thought to use meaningful commit letters as they will help you understand the history of your project and diagnose problems in the future.

Pro tip! Commit letters don't need to be too wordy. For example, you don't need to repeat all of the files that y'all take changed as git takes care of that.

Conversely, they should contain enough information to allow you and your teammates to understand what each commit contains.

Lazy messages like "add together stuff" will be really frustrating if yous ever have to revisit the commit in the hereafter.

            ➜  unity-meta-file-exam git:(primary) ✗ git commit -m "First commit, empty projection and .gitignore" [master (root-commit) abc2f72] First commit, empty projection and .gitignore  23 files inverse, 2010 insertions(+)  create fashion 100644 .gitignore  create style 100644 Assets/Scenes.meta  create mode 100644 Assets/Scenes/SampleScene.unity  create way 100644 Assets/Scenes/SampleScene.unity.meta  create mode 100644 Packages/manifest.json  create mode 100644 ProjectSettings/AudioManager.asset  create manner 100644 ProjectSettings/ClusterInputManager.nugget  create fashion 100644 ProjectSettings/DynamicsManager.asset  create manner 100644 ProjectSettings/EditorBuildSettings.asset  create mode 100644 ProjectSettings/EditorSettings.asset  create mode 100644 ProjectSettings/GraphicsSettings.asset  create style 100644 ProjectSettings/InputManager.asset  create way 100644 ProjectSettings/NavMeshAreas.nugget  create mode 100644 ProjectSettings/Physics2DSettings.asset  create mode 100644 ProjectSettings/PresetManager.asset  create style 100644 ProjectSettings/ProjectSettings.asset  create mode 100644 ProjectSettings/ProjectVersion.txt  create mode 100644 ProjectSettings/QualitySettings.asset  create fashion 100644 ProjectSettings/TagManager.asset  create fashion 100644 ProjectSettings/TimeManager.asset  create mode 100644 ProjectSettings/UnityConnectSettings.asset  create way 100644 ProjectSettings/VFXManager.nugget  create mode 100644 ProjectSettings/XRSettings.asset                      

Step 9 - Inspecting our outset commit

Now that we have committed our files, let'due south run git status once again to encounter where we are at.

            ➜  unity-meta-file-exam git:(master) git status On co-operative master aught to commit, working tree clean                      

Where did all our inverse files go? They have been committed to our local git repository.

Simply if you do a directory listing we'll meet that the files are still at that place in our project directory.

                          ➜  unity-meta-file-examination git:(master) ls Assets          Library         Logs            Packages        ProjectSettings                      

The central thing to larn here is that git status merely shows the files that are different from our git repository.

Now that our changes have been committed, the repository has the same contents as our project directory. Because they match, there are no changes for git to evidence us.

Commit history

Git keeps a log of all changes that we ever committed to the repository. That's every change, to every file forth with the commit message.

This log gives a consummate history of how our projection evolved over time. Allow's take a expect at it with git log --name-merely

            commit abc2f723844a4d095335899fc1c40cb7fae14180 (Caput -> principal) Writer: UnityAtScale <57212682+unity-at-scale@users.noreply.github.com> Date:   Thu Feb 27 09:xix:45 2020 +0000      First commit, empty project and .gitignore  .gitignore Assets/Scenes.meta Avails/Scenes/SampleScene.unity Assets/Scenes/SampleScene.unity.meta Packages/manifest.json ProjectSettings/AudioManager.asset ProjectSettings/ClusterInputManager.asset ProjectSettings/DynamicsManager.nugget ProjectSettings/EditorBuildSettings.asset ProjectSettings/EditorSettings.asset ProjectSettings/GraphicsSettings.asset ProjectSettings/InputManager.asset ProjectSettings/NavMeshAreas.asset ProjectSettings/Physics2DSettings.asset ProjectSettings/PresetManager.nugget ProjectSettings/ProjectSettings.nugget ProjectSettings/ProjectVersion.txt ProjectSettings/QualitySettings.asset ProjectSettings/TagManager.asset                      

There's our commit, along with information technology's description and the files we committed.

Later on, when nosotros push the repository to GitHub, we will be able use GitHub's web user interface to browse through our commit history in a much friendlier style.

Commit hash, our commit's unique identifier

The long hexadecimal number above starting abc2f... is the hash for the commit.

This number uniquely identifies the commit. This is useful when we want to refer to the commit in future, for case if we desire to undo it, remind ourselves of what files information technology inverse or send it to colleague for review.

Step 10 - Sharing our piece of work via GitHub

Now that we accept our project in a local git repository, it is time to share it with the team. And so far nosotros take been working entirely locally. None of our work has left our motorcar.

To share our work with the team nosotros need push button the changes that nosotros have committed to our local git repository to a server or service where our team mates tin get concord of them.

Shared repositories similar this are known as remote repositories and sending changes from our local repository to the remote repository is known every bit pushing.

The GitHub service allows us to create remote repositories that are stored in the deject where they can be accessed past our team mates.

While we are using GitHub hither, there are plenty of other git services available, each with their own strengths and weakness. Some y'all might want to have a look at are GitLab, BitBucket and Microsoft Azure Repos.

Sign-upward to GitHub

The first thing you lot will need is a GitHub account. GitHub offers a variety of plans, ranging both complimentary and paid.

At the time of writing the gratuitous plan is a skillful place to get started for the purposes of this guide, only you should keep your eye on the paid plans if yous are planning to apply the repository on a larger project.

The paid plans requite you the power to collaborate with a bigger team. They likewise requite you additional storage infinite if your project includes a lot of large avails.

Sign up to GitHub here.

Pace xi - Create a repository in GitHub

Once y'all are signed up to GitHub, we demand to create an empty repository to push our local changes to.

GitHub provide a swell set up of instructions creating a new repository here

Attention Sentinel out for the visibility setting when creating your new repository.

GitHub's default for free accounts is to make the repository publicly visible which means anyone on the internet can access it.

If this isn't what you want, choose the Individual choice so the repository can merely be seen by people that you invite.

Step 12 - Setup SSH keys to access GitHub

The git customer is capable of using a variety of different protocols when connecting to a remote repository like the 1 nosotros merely setup in GitHub.

Which ane you use is up to you, merely nosotros have had good results with SSH equally it offers a decent balance between simplicity, security and flexibility.

GitHub show you lot how to setup SSH access to your GitHub repositories here. The key thing to note down is the repository URL at stop of the creation process.

It should look something similar this:

            git@github.com:<YOUR_GITHUB_USERNAME/YOUR_GITHUB_REPO>.git                      

Pace xiii - Connect your local repository to GitHub

Once you have SSH access to GitHub configured, you need tell your local repository about the remote repository. By doing this, you are letting git know where to wait when you lot button or pull changes from the local repo to the remote one.

Go dorsum to your command line session and after checking that you cd'd into your project directory, run this control to configure the remote repository, substituting the URL for your own repository.

            git remote add together origin <GITHUB_REPOSITORY_URL>                      

In our case it looked like this:

            git remote add origin git@github.com:unity-at-scale/unity-meta-file-test.git                      

Step fourteen - Push your local changes to GitHub

Now that we accept the local repository continued to the remote 1, allow's try to push our local commits to GitHub with:

            git push  ➜  unity-meta-file-test git:(master) git push fatal: The electric current branch master has no upstream branch. To push the electric current co-operative and set up the remote as upstream, use      git push --ready-upstream origin master                      

Unfortunately nosotros are seeing an error here rather than a successful button.

Git is telling us that while it knows where to find the remote repository it doesn't know which branch in that repository corresponds to the "master" co-operative in our local repository.

Git helpfully tells us how to configure the remote branch in the error message.

For simplicity it is a good idea to follow git'south default behavior and utilise consistent names for your local and remote branches. For case, the co-operative "master" in your local repository will push to the co-operative "chief" in your remote repository.

Let'southward accept Git'southward suggested configuration:

            git push --set-upstream origin master                      

At present if nosotros get back to the project in GitHub, nosotros'll see the files from our first commit like this:

Nosotros will besides see that we have a single commit, showing:

• The commit message.
• The files that were inverse in the commit.
• The commit hash.

Pro tip Discover how Github doesn't show diffs for .meta files by default.

This is considering Unity is supposed to manage them usa and nosotros shouldn't need to look into them.

This is the case most of the time but occasionally you may demand to await within them every bit we'll see in our deep dive into meta files.

Step xv - Cloning a clean copy from GitHub

Before you start inviting your team mates to the project repository in GitHub, let's verify that it is complete and ready for use.

To do that we will pull down a clean copy of the repository from GitHub in to a new directory on our car. Git calls the process of pulling a repository for the showtime time cloning the repository.

Doing a fresh clone mimics the feel that our team mates will have when they start showtime using the repository from GitHub.

Beginning, leave the directory your original project directory:

Then, clone a copy into a new directory like this, where DESTINATION_DIRECTORY is the name of a new directory that git volition clone into.

            ➜  work git clone <DESTINATION_DIRECTORY> Cloning into 'coworker-unity-meta-file-test'... remote: Enumerating objects: 29, done. remote: Counting objects: 100% (29/29), done. remote: Compressing objects: 100% (28/28), done. remote: Total 29 (delta 0), reused 29 (delta 0), pack-reused 0 Receiving objects: 100% (29/29), 15.75 KiB | seven.87 MiB/due south, washed. ➜  piece of work                      

I used coworker-unity-meta-file-test so my fresh clone will cease up a directory with that name.

Note Normally, your team mates would omit the 2nd argument and git would clone into a directory named after the repository.

Pace xvi - Test our fresh clone

Now cd into the directory containing our new clone and verify that everything is there:

            ➜  coworker-unity-meta-file-test git:(main) git status On co-operative master Your branch is up to date with 'origin/main'.  nada to commit, working tree clean ➜  coworker-unity-meta-file-test git:(principal) ls Avails          Packages        ProjectSettings ➜  coworker-unity-meta-file-test git:(master)                      

We tin meet the three principle directories Avails/, Packages/ and ProjectSettings/ which looks positive.

Step 18 - Open the project in Unity

At present permit'southward load up our new re-create into Unity and make certain that everything works.

Get to Unity Hub, add the fresh clone directory and open up it.

Annotation: You will probably run into Unity take a while "importing assets" while information technology repopulates its local caches from the source files in the project.

This will recreate the Library/ directory in your project, but yous won't see that as a change because we excluded information technology from version control above using the .gitignore.

You only tend to see see this delay when you first open up a fresh clone of the projection. Unity will and then work from your local caches, making subsequent opens much quicker.

Once Unity has opened the project, hit Play and verify that everything behaves equally expected.

If it doesn't, fix upward whatever missing files or errors and then phase and commit your changes to source control every bit described below.

Stride 19 - Committing changes

Now that your project is setup in GitHub, y'all can get on with developing, making changes to your project and committing them to git as you go.

Each time you take a set of changes fix to share with your squad, y'all'll exist going through the following process to stage and commit them in git:

• Stage the changes to commit - git add together <FILES TO Add>
• Check that the changes are valid and complete, with no missing meta files, duplicate GUIDs etc.
• Commit the modify - git commit -k "<YOUR MESSAGE>"
• Push the changes to GitHub - git push

Pro tip! Information technology is good practise to use a strategy of "little and frequently" when committing, with each commit containing a cohesive fix of changes that tin be easily described in the commit message.

For instance, a commit of ten files with the description "Add loading screen" is like shooting fish in a barrel for you and your colleagues to comprehend. When someone sees it the git history or is asked to review information technology, they can be pretty sure what those changes are supposed to reach in your game.

As a counter case, a commit of 150 files with the description "Add together loading screen, reorder high score table and add end of level ceremony" is much more than hard for people to make sense of. If nosotros discover that the commit introduced a defect, we accept a large ready of changes to pick through in order to diagnose it.

Proceed your commits small, with meaningful descriptions.

Step 20 - Movement apace past avoiding mistakes

The checking phase is where the majority of source control related issues arise with Unity. If someone forgets avails or meta files, they will break the project for the rest of the squad.

Breakages like this tin exist frustrating and plush, particularly if your squad is pushing hard to deliver a milestone.

We requite strategies for handling breakages like these in our article, Forgotten meta file? Cease the Line!, just a amend approach is to invest a little bit of endeavour to stop breakages reaching the team in the first identify. By doing this, you'll go quicker in the long run.

The key to preventing breakages is communicable problems before they become committed, either through automatic tooling or a process that people follow before they commit changes.

If y'all want to reduce the burden on your squad, automation is the way to become and our MetaBuddy plugin for Unity is a adept identify to start. Information technology finds missing files automatically and advises on how they tin be fixed, helping your squad become more confident with every commit.

The Unity Asset commit checklist gives you a template for a manual, process based approach. Can't make up one's mind whether to use a checklist or a tool? Larn from our experiences with both.

reillyuncealle.blogspot.com

Source: https://unityatscale.com/unity-version-control-guide/how-to-setup-unity-project-on-github

Share this post