How did I deal with…

Establishing Guidelines for Real Time 3D Production Pipeline

The goal of this project is to develop a general gameplay program in C++, testing it on one prototype level and enabling it to escalate into a whole video game.
This is what this project looks like at the block out stage:

What happens when you press E key — The Interface destroys the pickup geometry and triggers Events when you press the "E" key.

All functionalities are working
I solved all communication issues between nodes – including UI – using an Interface and some Delegates
The project's execution lacks refined models, rendering, animation, and VFX.

These are the guidelines steps that I'm taking:

Planning Contents
Buying Hardware
Pre-producing Interaction
Pre-producing Art
Producing Interaction, Part 1
Producing Art, Part 1
Producing Interaction, Part 2
Producing Art, Part 2
Post-producing Project

1. Planning contents

I'm developing the General Idea by:

Choosing a genre (3rd person, adventure, story rich, sci‑fi)
Deciding to program for PC first, and leaving other platform deployments for post‑production
Writing a design document including a basic plot, describing the gameplay, core storytelling for tone, mood, and features, for instance:
What the player has to do to fulfill a mission and progress to the next level.

Writing a Team Plan consisting of:

Developing Details, like defining goals, audience, graphic design and pre‑production (concept art, storyboards, etc.), setting deadlines, defining mechanics, telling a story, UI contents, where do the assets come from, etc.
One Game Design Document, including game world, game mechanics, character, story, UI functions, audio, prototype, documentation, etc.

One Page Design

This is the One Page Design for this project:

This document can be revisited by any stake holder and contains all the general logic of the project, including the conclusion.

I'm Programming this project using Unreal Engine Blueprints, and their C++ API:

Prototyping one level using placeholders and refining the programming until it matches the benchmarks I'm setting for the production phase
Leaving scalable and reproducible programming to C++, and
On the opposite, leaving the local and level‑exclusive changes to Blueprints, so that we don't have to bother a programmer every time I have to, say, update text chunks in the UI.

I'm creating all Assets from scratch, except for the animations, borrowing MoCap from Unreal's market place and Mixamo.
That means that I'm executing the whole pre and production DCC pipeline (ZBrush, 3DS Max, Maya, Substance, V-Ray, etc.) plus programming, interaction and UI in Unreal Engine.

2. Hardware

I'm working with SSD Hard drives, an NVidia GPU and 2 Monitors
Using Cintiq for all 2D, sculpting in ZBrush, weight painting, etc.
DINA3 Scanner for all the pre‑production material, and
English keyboard for efficient programming.

3. Pre‑producing interaction

I'm drawing a storyboard to have an overview of the interaction before defining the tasks and the UI. Click on the arrows to progress through the vignettes.

Carousel showing interaction. Click on the arrows to progress through the vignettes.

Once I have this overview, I can plan the details of the interaction.
As you can see, I am going to need:

A list of collectibles
Input actions to collect them
A list of messages
A counter to lock/unlock the exit doors when all collectibles are collected, and
Scalability in case we want to add a combat mode in the future.

4. Pre‑producing art

These are the steps I'm following to pre‑produce the art in this project:

Doing Research, in this case about player character and what she should look like. I'm also basing the look and feel of the prototype's level on the ancient Persian architecture.
Sketching out level, VFX and characters. Here you can see a floor plan of the level for blocking out before modeling:

Floor plan layout — Thanks to the floor plan layout I know sizes and proportions before I start modeling.

Developing Characters, including questionnaires, construction, poses, expressions, and clothes sheets, turnaround, etc. This is the turnaround of my player character:

Protagonist turnaround — A turnaround should solve all foreshortening situations in character development.

Developing Environments, floor plans and elevations are the main part of this process, but also includes modularity and, planning ahead, texturing:

Covered bazaar — Architectonic 2D representation of the future model (floor plan and elevations), including modular parts.

Additionally: Props, Concept Art, User Interface and Storyboards & Animatics. If you want to see more about art pre‑production, visit these case studies:

Character Sheet for Video Game

Character sheet example from a video game project, including silhouettes, poses, expressions, clothes and gear, variations, turnaround and 3D block out.

Level Layout for Video Game

Drawing a Level layout for a video game as part of the pre production process, using CAD floor plans and elevations and blocking out the level in 3D.

5. Producing interaction. Part 1

The main part of the production at this stage is to make a prototype in Blueprints (BP), test it, and rewrite it until it works.
Once the prototype is functional, we can proceed to program the basic interaction in C++. I'm using:

An Actor Component on my player character driving the Interaction through:
An Input Action
Overlapping the collectible BPs, and
Sending messages to UI using Event Dispatchers

This is the counter node, calling an update through the interface:

Pickups counter Blueprint — The pickups counter updates the number of collected items.

This function just checks out whether the pickups have the interface implemented:

Blueprint checking out Interface implementation — This function loops through the pickups, eliminating those that don't have an implemented interface.

Here, I'm sending a message via Event Dispatcher to the UI, to tell the player they have only one item left before unlocking the exit gates:

Blueprint reaching penultimate pickup — The counter triggers this Event Dispatcher when it reaches `TotalItems` -1, updating the UI.

And here is the last function, checking out whether we have collected TotalItems and can go to the next level:

Blueprint reaching all pickups collected — When the counter reaches the total number of pickups, it sends several messages to update the UI, for example, unlocking the exit gates.

With these functionalities working (and some more for the gates, counter, game mode and pickups), we are in the position to draw some schematics for the C++ programming:

C++ Logic Schematics — Schematics showing translation from Blueprints to C++ logic.

These case studies show the later implementation from BP into C++ for this gameplay:

Programming video game interaction with C++

Programming interaction

The C++ Interface is able to identify when the player picks up an item, adds to the counter, loops remaining and sends delegates when all collected.

Implementing Interface for video game with C++

Implementing C++ Interface

The C++ interface becomes active when overlapping items, sends delegates when the player clicks the “E” key, modifying the environment and other actors.

Delegates for UI & Gameplay

Using delegates sent by the interface to push text updates in the User Interface and trigger behaviors in the environment, like opening doors.

Programming Gameplay with C++ for Unreal Engine

Programming Gameplay C++

Programming interaction for gameplay in C++ for Unreal Engine, using an interface, delegates and 2 bases for pickups and doors.

6. Producing Art. Part 1

At this stage of the project, we need some objects to apply our programming to. I'm blocking out environment and characters to ensure that my programming is acting on the definitive sizes, animations and weights.
This is what my blocking out and provisional models for the environment look like:

Block out to model — Comparing block out and model architecture in 3DS Max.

And this is what my character looks like at this block out stage, including a provisional rigging to reuse the animations from the 3rd person character template in Unreal Engine (UE):

Character block out — Block out phases of character (from ZSpheres to rigged topology) and inside the level block out.