Logic Simplified, supported by its team of diligent, hard-working developers and animators has perfected the art of creating true-to-life games. Our Unity game developers have spent countless hours getting the right camera shot developed for various games. When you partner with us, you know you’re partnering with the experts.

What are cameras in the Unity Shooter Games 

While building Unity Shooter games, a Unity game development company creates scenes by arranging and moving objects in a three-dimensional space. However, this three-dimensional orientation cannot be portrayed, as it is, on computer screens, since those are two-dimensional. Thus, different views are needed to be captured and flattened. “Cameras,” in the context of Unity games, help accomplish this. You can hire shooter game developers to create a new shooting game mania for millions of fans out there.

In the Unity platform, a camera is an object that describes a view in a game scene. The placement of this object determines the point of view. Using the “Camera component,” the size and shape of the region that falls within the view can be decided. According to these set parameters, the camera “captures” a scene and displays it on the screen. When the camera object moves and rotates, the view on the screen also moves and rotates accordingly.

Although Unity supports several camera views, there are several factors to be considered when using these cameras. These factors are determined by the game, the gameplay, a particular scene, or gesture. Some of the factors that play an important role in camera determination and performance are as follows.

Lighting

Lighting effects in Unity work by simulating the behaviour of light in the real world. For more realistic results, detailed models of light behaviour are used, while for stylized results, simplified models are used.

Direct and indirect lighting

Unity has provisions for both direct and indirect lighting. Direct light is the one that is emitted from a source, hits a surface a single time, and is then reflected directly into a sensor (for example, the camera, in the gaming world, or the eye, in the real world). Indirect light can be defined as the light that, after emitting from a source, reflects from multiple objections and eventually falls on a sensor. This includes the light that hits surfaces several times and the skylight. Since unity provides provisions for both, realistic lighting results can be achieved by using Unity.

Real-time and baked lighting

Sometimes, lighting parameters need to be calculated at runtime. This is called real-time lighting. Unity enables adjusting lighting at runtime, which makes for a great development and playing experience.

Baked lighting is the lighting that has been predetermined by Unity by performing lighting calculations in advance. After performing the calculations, the results are saved as lighting data, which is then applied at runtime.

Unity allows using both real-time and baked lighting, or the combination of the two (called mixed lighting) depending upon the gameplay requirements.

Global Illumination

Global illumination is a combination of techniques that use both direct and indirect lighting to provide realistic lighting results. Unity allows two global illumination systems, which facilitate combining direct and indirect lighting. These are the Baked Global Illumination system and the Realtime Global Illumination system.

The Baked Global Illumination system comprises lightmapping, Light Probes, and Reflection Probes. The Realtime Global Illumination system comprises Realtime Global Illumination using Enlighten, and provides additional functionality to Light Probes.

Projections: perspective and orthogonal

Two very popular camera projections used in games are perspective and orthographic views.

Perspective Projection

In the real world, as objects move farther, they look smaller from the point of view. This is known as the perspective effect. There is a “sense of depth” included. This effect is observed not only in case of cameras, but the human eye too. This perspective effect is extensively used in computer graphics to create scenes as realistic as possible. Unity has provisions for including perspective camera renderings in games and graphical videos you might create on its platforms.

Field of View

In other words, the camera angle becomes significant when you choose the perspective view. It is measured in degrees and signifies how much of the current view would you like to include in the shot. The degree here becomes important because we are talking about perspective view and not orthogonal. Thus, how much of the scene to cover becomes important.

Orthogonal Projection

On the other hand, sometimes one may not require a perspective effect. That is, sometimes you might need to display some information or map for which a real-world, perspective camera effect may not be required. It may not be required to diminish the objects on display with distance. This is known as orthogonal projection. Unity provides an option for this too.

Thus, with Unity you can use both perspective and orthographic camera renderings, for developing your shooter game, as and how the storyline of the game might dictate.

Size

Since what the camera “sees” and shows remains static, the size of the visible region has to be determined by the developer. In orthogonal projection, the size becomes important. Because size determines how much of a region can be viewed and not the camera angle.

Clipping planes

Clipping planes are two imaginary planes that are perpendicular to the camera’s forward direction. There are two clipping planes, the near clipping plane and the far clipping plane. The region beyond these planes is not “viewed,” hence the word clipping. The near clipping plane is close to the camera and behind it lies the region that is too close for the camera to “see”. Similarly, the far clipping plane is farthest to the camera and defines the limit beyond which the camera cannot “see”.

The visible region

In both modes, perspective and orthographic, the distance to which cameras can “see” from their current position is limited. Two planes, the far clipping plane and the near clipping plane, determine the viewable region. These planes are perpendicular to the camera’s forward direction. They are called clipping planes because regions beyond these planes are excluded from rendering. The viewable range is the region lying between the two planes.

Unity Development with Logic Simplified

We at Logic Simplified understand the nuances of developing games on the Unity engine. The great news is, we enjoy the complexity! Our dedicated game designers and developers are experts at understanding the requirements of your game idea and turning it into reality. Whether you're looking to develop a first- or a third-person shooter game, our Unity game development services cover them all! Partner with us to see how we turn your dream game into reality!

The Unity version we are going to use for this game is Unity Personal Edition Version 5.5.1 f1. The reason I chose Unity game development for our FPS game is that it rids the need of using complex maths for 'movement' and 'looking around with the Mouse’.

Prerequisites to Build a Shooting Game in Unity

You need to have basic understanding of C# and maths for building your first FPS game in Unity. Besides, you need to have some knowledge of Unity app development and get familiar with the 
Unity
 interface 
and
 basic 
scripting
 concepts.

The First Shooter Elements To Consider for This Game are as Follows:

• WSAD-Maneuver & Jumping
• A weapon
• Bullets that explode when hit
• Point and shoot with the Mouse
• A decent looking level
• Something to shoot at

The most important concept in the Unity Editor is the GameObject. Every object that you want to create in your game has to be a GameObject. However, you need to add components to a GameObject to give it properties, so that it can become a character, an environment, or a special effect. You can add different combinations of components to a GameObject based on the kind of object you want to create.

Let’s begin with Project & Scene Setup

First, we are going to create a new project by going up to “File” and clicking on “New Project”. The next step is to give our new project a name and save in desired location.

Now, we will save the default scene (with desired or default name)

It’s time to create a player (Capsule). For this, you need to go to Hierarchy, as showed below. Right click on Hierarchy and choose 3D Object from the options. Doing so will bring more options, with the one called Capsule.

Click on Capsule and set the Capsule's transform in 'Inspector’ as showed below.

The next step is to make main camera child of player capsule and set its transform as showed below.

Now, we will add new script to the main camera and name it "MouseLook".

Check out the script below.

We can’t imagine our game without a ground. Therefore, we will add a Plane to the scene.

The next step is to scale the Plane to (15, 0, 0). And then, we need to add some cubes, sphere, and cylinder to our scene to make a level. We will place them randomly above the ground. If we run the game now, the player will look around.

Rename Capsule to "Player Capsule".

Now, we will add new script to player capsule and name it "PlayerMovement". The script for player capsule is mentioned below.

Continued…

Continued…

We want our GameObjects to act real when influenced by gravity or do something special under added forces. In order to make this happen, we need to add rigidbodies to our GameObjects. To add rigidbodies, we will first click on “Add Components” and then on “Physics” as showed below.

Clicking on Physics will bring us “RigidBody” with a few options as showed below (towards the bottom right). The next step is to set rigidbody constraints to ensure that player does not fall over on slight movements. Here, we are basically adding Physics to our GameObjects so that the game play appears real.

Our FPS can’t be complete without a gun. So now, we will be adding a gun in our game. Create an empty game object and name it "Gun".

The next step is to set its transform to given values.

It’s time to create a nested cube to “Gun”. Right-click on “Gun” and select a 3D Cube. Now, set cube's transform to given values showed below.

Now, attach a GunScript on Gun gameObject. The code to be pasted into it is mentioned below.

Continued...

Set the script variables to given values in the editor. For camera field drag-and-drop, select "MainCamera" which is child of "PlayerCapsule" GameObject.

No gun in any FPS game in this world is of any use until it shoots. Having said that, we will now create and add a script to make sure the gun fires whenever triggered.

To start, we will first add a new cube to the Gun object and name it Sight (Optional). We will set values as showed below to ensure the gun looks how a gun looks like.

The next step is to add an empty game object to Gun and name it "SpawnPoint". This object's position will work as a generation point for the shells of bullet when firing. The variables are showed below.

We are now going to add another empty game object to Gun and name it BulletSpawnPoint. This object's position will work as a point from where we will simulate bullet shooting via "Raycasting”. The variables are showed below.

Now, assign both "SpawnPoint" and "BulletSpawnPoint" to GunScript's variables "ShellSpawnPos" and "BulletSpawnPos". In order to help players aim at targets, we need to add the crosshair in our gun. You can download any crosshair of your choice in PNG format from the internet.

The next step is to create a 2D sprite in Gun object and name it "Crosshair" and assign it to the downloaded "sprite”.

Note: When importing the image in PNG make sure to switch image mode to sprite as showed below.

Moving forward, we need to set the Crosshair values as showed below.

Now, we will create “Shell”, for which we will create a sphere and name it “Shell”.

We will also set the Shell as showed below.

Now, add Rigidbody and ShellScript to the Shell, and set both component's values as showed below.

It’s time to create a folder in Project view and name it "Resources". Now drag n drop Shell GameObject from Hierarchy to Resources folder. We will now delete the shell from hierarchy. The final editor will look like as shown below.

That’s it! We have covered all the step to make our FPS game ready. How did you find it? Wasn’t it easy to create your first FPS game using Unity? I am sure it was. However, if you still have any query or not being able to understand anything in the tutorial, feel free share your concerns in the comment box below.