Over the last few weeks, I started to create an FPS using Unreal Engine 4. After spending most of the last 12 months developing in Unity, I thought it would be a good time to switch engine and try out UE4.

As this is my first time developing anything in UE4 using both C++ and Blueprints, I decided to keep the scope of the game moderately limited. However, the concept of the game is a straightforward combat system where the player has to clear out areas of the level of enemies. Similar to the combat of the classic Star Wars: Republic Commando minus the squad. I also have some ideas to maybe have the ability for the player to have secondary objectives that they could complete alongside their main objective.

As the game is still in very early development I only have a few of the systems working and at the moment working by themselves. However, in the last few days, some systems I've been working on have come along pretty well despite still having some more way to go. The two systems, that are still in early stages, that I'm going to talk about are the Interaction and Cover systems.

There are objects in the level that the player can interact with, such as doors. These objects have many of the same components. To handle this all interactive Blueprint objects derive from a C++ class that has all of those common components. When the player gets close enough to the object they can interact with the object using the interaction key.

Projectiles are blocked by all objects in the level and as I didn't want the enemy to just stand on the spot and face the player to shoot them. I started to develop the cover system for the enemy AI to use. The AI behaviour for using cover is straightforward, if the player is in the line of sight then look for any valid cover to use. If any cover is found move into cover then attack the player, otherwise, just attack the player.

In the image above the blue lines shows the detected cover and the black line was the selected cover to move to. The enemy will move to the closest cover to itself and once in cover, the enemy will then face the player in order to attack them.

There are more systems that I've been working on and have yet to create, which I plan to write more blog posts about in the coming weeks.

My Fire Propagation System designed to provide a solution for fire propagation in outdoor environments for games developed in Unity has been released. The Fire Propagation System can be downloaded from the Unity Asset Store for free at: www.assetstore.unity3d.com

For more details about the development or for videos on how to use the Fire Propagation System go to the Unity Asset Store or check out my details page about it.

I've just returned from spending a week in San Francisco to attend my second Game Developers Conference (GDC 2017).  Before I left for America I did wonder "if my second GDC would be as great as my first GDC or a greater experience?". It was greater and let me tell you why.

However, before I do that for those who are reading this post and are thinking "what happens at GDC to make it so great as I've never been before?" or "I'm thinking about going but not sure if it's for me?" I would encourage you to read my blog post from last year about attending GDC 2016, for an insight into what an incredible 5-day experience GDC is.

Back to GDC 2017. I attended with a Bootcamp pass that allowed me to attend a wide range of summits on the Monday and Tuesday. The AI, Community Management, Mobile and Game Narrative summits just to list some of the summits that took place.

The summit that I attended the majority of was the AI summit, which had a number of great talks. There were two sessions that really stood out to me from the other great sessions. The first was about managing crowd AI in Watch Dogs 2 (Ubisoft) and the second was about how asynchrony can be used for AI tasks (Havok).

For the last three days, I spend my time between seeing sessions covering a range of different topics, exploring the expo halls and meeting up with friends, most of whom I haven't seen since GDC last year. This is what GDC is about, not only do people from the Games Industry present the cutting edge techniques and technology they developed in their games and game engines that they've been working on to their fellow colleges in the Industry. But it is also a great opportunity to catch up with friends and make new friends, there are many people who attend GDC for the networking opportunities rather than the sessions.

The networking side of GDC wasn't anywhere near as daunting for me compared to last year. Even before I had boarded the plane in the UK, I was talking with people who were also attending GDC. It's not hard to figure out who's going to GDC and start a conversation (well this bit can be a little bit more difficult) with them when most of the people sitting around you are waiting for the same plane and for many of the same reasons as you. For those reading and looking for ways to make networking a less stressful experience, I'm afraid I don't have any answers for you other than to say the more you do it the easier it is to meet and talk with others which in its self is an easier said than done bit of advice.

A week of attending sessions, catching up with friends, making new friends, networking and travelling are what made GDC 2017 a great week. To answer the question I had before leaving for the conference, the main reason why my second GDC was greater than my first was that I knew what to expect, how to get more out of GDC and did get more out of GDC this time round.

After having a long end of term at University I was very much looking forward to the few weeks we have off for the Christmas holidays, in fact, I hadn't really given any thought to the time of year it was until the first day of my holidays.

On that first day of the holiday, I could have spent it doing very little other than relaxing after all its mid-December right? Well no, after so many weeks of working and little sleep I just had to do something so what is the best thing that I could do, easy, start making a game. Yes, many people would have answered with sleeping or Christmas shopping, but where is the fun in that?

I've made a few games before but unlike all of my previous games, this time I wanted to make a game that was 3D and bigger than any other game that I've made before. So I spent some time taking my ideas and turning them into designs that could be used in the game, the result of which is a Dungeon Keeper style game called "Dwarf Underworld" where the player manages and builds up a Dwarven underground city to provide the resources to create an army to reclaim their lost treasure that has been taken by the goblin hordes that live in the same underground caves as the players' Dwarfs do.

After spending a couple of days working on my game, I've been able to get world and resource generation, basic AI pathfinding, the player economy and basic building/unit construction implemented. There is still more systems to develop and I will write more posts in the future detailing where I've got to with development, but for now I'm going to leave this post here.

In the last tutorial, we had set up the texture and framebuffer to do a shadow pass, in this tutorial, we are going to use the depth texture from the shadow pass and use it in the second pass which will draw the scene with lighting. I'm going to call the second pass the lighting pass as we perform the lighting calculations in this pass. I have used two shader programs, the first program has the shadow vertex/fragment shaders and the second program has the lighting vertex/fragment shaders.

In the shadow pass, we created a Model-View-Projection matrix from the lights' position, in the lighting pass we are going to create a Model-View-Projection matrix from the camera's position.

// MVP from camera position
glm::mat4 model(1.0f);
glm::mat4 view = glm::lookAt(m_camera, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 projection = glm::perspective(45.0f, scrennSize.x / scrennSize.y, 0.1f, 100.0f);
glm::mat3 normalMatrix = glm::transpose(glm::inverse(model));

The normalMatrix will be used as a uniform in the fragment shader for normal calculations, we will come to this in a bit. The rest of the lighting pass is very simple on the C++ side as we just have to set up the uniforms, bind shader programs and textures:

// set the viewport and bind resources
glViewport(0, 0, (size_t)scrennSize.x, (size_t)scrennSize.y);
glUseProgram(programLighting);
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_2D, texture_id); ///< just a texture we will use in the scene
glUniform1i(glGetUniformLocation(programLighting, "texture"), 1);
glActiveTexture(GL_TEXTURE0 + 2);
glBindTexture(GL_TEXTURE_2D, shadow_id); ///< the shadow texture
glUniform1i(glGetUniformLocation(programLighting, "shadowMap"), 2);

// set the uniforms for matrices etc.
glUniformMatrix4fv(glGetUniformLocation(programLighting, "depthBiasMVP"), count, false, &depthBiasMVP[0][0]);
glUniformMatrix4fv(glGetUniformLocation(programLighting, "modelMatrix"), count, false, &model[0][0]);
glUniformMatrix4fv(glGetUniformLocation(programLighting, "viewMatrix"), count, false, &view[0][0]);
glUniformMatrix4fv(glGetUniformLocation(programLighting, "projectionlMatrix"), count, false, &projection[0][0]);
glUniformMatrix3fv(glGetUniformLocation(programLighting, "normalMatrix"), count, false, &normalMatrix[0][0]);
glUniform3f(glGetUniformLocation(programLighting, "gammaCorrectness"), 1.0f / 2.2f, 1.0f / 2.2f,  1.0f / 2.2f);
glUniform3f(glGetUniformLocation(programLighting,"eyePosition"), m_camera.x, m_camera.y, m_camera.z);
glUniform3f(glGetUniformLocation(programLighting, "ambientColour"), 5.0f / 255.0f, 5.0f / 255.0f, 5.0f / 255.0f);
glUniform3f(glGetUniformLocation(programLighting, "light.colour"), 75.0f / 255.0f, 75.0f / 255.0f, 75.0f / 255.0f);
glUniform3f(glGetUniformLocation(programLighting, "light.position"), lightPos.x, lightPos.y, lightPos.z);
glUniform1f(glGetUniformLocation(programLighting, "light.shininess"), 90.0f);

// draw calls
objDrawCall(planeObject);

// need to recompute the MVP for each object in the scene and set the uniforms for it.
glm::mat4 depthM = m_sphereObject[i]->getMatrix();
depthMVP = depthProjection * depthView * depthM;
depthBiasMVP = biasMatrix * depthMVP;
glUniformMatrix4fv(glGetUniformLocation(programLighting, "depthBiasMVP"), count, false, &depthBiasMVP[0][0]);
glUniformMatrix4fv(glGetUniformLocation(programLighting, "modelMatrix"), count, false, &m_sphereObject[i]->getMatrix()[0][0]);
glUniformMatrix4fv(glGetUniformLocation(programLighting, "normalMatrix"), count, false, &glm::transpose(glm::inverse(m_sphereObject[i]->getMatrix()))[0][0]);

objDrawCall(sphereObject);

glBindTexture(GL_TEXTURE_2D, 0);
glUseProgram(0);

Key points about the about is the depthBiasMVP that is used to convert the results from the shadow pass from [-1, 1] to [0, 1] so we can use it like a texture using UV's, this is computed by:
glm::mat4 biasMatrix(
        0.5, 0.0, 0.0, 0.0,
        0.0, 0.5, 0.0, 0.0,
        0.0, 0.0, 0.5, 0.0,
        0.5, 0.5, 0.5, 1.0
);
glm::mat4 depthBiasMVP = biasMatrix * depthMVP;

Gamma correctness is set as a uniform and this will be used at the very end of the fragment shader to apply gamma correctness to the final fragment colour before writing it to the framebuffer. Some of the uniforms are 'light.xxxxx' we will use a light structure within the shader, which works that same way as a struct in C++ for reading/writing to. We have set up the uniforms for our shaders, now for the shader code:

vertex shader:
#version 330
layout(location = 0) in vec4 position; ///< the vertex co-ordinate from VBO
layout(location = 1) in vec3 normal; ///< the normal from VBO
layout(location = 2) in vec2 uv; ///< the UV co-ordinate from VBO

// uniforms
uniform vec3 eyePosition;
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionlMatrix;
uniform mat4 depthBiasMVP;

// output to fragment shader
out vec2 vs_uv;
out vec3 vs_fragpos;
out vec3 vs_normal;
out vec3 vs_position;
out vec3 vs_lightDir;
out vec3 vs_halfVector;
out vec4 vs_shadowCoord;

// light
uniform struct Light
{
  vec3 position;
  vec3 colour;
  float shininess;
} light;

void main()
{
  // compute the world, view and clip spaces
  vec4 worldPos = modelMatrix * position;
  vec4 eyePos = viewMatrix * worldPos;
  vec4 clipPos = projectionlMatrix * eyePos;

  gl_Position = clipPos;
  // set the outputs to fragment shader
  vs_uv = uv;
  vs_normal = normal;
  vs_fragpos = worldPos.xyz;
  vs_shadowCoord = depthBiasMVP * position;

  // compute the light direction and length
  vec3 lightDir = vec3(light.position - worldPos.xyz);
  float lightDis = length(lightDir);

  // basically the same as doing normalize
  vs_lightDir = lightDir / lightDis;

  // compute the half vector
  vs_halfVector = normalize(lightDir + eyePosition);
}

Fragment shader:
#version 330

uniform sampler2D texture;
uniform sampler2DShadow shadowMap;
uniform vec3 gammaCorrectness;
uniform vec3 ambientColour;
uniform mat3 normalMatrix;
uniform mat4 modelMatrix;

in vec2 vs_uv;
in vec3 vs_fragpos;
in vec3 vs_normal;
in vec3 vs_position;
in vec3 vs_lightDir;
in vec3 vs_halfVector;
in vec4 vs_shadowCoord;
out vec4 output_colour;

uniform struct Light
{
  vec3 position;
  vec3 colour;
  float shininess;

} light;

void main()
{
  // what pixel colour is the texture for this Uv position
  vec4 diffuse = texture2D(texture, vs_uv);
  vec3 normal = normalize(normalMatrix * vs_normal); // the normal

  // compute the amount of diffuse and specular
  float diff = max(0.0, dot(normal, vs_lightDir));
  float spec = max(0.0, dot(normal, vs_halfVector));

  // normals that face away from the light cannot be lit
  if(diff == 0)
    spec = 0;
  else
    spec = pow(spec, light.shininess);

  vec3 surfaceToLight = light.position - vs_fragpos;

  float brightness = dot(normal, surfaceToLight) / (length(surfaceToLight) * length(normal));
  brightness = clamp(brightness, 0, 1);

  // in shadow or not
  float visibility = 1.0;

  // calulate shadow using smapler2DShadow
  visibility = textureProj(shadowMap, vs_shadowCoord);

  // compute if the light is directly or indirectly hitting the camera and clamp the results
  vec3 scatteredLight = ambientColour + light.colour * diff;
  vec3 reflectedLight = light.colour * spec * brightness;
  scatteredLight = clamp(scatteredLight, 0, 1);
  reflectedLight = clamp(reflectedLight, 0, 1);

  vec3 finalColour = vec3((scatteredLight * diffuse.rgb + reflectedLight) * visibility);

  // apply gamma correctness
  vec3 gamma = vec3(gammaCorrectness);
  finalColour = pow(finalColour, gamma);

  // output colour
  output_colour = vec4(finalColour, diffuse.a);
}

If you compile and run the program you should have an output result something like:

I have not gone over how to load models or textures but if you are interested in how I have done it, or see any of the other source code, you can find it here: https://github.com/LewisWard/Shadow-Mapping