Word "file"

Most Used Tags

Posts in 2021

The Art of Mirror's Edge on 11th of Apr
Serving Static Websites Using Lambda@Edge on 20th of Mar
Thread Safe Random in C♯ on 16th of Mar
Spotting Fake Indie Game Key Requests on 11th of Mar
Jenkins Library for Unreal Engine 4 on 13th of Feb
Three Approaches to Readable Materials in First Person Games on 7th of Feb
Cheap Synthetic Monitoring with AWS Lambda on 24th of Jan

Posts in 2020

Generating Mipmaps for Render Targets in UE4 on 24th of Dec
Routing DNS over HTTPS Using Raspberry Pi on 6th of Oct
Tips for Building Games with Unreal Engine 4 on 3rd of Oct
Serving Localised Assets from S3 Using Lambda@Edge on 17th of May

Posts in 2019

Automating macOS Notarization for UE4 on 23rd of Nov

Posts in 2018

ISO Country Code to Unicode Flag in C♯ and JavaScript on 22nd of Jul
Serverless Git LFS for Game Development on 6th of Jan
Adding Custom Map Checks in UE4 on 3rd of Jan

Posts in 2017

Building and Deploying a React App Using AWS Lambda on 24th of Dec
Git HTTP Username and Password in Environment Variables on 22nd of Dec
Capturing and Uploading Screenshots in UE4 on 20th of Dec
Using Capsule Shadows on Large Objects in UE4 on 8th of Dec

Viewing subset of posts matching the word "file".

Serving Static Websites Using Lambda@Edge

Posted March 20th, 2021, updated April 4th, 2021 in cloud-software

A typical approach to static websites on AWS involves a CloudFront distribution pointed at an S3 bucket.

One drawback to this approach is that in the event of a cache miss, CloudFront must retrieve the content from S3. If the bucket is in Ireland and the edge cache is in Australia, this will mean a round trip between those points.

In reality this latency isn't really a problem since it's only evident on a cache miss, but (more as as an experiment than anything else) I decided to write a proof of concept to serve static content entirely from the edge cache.

Routing DNS over HTTPS Using Raspberry Pi

Posted October 6th, 2020, updated March 20th, 2021 in cloud-software

DNS is a protocol from the late 1980s, and today at its core DNS is still exactly the same. When it was conceived, there wasn't the same privacy focus as there is today, and one of the main drawbacks with the protocol is that queries and responses are not encrypted nor tamper proof when sent over the internet.

DNS over HTTPS is a newer take on the original DNS protocol, which routes queries over secure HTTP connections. While this is seeing some support (namely in Firefox and Windows 10), many devices on your network will continue to send DNS queries over UDP for years to come.

Tips for Building Games with Unreal Engine 4

Posted October 3rd, 2020 in game-development

I have released Estranged: The Departure on 3 platforms, Windows, macOS and Linux, and I will be bringing it to the Nintendo Switch and other platforms in the coming months.

This blog post covers my experiences as a solo developer, working with Unreal Engine since 2014 (without access to the UDN), and what to look out for if you are new to the engine.

I intend to keep this post updated (a living document).

Automating macOS Notarization for UE4

Posted November 23rd, 2019 in game-development

One of the trickier requirements introduced with macOS Catalina was the requirement that all applications must be notarized, for any kind of distribution.

Xcode does have tools to do this for you, but when you're building software that is bootstrapped by its own build process (such as a game), or you automate the build and deployment of your app, you need to use the custom workflow.

This post will discuss the entire notarization process for an Unreal Engine 4 game, but the process is the same for any app bundle.

Serverless Git LFS for Game Development

Posted January 6th, 2018, updated July 18th, 2020 in cloud-software

For Estranged, I needed a simple, cheap way of storing binary files. All solutions I tested required me to host a server, or me to pay someone to host a server. I wanted to avoid the flat fee for a constantly running server, and use something completely serverless with a pay-for-what-you-use model.

I settled on using a GitHub private git repository (free) and an LFS (large file storage) backend using Amazon Lambda, Amazon S3 and Amazon API Gateway.

This write-up is a follow up to my older YouTube video covering the manual setup. This guide uses a template for a 1-click deployment of all resources mentioned in the video.

Building and Deploying a React App Using AWS Lambda

Posted December 24th, 2017 in cloud-software

If you use React with a static frontend web app, the deployment steps may comprise of the following:

Run npm install
Run npm test
Run npm build
Deploy build folder to Amazon S3 & invalidate CDN cache

The first part of the build only requires node.js & npm, and the second part can be written in JavaScript too as a package.json script (I'll go into that more below).

Since node and npm are both available on Lambda, we can write a Lambda function invoked using a post-commit webhook (from GitHub or BitBucket), which builds and deploys the React application.

A few advantages to doing this:

You don't need any orchestration infrastructure (Jenkins) or cost overhead of BitBucket pipelines and similar solutions
Since the environment is completely managed, the only changes you may need to make are updating the Node.js runtime version as Amazon release newer versions
Access to the S3 bucket is controlled using IAM roles, no access key/secret

Capturing and Uploading Screenshots in UE4

Posted December 20th, 2017 in game-development

For Estranged, I wanted the ability to capture the contents of the frame buffer, compress it, and upload it to a REST API. This allows users to attach screenshots to an in-game feedback window, to simplify the bug reporting process.

Unreal Engine 4 has APIs around all of those pieces, and in this post, I'll cover sticking them all together.

The full header and source file from the Estranged code is available as a GitHub gist. Below are the important excerpts.

Capturing a Screenshot

This is a two step process. First, you need to register a callback for when the screenshot is captured, then you request a screenshot:

void UEstScreenshotTaker::RequestScreenshot()
{
    GEngine->GameViewport->OnScreenshotCaptured().AddUObject(this, &UEstScreenshotTaker::AcceptScreenshot);
    FScreenshotRequest::RequestScreenshot(false); // False means don't include any UI
}

void UEstScreenshotTaker::AcceptScreenshot(int32 InSizeX, int32 InSizeY, const TArray<FColor>& InImageData)
{
    // See below
}