HERETIC DEVELOPER

Dev setup 2026

2026-04-30T00:00:00+02:00

My use case

I mainly work on a cross platform game written in C++.
With this purpose in mind this is my current dev setup as of 2026.

Clients

Main desktop PC

OS: Manjaro Linux x86_64
CPU: Intel i5-8400 (6) @ 4.000GHz
GPU: Intel CoffeeLake-S GT2 [UHD Graphics 630]
GPU: NVIDIA GeForce RTX 3060 12GB VRAM
RAM: 32GB

I do 90%+ of my computing on this machine.

Windows PC

I use this for debugging my game on Windows and for Photoshop.
It’s a Dell 7010 Thinclient.

OS: Windows
CPU: Intel i5 13500 / up to 4.8 GHz
GPU: GIGABYTE GeForce GT 1030 Low Profile
RAM: 16 GB

Laptop

When I travel or work not from home, I bring a MacBook Air M2.
I used to run a refurbished Thinkpad T495 (AMD Ryzen 3 PRO 3300U) running Linux.

I switched around October 2024, because I need to have an Apple machine to be able to compile for macOS. Also the overall quality of the MacBook is much better. Especially the trackpad and display.

Servers

Promox

Jenkins
Build nodes
- Windows 10
- Debian Linux (Linux and Emscripten builds)
- macOS (eventually)

I run this on a Fujitsu Esprimo E920.

Intel Core i5-4590 CPU @ 3.30GHz
16GB RAM
1TB HDD

Gitlab

I selfhost Gitlab on a Veriton N4640G Thinclient to be able to access my repos across devices, and to be able to build them using Jenkins.

OS: Debian Linux
CPU: Intel®Celeron® 3900T 2x2.60GHz
RAM: 8GB DDR4

Summary

I utilize cheap hardware to create selfhosted services. Most of the hardware mentioned I bought for about 100$ a piece off of Amazon. They’re not the latest and greatest, but they’re good enough for my setup.

In closing: To me infrastructure and data is more important than the machine I use to connect to it. As long as I can access my data and services I’m fine.

I plan on dowsizing my setup for future.
I haven’t fully figured out how to approach this, but I will do it eventually!

idTech 4 coding style

2025-11-14T00:00:00+01:00

idSoftware Coding Style (idTech4)

#programming #idsoftware #style

General

Use real tabs that equal 4 spaces.

Use typically trailing braces everywhere (if, else, functions, structures, typedefs, class definitions, etc.)

if ( x ) {
}

The else statement starts on the same line as the last closing brace.

if ( x ) {
} else {
}

Pad parenthesized expressions with spaces

if ( x ) {
}

Instead of

if (x) {
}

And

x = ( y * 0.5f );

Instead of

x = (y * 0.5f);

Use precision specification for floating point values unless there is an explicit need for a double.

float f = 0.5f;

Instead of

float f = 0.5;

And

float f = 1.0f;

Instead of

float f = 1.f;

Function names start with an upper case:

void Function( void );

In multi-word function names each word starts with an upper case:

void ThisFunctionDoesSomething( void );

The standard header for functions is:

/*
====================
FunctionName
Description
====================
*/

Variable names start with a lower case character.

float x;

In multi-word variable names the first word starts with a lower case character and each successive word starts with an upper case.

float maxDistanceFromPlane;

Typedef names use the same naming convention as variables, however they always end with “_t”.

typedef int fileHandle_t;

Struct names use the same naming convention as variables, however they always end with “_t”.

struct renderEntity_t;

Enum names use the same naming convention as variables, however they always end with “_t”. The enum constants use all upper case characters. Multiple words are separated with an underscore.

enum contact_t {
	CONTACT_NONE,
	CONTACT_EDGE,
	CONTACT_MODELVERTEX,
	CONTACT_TRMVERTEX
};

Names of recursive functions end with “_r”

void WalkBSP_r( int node );

Defined names use all upper case characters. Multiple words are separated with an underscore.

 #define SIDE_FRONT 0

Use ‘const’ as much as possible.

Use:

const int *p; // pointer to const int
int * const p; // const pointer to int
const int * const p; // const pointer to const int

Don’t use:

int const *p;

Style

Doom almost always sticks to a “no in-out” parameter policy; meaning all parameters to a function are either input or output never both.

Minimal Comments

Do not waste vertical space nor horizontal space

Minimal Templates

Use Orthodox C++ style of coding (C flavored C++)

Classes

The standard header for a class is:

/*
===============================================================================
Description
===============================================================================
*/

Class names start with “id” and each successive word starts with an upper case.

class idVec3;

Class variables have the same naming convention as variables.

class idVec3 {
	float x;
	float y;
	float z;
};

Class methods have the same naming convention as functions.

class idVec3 {
	float Length( void ) const;
};

Indent the names of class variables and class methods to make nice columns. The variable type or method return type is in the first column and the variable name or method name is in the second column.

class idVec3 {
	float         x;
	float         y;
	float         z;
	float         Length( void ) const;
	const float * ToFloatPtr( void ) const;

}

The * of the pointer is in the first column because it improves readability when considered part of the type.

Ording of class variables and methods should be as follows:

list of friend classes
public variables
public methods
protected variables
protected methods
private variables
private methods

This allows the public interface to be easily found at the beginning of the class.

Always make class methods ‘const’ when they do not modify any class variables.

Avoid use of ‘const_cast’. When object is needed to be modified, but only const versions are accessible, create a function that clearly gives an editable version of the object. This keeps the control of the ‘const-ness’ in the hands of the object and not the user.

Return ‘const’ objects unless the general usage of the object is to change its state. For example, media objects like idDecls should be const to a majority of the code, while idEntity objects tend to have their state modified by a variety of systems, and so are ok to leave non-const.

Function overloading should be avoided in most cases. For example, instead of:

const idAnim * GetAnim( int index ) const;
const idAnim * GetAnim( const char *name ) const;
const idAnim * GetAnim( float randomDiversity ) const;

Use:

const idAnim * GetAnimByIndex( int index ) const;
const idAnim * GetAnimByName( const char *name ) const;
const idAnim * GetRandomAnim( float randomDiversity ) const;

Explicitly named functions tend to be less prone to programmer error and inadvertent calls to functions due to wrong data types being passed in as arguments. Example:

Anim = GetAnim( 0 );

This could be meant as a call to get a random animation, but the compiler would interpret it as a call to get one by index.

Overloading functions for the sake of adding ‘const’ accessible function is allowable:

class idAnimatedEntity : public idEntity {
idAnimator *       GetAnimator( void );
const idAnimator * GetAnimator( void ) const;
};

In this case, a const version of GetAnimator was provided in order to allow GetAnimator to be called from const functions. Since idAnimatedEntity is normally a non-const object, this is allowable. For a media type, which is normally const, operator overloading should be avoided:

class idDeclMD5 : public idDecl {
const idMD5Anim * GetAnim( animHandle_t handle ) const;
idMD5Anim *       GetEditableAnim( animHandle_t handle );
};

id Studio Names

id<name>Dlg      // dialog class
id<name>Ctrl     // dialog control class
id<name>Frm      // frame window
id<name>View     // view window
id<name>         // any other class

File names

Each class should be in a seperate source file unless it makes sense to group several smaller classes.

The file name should be the same as the name of the class without the “id” prefix. (Upper/lower case is preserved.)

class idWinding;

files:

Winding.cpp
Winding.h

When a class spans across multiple files these files have a name that starts with the name of the class without “id”, followed by an underscore and a subsection name.

class idRenderWorld;

files:

RenderWorld_load.cpp
RenderWorld_demo.cpp
RenderWorld_portals.cpp

When a class is a public virtual interface to a subsystem the public interface is implemented in a header file with the name of the class without “id”. The definition of the class that implements the subsystem is placed in a header file with the name of the class without “id” and ends with “_local.h”. The implementation of the subsystem is placed in a cpp file with the name of the class without “id”.

class idRenderWorld;

RenderWorld.h // public virtual idRenderWorld interface
RenderWorld_local.h // definition of class idRenderWorldLocal
RenderWorld.cpp // implementation of idRenderWorldLocal

Prototype 0

2025-10-25T00:00:00+02:00

It’s more a tech test rather than a game.
The tech and infrastructure serves as the bones for everything to come.

Game rules

Kill enemies to gain score
Score ticks constantly down
Hitting enemies and collecting gems increases fire rate
Getting hit reduces HP and shrinks the game play area
Don’t get hit and don’t shoot for 5 seconds to gain HP
The higher the score, the more damage enemies deal

Controls

WASD - Movement
Space - Jump
ESC - Grab / release mouse
Mouse 1 / Primary fire
Mouse 2 / Secondary fire

V1.0 released on 25. October 2025

Dot Product Tricks

2025-10-25T00:00:00+02:00

When I first started 3D programming and came across the dot product, I was confused about it. I couldn’t wrap my head around how it could be used.

Here are some neat use cases I found throughout the years for it

It tells you how similar two normalized vectors are

The dot product returns a value in the range of [-1, +1].
+1 means the vectors are 100% the same
0 means that the vectors are perpendicular/orthogonal to each other
-1 means the vectors are pointing 100% in the opposite direction

float similarity = DotProduct(vec_a, vec_b);

Vector Projection

Remove a vector from another

In this example we cancel out the velocity in “gravity direction”.

// cancel out gravity part from velocity
const Vec3 vel = state.velocity - state.gravityNormal * DotProduct( state.velocity, state.gravityNormal );

This gives you the length of velocity in the gravity direction

DotProduct( state.velocity, state.gravityNormal )

Angle between two normalized vectors

This is useful when you want to get the angle between two vectors. float angle_rad = acosf(DotProduct(normalized_vec_a, normalized_vec_b));

Note that the range of angle will be 0° ≤ angle ≤ 180 degrees and the equivalent in radians 0° ≤ angle ≤ PI radians

The acos gives you only the magnitude of the angle between the vectors, it doesn’t give you the direction.

If you use this to rotate an object using this angle, you’ll need to make adjustment to the result if you want to make it look at a target for example.

// Define a normal (usually something like vec3(0, 0, 1) for XY plane)
vec3 normal = ...;

float angle = acos(DotProduct(normalized_a, normalized_b)); // 0 to π

vec3 cross = CrossProduct(normalized_a, normalized_b);

// Use the direction of the cross product to determine sign
if (DotProduct(cross, normal) < 0) {
    angle = 2 * M_PI - angle;
}

Clip vector to plane

I’m not sure what the proper terminology is to describe this, but you can use the dot product in the following way to change the length of vectorToClip so that it ends up on the plane normal.

Vec3 VectorClipToVectorPlane( const Vec3 &planeNormal, const Vec3 &vectorToClip ) {  
    return vectorToClip / DotProduct( planeNormal, vectorToClip );  
}

This clips the red vector to the plane of the black vector.

Visibility tests

Back face culling

If you want to check, you are viewing the front side of a triangle, you can use this. This can be used for checking, if something is looking at something

float backface_culled = DotProduct( plane_normal, view_dir );
if (backface_culled < 0)
{
// not visible
} 

float is_looking_at = DotProduct( enemy_view_dir, VectorNormalize( other_obj_pos - enemy_pos ) );

if (is_looking_at >= 0) 
{
	// sees the front face of the other object
}

View Cone Visibility

You can expand the above case to a view cone of a specified angle width

float is_looking_at = DotProduct( enemy_view_dir, VectorNormalize( other_obj_pos - enemy_pos ) );

const float DEGREES_TO_RADIANS = static_cast < float >( M_PI ) / 180.0f;
float dot_angles = cosf( 45.0f * DEGREES_TO_RADIANS );
if (is_looking_at >= dot_angles ) 
{
	// other object is in view cone of enemy
}

Vector Rejection (Coming soon)

Project onto plane

Wall sliding

Example book entry

2025-06-01T00:00:00+02:00

Use this post as a template: set cover to your jacket image (paths are relative to the site root), subtitle for a one-line summary, author, optional booklink for a store or reference URL, and category: [ books ] so it appears on the books page.

Meritocracy

2025-02-14T00:00:00+01:00

Academia went to shit in the last couple of decades, due to an influx of political correctness and other woke mindviruses, and bred new generations of ““yes-people””, who never question what they’ve been taught in university and who aren’t able to have an original thought on anything which might contradict what they’ve been told by authority.

These indoctrinated yes-man flood tech companies and produce slop by “design by committee”. There should always be one person in charge with a clear vision instead of a room full of confused people who only follow best practices and don’t have an inner monologue.

Companies don’t hire for skills anymore

In a world where meritocracy is viewed as racist and unfair, soon performance metrics will be viewed in the same way, because “youths” can’t rub two brain cells together to produce a solution. Mark my words, this will happen. You can clearly see the evidence in the web development sphere, where nowadays every retard can get a job as long as they have the correct pronouns, skin color or political beliefs.

If the tech sector doesn’t trim the fat, software development as a field is doomed.

Programming Philosophy

2024-05-10T00:00:00+02:00

Here are some insights of wisdom I picked up over the years.

Simplicity

Keeping it simple makes your code more robust, easier to debug, and allows you to come back to it and understand it quickly.

Don’t try to be smarter than you are. This will only hurt you in the future.

Like Terry Davis pointed out, the hardest question in programming is asking yourself

Is this niggerlicious or is this divine intellect?
Is this too much voodoo?

Focus on the problem not the programming

Don’t get caught up implementing “neat” solutions, which won’t add progress towards finishing your product, but will just “make the code better”. At this point it becomes programming porn.

Just because a solution is interesting to implement, does not mean that you need to implement it at all. You don’t need to always find the most optimal solution for everything. Sometimes a naive and straightforward solution will be more than sufficient.

You are building a product. Don’t fetishize code that much.

Generic solutions take longer

There is no need to try and think ahead into the future and generalize every little detail of your implementation to be more “flexible” in the future. There might not even be a need in the future for your use case.

You are basing your assumptions of the future on the problem you are solving in the present. The truth is that your are just guessing what you might need in the future. Most likely you will guess wrong and you will need to rewrite it anyway when it comes to it.

Perfectionism kills productivity

Trying to write perfect code is a waste of time.

Know the value of “good enough” and continue to solve other issues. It’s never going to be perfect and a good solution today is better than a closer to perfect solution tomorrow. Being productive is more important than being perfect.

Own your dependencies

You must not be dependend on binary distributions for libraries.

You’ll have trouble compiling your project for other platforms
You won’t be able to extent, fix or debug your dependencies
You can’t take a look and check what the code actually does

Hours in, is progress out

Keep grinding away on your project.
Each hour invested brings you closer to finishing your product.
There is light at the end of the tunnel!

Learn A Build System

2024-02-18T00:00:00+01:00

I had a colleague once, who suggested to me that I should learn CMake. This advice turned out to be golden, hence why I suggest to you the same. However you can chose to learn a different build system as well.

Knowing a build system is a game changer in how you setup and structure your projects. All of a sudden all your code can be generated/build on various platforms. You no longer need to know the individual, platform specific IDE project setup configurations. You can just learn the build system and it will setup everything correctly for your target.

This makes it easier for you to adopt the mindset that infrastructure is more important than the platform you are using. It allows you to switch operating systems whenever you want.

It makes adding external code easy! You can include other projects as part of your project.

It enables you to build your own work flows, as you can script in CMake. This means you can automate certain things. You can execute pre build steps and post build steps. Furthermore you can write code as part of the project and run it as a build step on your code base.

So far learning CMake had one of the biggest impacts on me as a programmer.

Collision Detection Is Hard

2024-02-13T00:00:00+01:00

I was always hesitant with rolling a custom solution for collision detection. This is why in the past I’ve tried to use 3rd party libraries for physics and such, but it always felt wrong to me. Most of the physics libraries I’ve used were big. They would increase my build times by a lot and they all come with their own math classes and other utilities, which I’ve had already implemented. I don’t want to have multiple classes for vectors, matrices, etc. in my codebase. And I don’t like glue code, to make it behave the way I want it to.

I decided to roll my own physics code, however I have had zero experience in writing professional grade collision code. This destinction here is important. If you are anything like me you learn through reading tutorials online and watching YouTube videos explaining things. However the stuff which is available on YouTube is not usable in a professional game engine. Let me explain why. Most of the things you can find online are mearly scratching the surface of this topic, but are presented in a way that make you think that after finishing the tutorial that you can go and build your custom collision solution. Unfortunately this is not the case. There are so many developers who themselves don’t know what they don’t know about the topic. They will showcase their phyics systems and try to impress you with visuals.

Oh look, how many objects ““my”” code can handle

Most of them also just copy/paste code, and make it look like they came up with something great.

If you are lucky you will come across more advanced stuff like GJK or some derivative of it. However they will not mention, that GJK is not a silver bullet and don’t present its weaknesses.

All of the videos I’ve seen only attempt to solve a “static collision resolution”, meaning they just compare objects in fixed time intervals to check if any are stuck inside each other. They don’t solve for “dynamic collisions” or perform “continious collision detection”. The moment you realize that static collision detection is really not suitable for player movement, bullet movement, or any movement which does affect gameplay, you understand how screwed you are. People try cope by increasing the physics update frequency by 2x, 4x, etc. in order to not miss collisions to the detriment of performance. However, even if collisions are not missed they are not resolved properly. You don’t want to JUST “uncollide” objects, but you want to prevent penetration. You want to slide along walls, you don’t want to get stuck on corners or geometry edges.

And this is where the journey actually begins. Researching continious collision detection was a painful experience.

I came across a variety of potential solutions. Namely Sphere vs. Sphere CCD, Ellipsoid CCD, etc. Besides a poorly performing GJK CCD derivative I didn’t find anything which did solve generic cases. I did manage to write a custom solution for AABB vs AABB, which actually works really great. It has wall sliding, doesn’t get stuck on geometry edges and performs acceptable.

// AABB vs. AABB only!
void MOVEMENT_MoveSceneObject( SceneObject *scene_object, const Vec3 &total_move, 
								std::list< SceneObject * > &scene, eMoveType type, uint32 flags ) {
	if ( VectorLengthSquared( total_move ) <= 0.0f )
		return;

	const float move_epsilon_sq = Square( 0.005f );
	const int32 max_recursions = 7;

	Vec3 valid_move = total_move;

	bool recurse = true;
	for ( int32 i = 0; ( i < max_recursions ) && recurse; i++ ) {
		const Bounds &bounds = scene_object->GetBounds();
		const Vec3 bounds_center = bounds.GetCenter();

		float move_length;
		const Vec3 move_dir = VectorNormalizeOrZero( valid_move, move_length );
		recurse = false;

		// hit and sort
		std::vector< Collision > collisions;
		for ( SceneObject *obj: scene ) {
			const Bounds &other_bounds = obj->GetBounds();
			IntersectionInfo info = MovingBoundsIntersectsBounds( bounds, valid_move, other_bounds, true );
			info.scene_object = obj;

			// Don't clip since we want to detect seams
			if ( info.did_hit )
				collisions.push_back( { info, other_bounds } );
		}

		// Find closest hit to object
		const Plane sorting_plane( bounds_center, move_dir );
		std::sort( collisions.begin(), collisions.end(),
				   [ &bounds_center, &sorting_plane ]( const Collision &a, const Collision &b ) {
					   if ( a.info.distance == b.info.distance ) {
						   return SignedDistanceToPlane( ClosestPointInBounds( a.bounds, bounds_center ), sorting_plane )
								  < SignedDistanceToPlane( ClosestPointInBounds( b.bounds, bounds_center ), sorting_plane );
					   }

					   return a.info.distance < b.info.distance;
				   } );

		// do collision in sorted order and resolve
		if ( collisions.size() > 0 ) {
			const IntersectionInfo &hit_info = collisions[0].info;
			valid_move *= hit_info.dt; // Clip movement

			if ( type == MOVE_SLIDE ) {
				Vec3 slide_move = VectorReject( move_dir, hit_info.surf_norm ) * ( move_length - hit_info.distance );
				recurse = VectorLengthSquared( slide_move ) > move_epsilon_sq;
				valid_move = slide_move;
				scene_object->transform.SetPosition(
						hit_info.final_position + hit_info.surf_norm * 0.001f ); // Poor man's fix to avoid seams
			} else {
				recurse = false;
				scene_object->transform.SetPosition( hit_info.final_position );
			}
		} else {
			recurse = false;
			scene_object->transform.SetPosition( scene_object->transform.GetPosition() + valid_move );
		}
	}
}

However I did not want to limit myself to just AABB collisions. So I had to come up with something more flexible.

At this point I have started digging through the Quake 1 source code once again and started researching how they’ve solved it in the 90’s. I found some articles and random forum posts about the collision system Carmack wrote for Q1.

“Collision detection was pretty hard,” he admitted. “There was a good period where we were making interesting pictures, but movement only worked smoothly as long as you were sliding along walls with obtuse angles—you would get ‘stuck’ on sharp corners.”

Carmack refined code until he arrived at a solution, albeit not an optimal one. Quake’s collision detection functions by expanding the size of every object on a map by half the player’s size, treating players as a point moving through terrain. “This was robust and extremely efficient, but it meant that each unique size of entity that moved through the world had to have a special version of the map automatically generated for it,” said Carmack. “This cost both memory and processing time during level building.”

Shack News

I can’t speak for Quake 3, I heard somewhere they were using the brushes, but Q1 definitely uses axis-aligned bounding boxes for the objects and collides them with the BSP tree. The way they do this is that they store 4 different trees, one regular tree used for culling and three collision hull trees, used for 3 different sized objects (missiles, small things, people).

The BSP trees are ‘expanded’ at compile time which means that the collision engine only needs to clip a single line segment into the BSP tree in order to determine whether it is in solid or in space (and also where the collision takes place). The actual technique is a little more involved (requires bevelling) so try searching the web

GameDev

After reading all that I was a bit disappointed. I did not want to prebake BSP trees and I certainly did not want to limit myself to using only a handful of AABB sizes. I came across a paper by Stefan Melanx about dynamic collisions with BSP trees, where he introduced the concept of shifting planes.

Dynamic Plane Shifting BSP Traversal

BSP Collision Detection As Used In MDK2 and NeverWinter Nights

BTW: I dont want to “push” BSP’s on anyone. For example, if you can bang off a simple robust AABB implementation in a day, and it does what you need, then why not just use that? BSP algorithms can be harder to understand and implement. Every technology (BSP, aabb, obb, loose octtree, etc.) has advantages and disadvantages. When deciding, ignore any religious based arguments in favor of technical analysis.- Stefan Melax

[Algorithms] BSP bevelling

After having seen my options, I felt super overwhelmed and tried to code something up to just have a working solution.

Having spent bunch of time on this, I found some more info on how to solve it for generic cases in this thread. There’s a reference to Doom3 and this paper. TLDR; There are only two cases one must account for to solve CCD for generic triangle based shapes.

Vertex vs. Polygon Face
Edge vs. Edge

In that paper a method is outlined using Plücker coordinates, which was used in Doom3. I copied the entire collision system from Doom3, only to find out that it’s not working 100%, because of my internal geometry structure and that there are certain edge cases where collisions are missed and the player can walk through walls or gets stuck on corners.

I tried coming up with custom functions to solve the above mentioned cases and it worked, but it didn’t work well enough. I looked into modern CCD projects on github, which come with implementations for those functions and found Tight-Inclusion and some others in the same repos. I had troubles getting them to work properly and when I did manage to get them semi working, the performance was too bad to be usable in a game.

I could’ve lived with those edge cases, however when I started creating more detailed levels the solution would tank in performance. I did use the axis aligned BSP implementation provided by Doom3, but it still wasn’t fast enough. I assume I made mistakes copying it (In hindsight this is 100% the case, btw). However I was too annoyed to bother even looking how to speed it up.

So after more wasted time and effort on trying to fix these issues I had to bite the bullet and use a 3d physics library. Seemingly randomly I discoverd Jolt, which on the surface looks like everything I needed. After integrating it into my engine, I was left with disappointment. The character controller was working quite well, but still it had a bunch of edge cases uncovered and there was annoying jittering going on when moving up steep surfaces. At this point I was fed up with all of it.

I decided to go with the most bloated lib I could find in the hopes that it would cover my needs. I went with NVidia physx. But not just any version of it, no. Of course these geniuses make it seemingly extra hard for people to compile their stupid library. They do use CMake, however it is a clusterfuck to include it in your own project. I had to use this version. Fortunetly a guy already has suffered through this and has created a working CMake-fied version of PhysX, which can be included as part of any CMake project to build from source.

After compiling it and making it run, I had to do a lot of reading in their API / docs on how to set this thing up etc. I spent some days on it, but at the end I had a moving character. Here again, the character controller they provide does not cover all edge cases and I had to patch ~3 bad behaviors in the PhysX code to make it work was intended.

It still isn’t as perfect as I want it to be, but at least it performs well.

What I am trying to say here is

This is by far the most painful topic I had to deal with. So, maybe, you should consider using a premade library for collision detection after all.

Besides giving you collision detection tools, they also come with already implemented acceleration structures, and more stuff you don’t know, you need.

PhysX and Jolt both have visual debugging built in. Try it out first, before you decide to roll your own. See how fast you can get a working prototype ready to go. And then evaluate again, if you really need a custom solution.

Keep in mind that none of the included character controllers are out of the box production ready. You will need to implement functionalities for all sorts of things.

On Noise Cancelling

2023-08-06T00:00:00+02:00

When you want to program in complete silence without being disturbed by surrounding noise.

Brown Noise

Before you start looking into buying headphones, you should try listening to brown noise. Even, if you don’t have noise cancelling headphones, listening to low frequency brown noise blocks out a fair amount of ambient noise. Give it a try. It’s free.

Noise Cancelling

I don’t have any experience with active noise cancelling headphones, so I can’t talk about that. But, Passive noise cancelling works without batteries and doesn’t require an audio signal to block noise. However, there are passive ear muffs, which have an audio-jack, through which you can mix in brown noise to eliminate more sound from the surroundings.

🔥 HOT TIP🔥

There are Bluetooth audio adapters, which you can plug into any audio jack to make it able to receive audio signals via Bluetooth.

I use passive noise cancelling ear muffs with an audio-jack. I like these, because they aren’t really designed for “office use” but rather for the real world like construction sides, shooting ranges and military applications. You can expect high build quality and reliability. Also they’re cheaper. At first they’re super uncomfortable as they fit really tight on the head and ears. You’ll get used to it however after some time. I usually use mine with brown noise or some low frequency droning ambient music.

Improve Life Quality With A Rice Cooker

2023-08-06T00:00:00+02:00

If you are too lazy to cook for yourself, this is a MUST-HAVE. Rice cookers are underrated appliances, which in my opinion everybody should own. Not only can you cook rice in it, but all sorts of things like soups, potatoes, porridge, etc. You also can steam vegetables or dumplings at the same time. This reduces the effort to prepare a good meal to just a couple of steps.

Wash rice
Put washed rice into the rice cooker
Fill with water
Place dumplings into steaming compartment
While the rice is cooking, you can cut some fresh vegetables and prepare some meat

Rice cookers are very affordable, ranging from 30$ to upward of 100$. It really depends on what “features” you need. You don’t need a fancy one to get good results.

However when it comes to rice, I recommend buying high quality Japanese or Korean rice. They have a very pleasant consistency and in my opinion taste the best. It might cost more than the rice you can buy in your usual stores, but it’s worth to pay the premium.

Besides that you can buy the following extra ingredients to further expand the amount of recipes you can cook with it.

Get inspired by Japanese rice cooker recipes on YouTube.

Recommended Recipes

Get Books Before AI Ruins Knowledge

2023-08-06T00:00:00+02:00

The internet is quickly becoming an informational wasteland full with regurgitated bullshit.

It really doesn’t matter which topic you’re trying to look up. Usually you’ll find the same information phrased in a slightly different manner over and over again. It seems like that there is only one way of doing things in the modern era and everybody is just rephrasing it in their own words, presenting it as some sort of original work.

The things you can read online about any topic are mostly incomplete and are only scratching the surface. If you want to dig deeper it becomes almost impossible. Everybody keeps rewriting the same blog post again and again. YouTube isn’t really better in that regard. People are re-recording the same video with their own personal spin without any added value for the viewer.

With the advent of generative AI tools like ChatGPT, this problem will amplify itself times infinity. AI is becoming the single source of truth for the masses as it’s much easier for the bugmen to ask ChatGPT something, rather than coming to a conclusion of their own. Soon SEO optimized, AI generated content will flood the internet, drowning out, genuine knowledge and information even more.

It will become increasingly harder to find deep knowledge. This is why you should get books, while their content is still valuable and not generated by AI. Personally I prefer physical books, but you can get the digital versions as well. It’s up to you. Getting them digitally usually doesn’t require a lot of money, if at all. A lot of great books are circulating online as PDFs, ready to be downloaded.

Start building your library today.

Mouse Release For Debugging On Linux

2023-08-01T00:00:00+02:00

Debugging an application which captures your mouse cursor on Linux, leads to a problem where when a break point is triggered, it doesn’t release your mouse cursor.

For some people switching between windows with ALT + Tab makes the mouse reappear. However this doesn’t work for everybody and having to perform additional hand movements in order for the mouse to appear is annoying.

To solve this issue, we can write a script which will release the mouse automatically when a break point is hit.

Keep in mind, that this will only work for debugging with GDB

How to

Create a gdbinit file, if it doesn’t exist

mkdir -p ~/.config/gdb
nano ~/.config/gdb/gdbinit

Add the following content to the gdbinit file

set auto-load python-scripts on
source ~/config/gdb/release-mouse-gdb.py

Create the Python script

nano ~/config/gdb/release-mouse-gdb.py

Add the following content to script

#!/usr/bin/python

import os

def release_mouse (event):
    os.system("setxkbmap -option grab:break_actions")
    os.system("xdotool key XF86Ungrab")
    os.system("setxkbmap -option")

gdb.events.stop.connect(release_mouse)
gdb.write("GDB/X11: installed release mouse for X11\n")

That’s it! Just make sure to actually use GDB when debugging

References

github github github libsdl stackoverflow

Arguments against using Unity/Unreal

2023-07-01T00:00:00+02:00

Here are some points to think about before using Unity/Unreal:

Long Term Support

Compiling your game in five years might become challenging. Finding and setting up the right Unity/Unreal version could be tricky. Older versions may not support newer platforms. In that case, you will need to update your project to a more recent Unity/Unreal version, which may break things.

Compatibility

If you want to port your game to a platform that isn’t supported, you’ll run into a roadblock. Unity/Unreal needs to add support for it.You can’t do it yourself. This means your game’s compatibility and success ultimately depend on Unity/Unreal’s decisions.

Corporate Monopoly

Don’t contribute to building dystopian monopolies. Unreal and Unity are just centralizing power for globohomo.

Build Knowledge

Learn how game engines work. It’s fun writing stuff on your own and you learn how it works under the hood.

Start-Up

2022-06-30T00:00:00+02:00

I want to share my views on programming, video game development and technology.
I’ll publish code snippets and do write-ups on interesting topics.

I am working on a video game, which I’ll shill from time to time.

This blog is mainly for myself to keep track of my progress as some kind of journal.