
### The Problem
While working on my flappy bird remake (Rocket Robot), I came across a problem. The problem was that I need to have pillars at different heights but I was using the same mesh for each pillar. This meant I needed to stretch the entire pillar in the Z access to get an assortment of different heights.

![Streched Pillars](Stretchpng.png)

### 9-Slice Scaling
While working at one of my previous employers as a Game Developer, I was often working with UI’s and Buttons. This reminded me of a similar problem we had with the button texture not always coming out looking the same on different buttons. The solution to this was 9-slice scaling.

9-slice scaling is an image rescaling method where the 4 corners are kept in the same proportions while the middle sections are scaled. This helps keep those rounded edges no matter the side of the image.

![Streched Pillars](483px-Traditional_scaling_vs_9-slice_scaling.png)
Image *[Wikipedia](https://en.wikipedia.org/wiki/9-slice_scaling)*


### Solution
This gave me the idea for my solution. Unfortunately, in Unreal Engine you can’t scale parts of the Static Mesh, or at least I don’t know of any ways to achieve this. My method involved cutting my mesh into 3 separate sections: a top, middle and bottom.

![Pillar onstruction](Pillar_Construction.jpg)

I then created an Actor that took the three meshes and positioned them together so it looked like there were no splits in the mesh. I then wrote code that would change the scale of the middle section and keep the top piece at the correct height.

The scale of the middle section was worked out backwards. I would get a random pillar height ( within a range), subtract the top height and bottom height. Taking the current middle height, divide it by the remaining height and that gave me the scale that was needed.

```cpp
	float TopMeshHeight = MeshTopSize.Z;
	float BottomMeshHeight = MeshBottomSize.Z;
	float MiddleMeshHeight = MeshMiddleSize.Z;
	float MiddleMeshNewHeight = (PillarTotalHeight) - (TopMeshHeight + BottomMeshHeight);

	float UpdatedScale = MiddleMeshNewHeight / MiddleMeshHeight;
	MiddlePillarSize = FVector(MiddlePillarSize.X, MiddlePillarSize.Y, UpdatedScale);
```
### Conclusion
Obviously the middle section is stretched, but the top and bottom sections keep their ratios which was perfect for my use case. This could still be improved on by taking a smaller section that would scale better or using a mesh that wouldn’t be as noticeable when stretched.

![Final Image](Pillar_Out_Come.png)

Ultimately I was happy with this solution and thought I would share the idea. Maybe it will give someone else an idea.


Solution I found for streching pillars in Unreal Engine to better keep the aspect ration.

A Better Way of Streching Meshes In Unreal Engine


Hi there! 👋

I’m SylarAtomic - Welcome to my dev blog! I’ve been a developer professionally for 3+ years. Back in 2019, when I started my first job, I worked as a game developer creating HTML5 games using JavaScript and Pixi.js. This was my first introduction into the world of creating games. After working for that company for 2 years, I moved to my current company, which focuses more on 3D architecture. I’ve worked here as a developer creating 3D webpages to help our clients sell apartments and houses. 


### Back in the day
Ever since I got my first computer, I've been interested in finding out how things worked. This didn’t always please my parents when they came home to find that I had taken my first computer apart, but I always managed to put it all back together, and it still worked, so that was good news!

As I got older, I continued to be curious and when it came time to choose a degree to study, I went with a BSc Computing. I wouldn’t say a degree is completely necessary to develop games, but as I’ve found in the software field, it's one of those things that isn't needed until it's needed. When you have a degree, no one asks for it; when you don’t, everyone wants one. Ultimately, I am glad I got my degree first.

![Developer Working](GameDev.png)
Image from *[Medium](https://miro.medium.com/max/1400/1\*KbYaeKKyTGzNTKjIiBzb3w.png)*

### Full Game Dev Mode
At the beginning of 2022, I decided that I wanted to move my career back towards game development: this time towards PC / Mobile games. Since then, I have been using my free time and weekends to improve my craft and learn as much as possible about game dev. From Youtube, podcasts, books and even Udemy courses, I have been throwing myself into the world of game dev. My goal is to become a game developer. Some could argue that I am already a game developer, but until I’m getting paid to do this, I don’t consider my goal as completed.

I know I will achieve this goal, as I have the sheer determination to get what I set my mind on. It will be a lot of hard work and many late nights, sacrificing free time but ultimately, if I have to wake up and do something in order to pay the bills, I might as well do something I enjoy!

I want to create games that are fun and that people will remember for years to come. Any gamer can answer the question, "what was one of your all time favourite games?" I want one of the games I’ve worked on to be the answer to that question.
   

![Unreal Engine 5](Unreal-5.jpg)
Image from *[Unreal Engine 5](https://cdn2.unrealengine.com/share-1200x630-a-1200x630-22326b97f383.jpg)*

### Game Engine
My game engine of choice is Unreal Engine. I chose Unreal because of my previous C++ experience from university. This blog will primarily be focused on Unreal Engine (sorry Unity Users). Nothing against Unity; I have used it previously but I had stronger  skills with C++, so I ultimately decided against it. 

You don’t need to know C++ to learn Unreal Engine. They have made it really easy to use without any C++ knowledge as you can use their visual script system called “Blueprint”.

For now, all I’ll say is that blueprints are fantastic and I have used them a bunch in the games I’ve created.

So far, I’ve created three games in Unreal Engine: one in Unreal 4, and two in Unreal 5. I even competed in my first game jam! (That was hectic). 

The game jam was a great learning experience and I would highly recommend trying one out even if you are on your own. What you can do is choose a game jam, do it along with everyone else and only sign up if you completed a game. This way, you aren’t under any stress of getting it finished if other events pop up.

![Start Line](Start.jpg)
Image from *[Medium](https://miro.medium.com/max/1060/0\*-RDfUUMDd2F1L2po.jpg)*


### Getting Started

After choosing a game engine, my next step was to start learning. Off to Udemy I went! (You could also use YouTube tutorials). If you are looking to get into Unreal Engine and want to follow some courses on Udemy, I would highly recommend Game Dev Tv courses. Game Dev Tv has multiple courses that cover a wide range of game types and styles. What I especially like about these courses is that you are building games while you learn. They take you through the process of building your own game step by step. These are the courses that I have done:
- Unreal Engine Blueprint Game Developer (Good starting point)
- Unreal Engine 5 C++ Developer: Learn C++ & Make Video Games
- Unreal C++ Multiplayer Master: Intermediate Game Development (Optional)


Podcasts are another great medium to learn about game dev. I have mostly been following these podcasts:
- Game Dev Field Guide 
- Game Dev Advice: The Game Developer’s Podcast


What has worked best for me so far has been consistency. I have found doing a little bit of game dev everyday has helped me to continue to move forward.

Ultimately, if you are on the fence about getting into game dev, the biggest mistake you can make right now is not starting.

I’ll be using this blog to share my journey as well as give advice and write guides to help others along. Stick around and let's learn new things together!


A little bit about me and how I started my developer journey.

Introduction


# Coding Principles

### Introduction
This serves as some of the tips I use when writing code, even when working by myself.

*Coding Principles* can be broken up into two parts: *Coding Standards* and *Coding Best Practices*.

*Coding Standards* are a set of guidelines and rules that define how something should be written within a particular organisation. This can be enforced through tools such as linters or code reviews.

*Coding Best Practices* are a set of recommended practices that are generally accepted as being the most effective or efficient way to write code. They are not necessarily enforced like coding standards, but they are widely used and recommended to improve the quality of code. 

*For example*, a coding standard might require all functions to have a specific naming convention, while coding best practice might recommend using functions that are small and focused, with a single responsibility.

Overall, your code should be easy to read and understand, both for yourself and for others who may need to work with it in the future. This means using descriptive variable and function names, commenting your code where necessary, and following consistent formatting and style conventions.

## Coding Standards
These help make the code more readable, consistent and maintainable.
- **Naming conventions:** Names of variables, functions, and classes should be meaningful and follow a consistent naming convention. For example, use camelCase for variable names and PascalCase for class names.
- **Indentation:**  Code should be properly indented to make it easier to read and understand.
- **Commenting:** Code should be adequately commented to explain its purpose and how it works. Comments are a great way of explaining your thought process and why you are doing it this way. It can also be used to provide additional relevant information. Avoid obvious comments such as explaining an if statement if it is obvious what it's doing.
- **Error handling:** Code should handle errors gracefully and have appropriate error messages.
- **Formatting:** Code should be formatted consistently, such as using a consistent number of spaces for indentation or using consistent line breaks.
- **Performance consideration:** Code should be written with performance in mind, such as avoiding unnecessary loops and optimising data structures.
- **Security considerations:**  Code should be written with security in mind, such as avoiding SQL injection attacks and properly handling user authentication.
- **Version control:** Code should be properly managed using version control tools.


## Coding Best Practices
### DRY
DRY follows the principle of Don’t Repeat Yourself (DRY). This advises developers to minimise the duplication of code in their projects. This can be achieved by creating reusable functions of components that can be utilised in multiple sections of the codebase. By following this approach, developers can increase efficiency and reduce errors in their code. Use the rule of 3: if you copy and paste 3 times or more, use a function instead. 

### Code Formatting
Use Consistent formatting [Prettier VS Code](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode). This helps keep the code cleaner and easier to read. Use our predefined modular, we don’t want one person using 2-tab space and another using 4. With inconsistent tab space errors, it can be a nightmare to keep track of code changes because committing a single line could reformat the entire document. 

### Functions
Break code into small, manageable functions. Functions should do one thing and do it well and should be as small as possible to make them easier to read, understand and test.

### Documentation
Document as you Code (DAC) This will help other programmers understand your code and make it easier to maintain.

### Version Control
This keeps track of changes to your code, and it will also make it easy to revert to a previous version if a mistake is made. A general rule for what goes into Version Control: anything made by humans such as code, images or small data (Big amount of data go into Databases). Anything that gets generated (sometimes in a folder prefixed with “.” such as “.next” ,”.vs” “.firebase”), gets ignored from being tracked by version control.


## Specific Coding Standards
- [Unreal Engine](https://docs.unrealengine.com/4.27/en-US/ProductionPipelines/DevelopmentSetup/CodingStandard/)
- [C++](https://www.scaler.com/topics/cpp/cpp-coding-standards/)
- [JavaScript](https://developer.wordpress.org/coding-standards/wordpress-coding-standards/javascript/)
- [Python](https://docs.python-guide.org/writing/style/)

## Conclusion
Coding best practices are essential for writing high-quality code that is effective, efficient, and maintainable. 
While it may take more time and effort to write code that adheres to these best practices, the benefits in terms of code quality, maintainability, and team productivity are well worth it. By making a commitment to coding best practices, developers can create code that is reliable, scalable, and future proof.


Coding Princiles To Write Better Code


### C++
Unreal Engine programming is done with C++, therefore it is important to have some C++ notes.
I found the C++ Cheat Sheet from Hackr.io is a great start.
- [C++ Cheat Sheet](https://hackr.io/blog/cpp-cheat-sheet-pdf)

### Ari's Unreal Engine Notes
If you haven't heard about Ari, Ari is an Evangelist at Epic Games. He is EPIC ;-) (See what I did there?)
Ari has a set of notes for Unreal Engine and is where I got the idea to start making my own set.

- [Ari's Unreal Engine Notes](https://flassari.notion.site/Ari-s-Unreal-Engine-Notes-1a75e43f4014464984d4fae0617e5cef)

Make sure to also check out Ari's website [https://ari.games](https://ari.games). He has a wealth of industry knowledge and his vidoes are always full of passion and enthusiasm!

### Sylar's Unreal Engine Notes
Below you will find all my notes that I have made along my way. Just as Ari did for me, I would like to encourage you to make your own notes!


#### Root Component
Every class that inherits from Actor has a *Root* component already set up called *RootComponent*
Items can be attached to this by calling

```cpp
BaseMesh->SetupAttachment(RootComponent);
```

#### Forward Declaring
In the *.h* file, you forward declare by using the *class* specifier.

```cpp
class USpringArmComponent* SpringArm;
```

Forward declaring is a way of telling the compiler about a class or function without declaring it in the header file. You want to do this for two reason, to prevent circular dependencies and reduce compile times.
Circular dependecies is when you have Class A that depends on Class B, Class B that depends on Class A and the compiler may not be able to compile the code as it can get stuck trying to always include the other file.
Forward declaring is to reduce compile times and the overall header file size. 
For more information, have a look at the excellent video by *Mike Stevanovic* [Unreal Engine C++ Guide - Forward Declarations](https://www.youtube.com/watch?v=sMKDZaszGEM)

#### Casting
Casting is when you need to convert a data type from one type to another. Essentially, you have an object, but you want to call a function on its base object (The object it was derived from).

```cpp
ATank* Tank;
Tank = Cast<ATank>(UGameplayStatics::GetPlayerPawn(this, 0);)
```

#### UPROPERTY Macro
When working with variables inside C++ header files: If you want a variable to be declared during the Constructor and keep its variable for use later on, make sure to give it the UPROPERTY Macro.

```cpp
UPROPERTY()
```

#### Spawning and attaching an Actor to another Actor

```cpp
    UPROPERTY(EditDefaultsOnly, Category = "Window Scenes")
    TSubclassOf<class AWindowActor> WindowActors_ThreeBots;
   
    UPROPERTY()
    AWindowActor* CurrentWindowActor;
```

```cpp
// Spawn the actor
CurrentWindowActor = (AWindowActor*) GetWorld()->SpawnActor(WindowActors_ThreeBots);

// Attach to Actor Root
CurrentWindowActor->AttachToComponent(Root, FAttachmentTransformRules::KeepWorldTransform);
```

The AWindowActor is the C++ class, and WindowActors_ThreeBots is the BP class derived from the C++ class. Make sure in the BP Class that DefaultSceneRoot is set to Movable!

AttachToComponent returns a bool value. This is useful for checking that the attach was sucessful.

Alternatively, make sure to set DefaultSceneRoot to moveable in the constructor:

```cpp
    // Get the DefaultSceneRoot component of the child actor
    USceneComponent* DefaultSceneRoot = ChildActor->GetRootComponent();


    // Set the mobility of the DefaultSceneRoot to movable
    DefaultSceneRoot->SetMobility(EComponentMobility::Movable);
```



### Short Cuts
Open CPU profiling
Ctrl + Alt + Space
*Ctrl + Shift + ,*

Show FPS
*Ctrl + Shift + H*

Search for files (BP_Building) or types ('Static Mesh)
*Ctrl + P*

Opens Content Drawer
*Ctrl + SpaceBar*

### Miscellaneous
[Coding Principles](https://sylaratomic.com/posts/coding-principles-to-write-better-code) by SylarAtomic


All Posts

A Better Way of Streching Meshes In Unreal Engine

Introduction

Coding Princiles To Write Better Code

SylarAtomic's Unreal Engine Notes