Featured

Hello World

A short introduction of myself and what I want to achieve with this blog

Well, I thought a lot about how to start this and I came to the decision to tell you guys why I am actually doing this.

First of all, a bit about me.

I am 22, I am trainee (in my last year of apprenticeship) as a software developer. My main programing language is C++ but I am also familiar with C# and Java. (Java only a bit).

My dream is to become a professional game developer and I am trying to teach myself the basics of game development.

I am interested in software design, gaming but also the most recent hardware, and that leads us to one of the points why I am doing this blog. My friends and family are asking me a lot about hardware and computers in general and want some tips which hardware they should buy, and that is one of the points which I want to cover in this blog.

Ok what does that mean? Well, I will try to give some thoughts about new hardware (like AMD Ryzen etc) for different use cases (video editing, gaming and media stuff for example) which you can take as a base for buying a new PC.

But that is only one part of this blog. I will also try to share my thoughts and lessons learned about game and software development on this blog so those of you who are interested in that topic may have some ideas or starting points.

I will try to share good sources and protect you from bad ones. I am still in the process of learning so I am always happy about advice, constructive criticism or corrections from your side.

A simple collision approach

Collision is one of the core elements in game-development. Without collision we weren’t able to bring the most simple games to life. But there are a LOT of ways to start dealing with this particular problem since it’s not as simple as it sounds.

Possible complications:

  • We have to figure out who is colliding with each other
  • We have to specify who is allowed to interact with each other
  • We need a system which is not to complicated to expand
  • How detailed will our collision be?
  • How much performance can we sacrifice for convenience?

These are just some of the problems and questions you might face if you are dealing with this particular problem.

The big engines solved this very well with some interesting approaches, but this article is going to show, how one COULD!!! implement an own 2D collision approach.

I will try to focus on the theoretical part of the idea and how the idea works instead of coding everything into the last detail.

There will be a bit of code, some explanation, some code… aaand so on.

Ok let’s start. First of all I will implement a little helper class to deal with coordinates:

struct Vector2
{
 Vector2(int x = 0, int y = 0)
 : X(x), Y(y)
 {}

 int X;
 int Y;
};

static const Vector2 Origin;

Vector2 contains two int values, our X and our Y position. This class can be used to represent points as well as motions in a 2D space (I am going to presuppose that you guys are familiar with vectors in math). Our Origin is our base-Vector2 with a position of (0|0).

Now we need something which holds the info where our “collidable” begins/ends. We could save this information directly in our Actor (you will see later) but I prefer to outsource such kind of functionality to other components. We will implement a BaseCollisionBody from which we can inherit different CollisionBodies (like squares/circles) so we can easily change the collision body for our later Actors.

class CollisionBody
{
public:
 virtual bool IsCollidingWith(CollisionBody* target) = 0;
 virtual bool Contains(Vector2 pos)= 0;

 std::vector<Vector2>& GetBorderPositions()
 {
  return m_Points;
 }

 virtual ~CollisionBody(){}

 virtual void Move(Vector2 motion)
 {
  for (auto point : m_Points)
  {
   point.X += motion.X;
   point.Y += motion.Y;
  }
 }

private:
 std::vector<Vector2> m_Points;
};

This is our BaseBody. We got an IsCollidingWith() pure virtual function which will allow us to check if two Bodies are colliding with each other. We got a dynamic array which stores our border points so we can implement different forms with a different number of points. Futhermore we got a Contains() function which will later on implement the functionality to check if a point is contained by our body. Last but not least we got a Move() function which allows us to move our body.

Now we need at least one specified CollisionBody to cover the form of a sprite where we want to add collision to. I decided to go with a square.

class SquareCollisionBody : public CollisionBody
{
public:
 SquareCollisionBody(Vector2 position, int sideLength)
 {
 Vector2 pointA = position;

 pointA.X -= sideLength / 2;
 pointA.Y -= sideLength / 2;

 Vector2 pointB = position;

 pointB.X += sideLength / 2;
 pointB.Y -= sideLength / 2;

 Vector2 pointC = position;

 pointC.X += sideLength / 2;
 pointC.Y += sideLength / 2;

 Vector2 pointD = position;

 pointD.X -= sideLength / 2;
 pointD.Y += sideLength / 2;

 GetBorderPositions().push_back(pointA);
 GetBorderPositions().push_back(pointB);
 GetBorderPositions().push_back(pointC);
 GetBorderPositions().push_back(pointD);
 }

 bool IsCollidingWith(CollisionBody* target)
 {
  std::vector<Vector2>& targetPoints = target->GetBorderPositions();

  bool areColliding = false;

  for (unsigned int currentPoint = 0; targetPoints.size() > currentPoint; ++currentPoint)
  {
   Vector2 point = targetPoints.at(currentPoint);

   if (Contains(point)
   {
    areColliding = true;
    break;
   }
  }

  if(!areColliding)
  {
    bool condition1 = target->Contains(pointA) || target->Contains(pointB);
    bool condition2 = target->Contains(pointC) || target->Contains(pointD);

    areColliding = condition1 || condition2;
  }

  return areColliding;
 }

 bool Contains(Vector2 point)
 {
  Vector2 pointA = GetBorderPositions().at(0);
  Vector2 pointB = GetBorderPositions().at(1);
  Vector2 pointC = GetBorderPositions().at(2);
  Vector2 pointD = GetBorderPositions().at(3);

  if (point.X >= pointA.X && point.X <= pointB.X && point.Y >= pointA.Y && point.Y <= pointD.Y)
  {
   return true;
  }

  return false;
 }

private:
};

Ok, here we go, that’s our SquareBody implementation. In the constructor we are setting four points A(upper left), B(upper right), C(lower right) and D(lower left) and then we add them to our BaseBody::m_Points vector. We only need those four points to recognize if our square is colliding with something since we can simply check if one of the points is contained in our square. This leads to our simple two functions we are implementing for our BaseClass, Contains & IsCollidingWith. I don’t think I will have to explain those since they are quite simple. (And yes one could do this better, but this will suit our needs for this example)

The next class we will create is our Actor. I added some functions to the actor as placeholder which will give you a little view of how the class might work later. I won’t deal with these placeholders. Our Actor class will serve as base class for our other interactive classes like Character (Actors which have animations or can be moved around or which will be possessed by the AI later), EnviromentActors (Stones, Barriers etc…) or even projectiles.

class Actor
{
public:
 enum Type
 {
  actor,
  character,
  projectile,
  enviroment,
  background
 };

 class CollisionProperties
 {
 public:
  CollisionProperties(Actor::Type myType, CollisionBody* body, int n, ...)
  : m_CollisionBody(body)
  {
   va_list params;
   va_start(params, n);
 
   for (int currentArg = 0; currentArg < n; ++currentArg)
   {
     m_TypesToInteract.push_back(va_arg(params, Actor::Type));
   }
   va_end(params);
  }

  ~CollisionProperties()
  {
   if (m_CollisionBody != nullptr)
   {
    delete
    m_CollisionBody = nullptr;
   }
  }

  bool CanCollideWith(Type collisionType) const
  {
   return m_TypesToInteract.end() != std::find(m_TypesToInteract.begin(), m_TypesToInteract.end(), collisionType);
  }

  bool IsColliding(Actor* target) const
  {
   if (m_CollisionBody != nullptr)
   {
    const Actor::CollisionProperties& props = target->GetCollisionProps();

    if (CanCollideWith(props.m_CollisionType))
    {
     return
    }
   }
   return false;
  }

  void Move(Vector2 motion)
  {
   m_CollisionBody->Move(motion);
  }

private:
  Actor::Type m_CollisionType;
  CollisionBody* m_CollisionBody;
  std::vector<Actor::Type> m_TypesToInteract;
 };

 Actor(Actor::CollisionProperties* props, Vector2 position)
 : m_CollisionProps(props), m_Position(position)
 {}

 virtual ~Actor()
 {
  if (m_CollisionProps != nullptr)
  {
   delete m_CollisionProps;
   m_CollisionProps = nullptr;
  }
 }

 virtual bool IsColliding(Actor* actor)
 {
  return m_CollisionProps->IsColliding(actor);
 }

 virtual void Move(Vector2 motion)
 {
  m_CollisionProps->Move(motion);
  m_Position.X += motion.X;
  m_Position.Y += motion.Y;
 }

 virtual void Update()
 {
 //Some Stuff...
 }

 virtual void Draw()
 {
 //Some Stuff...
 }

 virtual const CollisionProperties& GetCollisionProps() const
 {
  return *m_CollisionProps;
 }

private:
 //...
 //Some Stuff...
 //...

 CollisionProperties* m_CollisionProps;
 Vector2              m_Position;
};

So this is our actor. Our actor contains a subclass CollisionProperties which will handle the collision for the actor. The properties class contains an Actor::Type member which specifies, which kind of actor we got (environment etc. see the enum) as well as the CollisionBody and a vector which contains the collision types, our actor can interact with. Our Actor is basically calling the functions we already implemented in our CollisionBody with the little difference that we can specify in our m_TypesToInteract which kind of collisions shall be ignored by our later implemented inherited subactors.

Let’s take a character for instance:

class Character : public Actor
{
 Character(const std::string& name, CollisionBody* body)
 : Actor(new Actor::CollisionProperties(Actor::character, body, 3, Actor::character, Actor::enviroment, Actor::projectile), Origin), m_CharacterName(name)
 {}

 std::string m_CharacterName; 
};

This class get’s all its features like update, draw and move from our Actor class, but it specifies which kind of actor(Actor::character) we got and which classes can collide with our character (other characters, environment actors and projectiles). This class got close to all functionalities a character needs (motion, collision, updates etc) but it remains pretty slim by now.

Okay that was a whole lot of stuff. Now we got close to all components we need for our collision together. There are only a few little things missing:

A little event class and an inherited collision event.

class Event
{
public:
 enum Type
 {
 collision
 //...
 //Some Others...
 //
 };

Event(Type type)
 : m_EventType(type)
 {}

Type GetEventType()
 {
 return m_EventType;
 }

private:
 Type m_EventType;
};

class CollisionEvent : public Event
{
public:
 CollisionEvent(Actor* a, Actor* b)
 : Event(Event::collision), m_ParticipantA(a), m_ParticipantB(b)
 {}

Actor* GetPA()
 {
 return m_ParticipantA;
 }

Actor* GetPB()
 {
 return m_ParticipantB;
 }

private:
 Actor* m_ParticipantA;
 Actor* m_ParticipantB;
};

Since you are pretty smart guys, I am pretty sure I won’t have to explain this classes to you because they are actually pretty simple so I will go on with a simple usage example of the collision eco system we just created. I will leave or actor/character creation and focus on the collection of collision events per frame.

class Engine
{
public:
 void Play()
 {
 while (m_Running)
 {
 Collision();
 Update();
 Draw();
 Present();
 }
 }
private:
 void Collision()
 {
 for (unsigned int currentActorA = 0; m_ActorPipeline.size() > currentActorA; ++currentActorA)
 {
 if (m_ActorPipeline.size() < 2)
 {
 return;
 }

for (unsigned int currentActorB = currentActorA; m_ActorPipeline.size() > currentActorB; ++currentActorB)
 {
 Actor* a = m_ActorPipeline.at(currentActorA);
 Actor* b = m_ActorPipeline.at(currentActorB);

if (a != b && a->IsColliding(b))
 {
 m_EventPipeline.push_back(new CollisionEvent(a, b));
 }
 }
 }
 }

void Update()
 {
 std::for_each(m_ActorPipeline.begin(), m_ActorPipeline.end(), [](Actor* actor)->void{actor->Update(); });
 }

void Draw()
 {
 std::for_each(m_ActorPipeline.begin(), m_ActorPipeline.end(), [](Actor* actor)->void{actor->Draw(); });
 }

void Present()
 {
 //Some Stuff...
 }

 //...
 //Some Stuff...
 //...

 std::vector<Actor*> m_ActorPipeline;
 std::vector<Event*> m_EventPipeline;

bool m_Running;
};

Okay, what do we got here. An Update() function, a draw function and our present function. Pretty basic if you ask me so I am going to leave them out. Collision().. well, that’s the interesting part. In this function we are handling our collision and there we will create our CollisionEvents and add them to our EventPipeline.

Basically we are iterating through out actor pipeline and we check our actors for collisions. If we detect a collision (remember, we specify which kind of actor may collide with which other types.), we will save a CollisionEvent with the two participating actors to our EventPipeline. What you will do with them from there on is no longer my concern since that is not part of this tutorial/article 😉

Puh, that was a whole lot of info I pushed out there. I hope some of you can get some helpful information out of this article. But hey, I know there is a lot of optimization potential in this code but optimal performance wasn’t the goal I wanted to archive with that.

The thing I like most about this approach is the little effort you will have to put into changing this one into a concurrent environment. Basically you have two ways of doing this:

First (and less effective way): You could create a task for every collision check and hand this task over to a thread pool to collect the results in future objects and process them later.

Second: You could add a pipeline for every type of collision object that you have a pipeline for environment actors, one for projectile actors and for each pipeline an own EventPipeline and so on. This way you could process one pipelines per thread and merge the events together in the end. (That’s how I would handle this, but I would handle the collision threads in a pool anyway.)

I hope you liked today’s post, that’s all for today. Have a nice day/evening whatever 😉

Stop bugging me

This is something which is annoying for a while now. I ignored it over a long period time but enough is enough.

Toady I made a little post on a helping platform for developers and it happened again… The people don’t read the question or the comments before they answer… This is really annoying. You won’t waste my time, your time and the time of the others who are reading this post. This is not meant to be insulting… but GOD DAMNED STOP BUGGING ME. If you don’t want to read the question which was ask or at least look into the discussion below it, don’t answer to it. that easy. A little example from my side:

StackExchange

I blacked out the names since I don’t want to insult anybody… Okay, the first guy were just fine since I just mentioned I am using VS, so how should he know. Then there were the second one who plain ignored what I posted 4 minutes earlier.

And because this is just one case, here is another one…

On the very top of my Post I wrote:

StackExchange2.1

Here comes a part of the answer:

StackExchange2.2

Well that’s not very helpful. (For his defence: The rest of the answer were pretty helpful and he really tried to give good advice, but this example is just to good to leave it out.)

Guys… please… read the questions BEFORE you come up with that kind of answer. I’ll take me as an example for this. I switched to Visual Studio 2015 this year since the company I am working at still uses VS2010. And it’s pretty awesome that C++ >= 11 has a lot of fancy stuff and features, but that won’t help me if I can’t use them for productive code, (Or at least code which I am producing with any relation to my workplace) since I can’t run it at work.

That’s all for today folks.

Concurrency the little bitch

Hey folks, todays post will feature some ideas, advises and conclusions about task-based concurrency programming (mostly in C++).

First of all, what actually is task-based concurrency? If it comes to threading there are basically two and a half approaches you can choose from: multithreading, multitasking, – multiprocessing.

Multithreading: This approach relies on multiple threads on which the developer can spread his workloads to reach an even resource usage and optimal performance. This approach is very low-level and requires a lot of knowledge and care of the person who is coordinating the threads. He always have to know: How many threads do I have, which threads are doing what and also (he better knows) where his threads are running. (On which cpu core for instance)

Multitasking: This one is a more high-level approach. There are some ways to get things done here. The first way: thread pooling. The developer initializes a pool of threads which keep active after they finished their work so he can pass them tasks and don’t have to create new threads all over. He (usually) don’t knows which thread is executing which task (and he also doesn’t care about it) since he just queues tasks up in the pool and the pool decides where they are going. The Second way: One could use wrappers like C++ std::async. Asyncs are (kind of) used like a thread pool. There is simply one difference. Not the developer but the “std::async framework” decides where or how the tasks are executed. If you hand a task to a std::async it could also be executed on the same thread where the result is required until you don’t explicitly tell the async object to behave another way.

Multiprocessing: You spawn multiple processes and let them communicate with each other. You are (kind of) running multiple programs wich do multiple tasks.

I will focus on multithreading/tasking in this post since I have little to no experience with multiprocessing.

Okay, this might sound like you have very little differences from multithreading to multitasking with the exception that multithreading seems to be more work. And in some way, this is actually not to far away from reality. But, and here is the point, there are reasons for both to exist.

A Realworld example for multithreading:

MessageLoop and GUI/Game thread. Let’s consider we have the following code:msgloop_m

We have our main thread which is basically our main function and we have our game thread, which is spawned and will run until the main thread exits it. The only communication between the two threads is managed through the function calls on the game object and the join on the game thread.

And an example for multitasking:update_m

We have our game thread which does some logic and which is containing the game loop ( run() ) and a thread pool which is executing little independent tasks (in this case updating actors) which won’t report back to the game thread.

Alright, let’s see: On our msgloop/gamethread example exactly know which thread is dealing with which piece of work (main() with the msg loop, gameThread with the gameloop). But how does is look for the update example? Well, until we try to figure out which thread of our pool is executing which task we would have to call any kind of thread identification from our task, so simple we don’t know who is who.

And these two examples are good for two things: Giving you guys an example where which approach may fit and giving you an example how these approaches are working.

In example one each thread executes some work completely independent from each other and sometimes they communicate to trigger actions on the other one which is basically a simple event handling pattern.

In example two one thread is creating tasks, the others are just “consuming” the tasks the game thread generates. That’s why it’s called the producer-consumer pattern.

Both of those patterns are suited for different use cases as you might recognize. The first pattern is very handy if it comes to things like controls or long-term work wich can be handled parallel or any kind of input loop or audio output, the producer-consumer pattern on the other hand is better suited if you need some small pieces of independent work to be done in parallel to the work of your long running other threads, like drawing, animation updates or simple outputs.

The p-c-pattern benefits a lot from lock free tasks but suffers even more if you need to synchronize the tasks you are pooling, since if you are locking a pool thread, you also lock some future tasks from being executed while you can easily create a new worker thread if you are managing your thread lifetimes on your own.

The best performance you can reach with a thread pool depends on the continuous and spike free stream of tasks you assign to your pool. Let’s display this in a little image:

queue_opt

In this image we got 4 pool threads which are executing work and 4 more tasks which are queued up. The next step would be each thread would grab one tasks and the queue would be empty again (or 4 more tasks could be queued). Pretty optimal isn’t it? All work is getting done fast and clean.

And this is the way you won’t like it:queue_erro

Again, 4 threads, but this time there are 6 tasks scheduled. Now let’s consider 4 are executed, 2 remain in the queue 5 more are getting added. As you might recognize (easy calculation 6 – 4 + 5 = 7) now we got 7 threads in the queue. And that’s the danger with pooling up threads and using task queues. If you throw too much work at a pool which is to small you will generate a growing backlog which will hurt your performance pretty bad. And that’s the reason why the std::async object has the option to spawn additional threads. Basically it’s the hybrid from pool to thread. I personally don’t like it too much since the standard constructor does not guarantee a parallel execution. Nevertheless, with some tricks (like the launch flag) it can get pretty handy since (at least the MSVC++ version) internally relies on a thread pool with the option to spawn a new thread if the pool is under heavy load. I have to admit, I did what each professional programmer would call bad style and implemented my own one with my own rules so I basically know how it will behave since I feel pretty confident with C++ as such but well that’s nothing I can recommend to others…

Ok, that was tasking, threading on the other hand needs a lot of synchronization to work well and sometimes it might be better for your performance since you don’t have to rely on such high-level constructs like async or pools, but well… it’s pain in the ass to get it working as intended. Your parallelization is good as long as you don’t need to access resources from multiple threads but even then, you won’t block other threads from spawning. You always have to remember: If you try to access a locked item, actually your program gets serial instead of parallel. The trick is to get your work lock free and good timed. Try to split task well thought to threads to minimize data sharing between threads and you will se a huge gain.

Usually I would hand you a picture about regular threading now but this time I decided to simply leave it be since in my opinion you can imagine it pretty well your self.

Try this. You got a railway with a crossing in the middle where the rails change the sides. (Don’t ask why, they simply do.) Now you have a train on each of the rails. Well, one of them will have to wait until the other one is passed since they don’t want to crash. And that’s exactly what your locks do. Now imagine you would do those change-of-side very often. The trains would take a lot longer to the end of the track if they would try to go parallel as they would do if they would go one after another since both could go, none of them had to wait.

Super beautiful metaphor of mine with one simple conclusion. Sometime it’s better to go for single threaded application instead of forcing threading into a super complicated program with a lot of locking work to do.

 

I hope this one were helpful to some of you. If you have any ideas, suggestions or criticism, feel free to comment.

Some PC build suggestions…

Trust me I’m an engineer

With this article I will try to give you a little overview over the graphic cards, CPUs and other hardware components on the market. I won’t cover every single aspect but I will try to explain things as detailed as can without driving this article into a wrong direction.

I will mark up some of the explanations as optional. These explanations will be more in-depth and those of you who aren’t to interested into technical things and just want to have some simple “what should I buy “advises don’t need to read them.

Okay here we go. First of all, you should consider what you want to do with your computer. I will break it down onto some simple points.

  • Media PC (For people who are less interested in gaming, content creation and more into social media, YouTube, watching movies on it, use office tools etc.)
  • Entry-Level Gaming PC (For people who want to do everything a Media Computer     can do but also a little bit of gaming, like playing MOBA-Games, CSxyz and so on)
  • Mid-Range Gaming PC (Now things are getting more serious. This PCs are for those   who actually like gaming a lot and want to crank up the settings a bit but who don’t want to spend an insane amount of money on their computer)
  • High-End Gaming PC (Here we are, that’s the point where performance per dollar      went to the backyard and shot itself. Now things are getting pretty expensive. These PCs are for those people who start crying if the counter hits the 59 FPS mark while they are playing on max settings in front of their 200$ gaming keyboard which light up their tears in colours where even a rainbow would get envious.)
  • Enthusiast Gaming PC (For Gaming purposes the top of the iceberg. Nvidia called.   they want their SLI-Titan cards back. These are for freaks. And that’s exactly the reason why I won’t talk to much about these ones.)
  • Hobby Content Creator PC (These are for people who like to do content creation     stuff like video editing, Photoshop, 3D Modeling but also some gaming or game developing.)
  • Prof. Content Creator PC (These rigs are for those who need to do serious work with their computers. Primary professional designers. And that’s also the reason why I won’t say really much about these, the people who need them know what kind of hardware they should use.)

Puh, that are a lot of descriptions. Since I won’t focus too much on Enthusiast and Professional-Content-Creation computers, let’s get one thing straight tight of the bat: There are some graphics cards which are specialized on content creation. I won’t take them into consideration since they are for full professionals and I don’t have experience with them. Usually a gaming card can (more or less) serve the purpose of one of those as well and I decided to make this builds with gaming in mind. Please be aware of that.

Okay, let’s see where the second point leads us. I will consider both, AMD and Nvidia cards as well as I will take Intel and AMD processors into consideration, sadly I don’t have any Intel/Nvidia builds at the moment but at least some friends of mine do. I won’t exclusively feature the latest chips since in my opinion a R9 Fury still is a pretty good choice.

Maybe as third and last point before I start to talk about the interesting stuff: you don’t have to agree with my opinion. It’s fine if you don’t, but hell don’t get mad if I have another opinion. I am doing PC builds for a decent amount of time now (if I am allowed say something like this at my age 😉 ) and by now everybody who asked me for help was actually pretty happy with his choice. And also a word of warning. I try to stay objective but I can’t deny that I favour AMD cards over Nvidia cards, I will try to leave out my personal taste in favour of a fair comparison but if you catch me starting to get unfair, ignore it and read between the lines, I try…. I really do.

So, here we are… let’s start the interesting part.

I will build the hardware list as followed:

for CPU, Mainboard and RAM I will enter the CPU manufacturer in front of the component data since not every CPU will fit on every mainboard or work with every RAM Kit. For the rest of the build I just will write down the component name.

CPU: [CPU Manufacturer A] [CPU A Name] /  [CPU Manufacturer B] [CPU B Name]

Mainboard: [CPU Manufacturer A] [A Name] /  [ CPU Manufacturer B] [B Name]

Ram: [CPU Manufacturer A] [A Name] /  [ CPU Manufacturer B] [B Name]

and so on. If you are more experienced and know which parts fit together, feel free to mix the different builds together.

The Media PC:

This kind of PC won’t need a big amount of power. Office and Browsing won’t take too much resources so I will aim at a very cheap price for this one.

CPU: (ca 100€ each)

[AMD] [A10 7870K FM2+] / [Intel] [Core I3 7100 LGA 1151]

Mainboard: (ca 100€ each)

[AMD] [Asus A88X-Pro FM2+] / [Intel] [MSI Z170A SLI LGA 1151]

Ram: (ca 60€ each)

[AMD] [8GB G.Skill Ripjaws DDR3-1600 DIMM CL9] / [Intel] [8GB G.Skill Value 4 DDR4-2133 DIMM CL15]

Power Supply: (ca 40€)

450 Watt Corsair VS450 Non-Modular

SSD (optional): (ca 55€)

120GB SanDisk Plus 2.5″

HDD: (ca 50€)

1000GB Seagate BarraCuda ST1000DM010 64MB 3.5″

Case: (ca 30€)

Sharkoon VS4-S Midi Tower

Okay with SSD this PC has a total price around 430€.

In my opinion, a media pc does not need a dedicated graphic chip since the power simply isn’t required. Now we are facing the little problem that the new AMD Ryzen CPUs don’t feature an onboard graphic chip, and that’s why I replaced them with an older AMD APU which will get the job done quite well. Nevertheless I think the I3 is the more viable option for this build since it is a more modern chip and the A10 will be replaced soon. I am going to update this post to the new Ryzen APUs short after their release. The SSD is not needed but from my experience people who are using a media PC aren’t the most patient ones with their computer and if that’s the case, a SSD is worth gold. The SanDisk Plus isn’t the fastest one arround, but it will serve it’s purpose for a really low price.

The 450 Watt power supply is a bit oversized but I decided to give it a go since it offers the possibility to add a dedicated graphics card for gaming later on.

The Enty Level Gaming PC:

CPU: (ca 100€)

[Intel] [Core I3 7100 LGA 1151]

Mainboard: (ca 100€)

[Intel] [MSI Z170A SLI LGA 1151]

Ram: (ca 60€)

[Intel] [8GB G.Skill Value 4 DDR4-2133 DIMM CL15]

Power Supply: (ca 40€)

450 Watt Corsair VS450 Non-Modular

SSD (optional): (ca 55€)

120GB SanDisk Plus 2.5″

HDD: (ca 50€)

1000GB Seagate BarraCuda ST1000DM010 64MB 3.5″

GPU: (ca 120€)

4GB Gygabyte Radeon RX 460 Windforce OC

or (ca 150€)

4GB Gainward GeForce GTX 1050 TI

Case: (ca 30€)

Sharkoon VS4-S Midi Tower

Basically, this is our media pc with a dedicated graphics card (pricing around 550€-570€). The I3 CPU is fast enough for MOBAS, CSxyz or usually even things like World of Warcraft, the I3 Onboard Graphics on the other hand is pretty weak. That’s why we add a GPU to the build. (I also removed the AMD APU from the suggestion since in my opinion it is not a really viable option for a gaming pc right now, if you don’t want an Intel CPU, wait for the Ryzen 3 series, I will add them later). The rest stays the same. In this pricing point we are in kind of a weird situation. Broken down to 2 options (in my opinion) you have the choice between the RX 460 and the a bit faster but also 20 bucks more expensive 1050ti. The 1050 (no ti) is not really a good option since 2GB of Graphic memory is simply not enough today. That’s why I took the more expensive 1050 ti into consideration.

The Mid Range Gaming PC:

CPU: (ca 200€)

[AMD] [Ryzen 1500x AM4]  / [Intel] [Core I5 7500 LGA 1151]

CPU-Cooler: (ca 30€)

[AMD and Intel] BeQuiet! Pure Rock Tower

Mainboard: (ca 100€)

[AMD] [Asus Prime B350-Plus AM4] / [Intel] [MSI H270 Gaming M3 LGA 1151]

Ram: (ca 70€)

[AMD and Intel] [8GB Crucial Ballistix Sport LT DDR4-2400 DIMM CL16]

Power Supply: (ca 40€)

450 Watt Corsair VS450 Non-Modular

SSD (optional): (ca 55€)

120GB SanDisk Plus 2.5″

HDD: (ca 50€)

1000GB Seagate BarraCuda ST1000DM010 64MB 3.5″

GPU: (ca 250€)

8GB PowerColor Radeon RX 480 Red Devil

or (ca 250€)

6GB Gainward GeForce GTX 1060

Case: (ca 80€)

Fractal Design Define C Midi Tower

Total: ca 875€

Here we are. Things are becoming more serious. For our CPU I chose the brand new Ryzen 5 1500x for the red team and the I5 7500 for the blue team. That’s where the choice becomes hard. The Ryzen 5 1500x is a really decent CPU and usually a bit faster than the I5 7500. In my opinion the Ryzen 5 is the better all-rounder than the I5 7500 due to its additional 4 virtual cores. For gaming purposes usually you won’t recognize the 4 virtual cores anyway, but for software use cases (like 7-Zip, Paint.net etc.) the Ryzen 5 has a medium advantage compared to the I5 so I would recommend the red team here.

The GPU, well that’s also no easy decision. The PowerColour Devil is a really decent card and it’s 8 GB of video memory are actually more attractive than the 6 GB of the GeForce. That does not mean the GeForce would be a bad offering since the 1060 performs very similar to the RX480. Basically you can say the 1060 got the faster chip but if the memory is the limiting factor the 480 will win. Considering this I would recommend you to look up some numbers for the games you want to play and take the one which shines brighter in the games you prefer.

And last but not least: The case. I decided to go for a better case on the medium pc since in my opinion a better gift needs better packaging. Jokes aside… The stronger the graphics cards/processors get, the more important cooling gets. That’s why I decided to go for a better case with better airflow to keep things nice and cool. And I also decided that this is the point where the good old boxed cooler for the CPU get’s obsolete and added a custom one. I think the BeQuiet Pure Rock will do a great job.

The High-End Gaming PC:

CPU: (ca 280-350€)

[AMD] [Ryzen 1600x AM4]  / [Intel] [Core I7 7700 LGA 1151]

CPU-Cooler: (ca 75€)

[AMD and Intel] Enermax Liqmax II 240 AM4

Mainboard: (ca 100€)

[AMD] [Asus Prime B350-Plus AM4] / [Intel] [MSI H270 Gaming M3 LGA 1151]

Ram: (ca 115€)

[AMD and Intel] [16GB G.Skill Flare X DDR4-2400 DIMM CL16]

Power Supply: (ca 80€)

600 Watt be quiet! Pure Power 10 CM Modular 80+ Silver

SSD (optional): (ca 55€)

120GB SanDisk Plus 2.5″

HDD: (ca 50€)

1000GB Seagate BarraCuda ST1000DM010 64MB 3.5″

GPU: (ca 350€)

4GB Sapphire R9 Fury Nitro

or (ca 420€)

8GB Gigabyte GeForce GTX 1070 Windforce OC

Case: (ca 80€)

Fractal Design Define C Midi Tower

Total: ca 1300€

Ok, that’s the high-end build. Let’s start with the CPU again. For this build I decided to go for an I7 7700 (non K) CPU and a Ryzen 7 1600x. (For the overclockers out there, I am pretty sure you know pretty well what you need/want/can do, this one is for “average” users, you are pretty likely advanced users) And yes I went for the Ryzen 1600x. The 1800x is the current enthusiast CPU from AMD ok, but we are still within the high-end range. And yes, I also could go with an Ryzen 7 1700/x. The hard (funny, ironic, cool? maybe a little sad) truth is: The Ryzen 5 1600x will equal and/or outperform the 1700/x in almost every single game. For gaming, the Ryzen 7 1700 is kind of no option for me since the 1600x arrived. The 1600x is 60-100€ cheaper and still the better GAMING CPU. Enough of Ryzen, back on track. The I7 7700 is the faster CPU (in most cases) but also 70€ more on the pricey side and the Ryzen 5 1600x should be enough to max out every GPU.

I would go (ok seriously…. I went 😉 ) for the Ryzen 5 instead of the I7 7700 since you won’t need an I7 for gaming. It’s just overkill. And actually there are cases arround where the Ryzen beats the I7. (Still, the I7 is a very very…..ry decent CPU.)

So… let’s explain the GPU choices. Since AMD still hasn’t released high-end or enthusiast GPUs for this generation we run into a little shortage here. I thought about this a long time and came to the following conclusion.

First option: Go for an old R9 Fury. The R9 Fury still is a very decent card and performs really decent. (I know it, I own one) The Fury will still manage to get stable and high FPS on max settings in nearly every title you throw at it, even at 1440p. The downside is the card only features 4GB of VRAM and HBM or not, if the limit hits you, you are screwed. In situations where a R9 390x Devil OC’d to 1250 MHz beats the shit out of your (at its time) 100€ more expensive R9 Fury you should ask yourself what the hell you did wrong…

Second option: Go for the green team, Geforce 1070. The 1070 is a decent card. (even since it’s suffering from the usual Maxwell/Pascal DirectX issues which I will explain at the lower part of this blog post) The price to performance ratio is really ok for a high and card (and ok for a high and card means really good since high-end cards are shit at price/performance points). I can’t tell how future proof the 1070 will be. But I can tell you it is at least as future proof as the Fury (and yes I wouldn’t even say the Fury is less future proof… look at the Hawaii Chip from AMD… released 2013, still a high-end card, so I can’t tell what happens to the Fury performance wise in the future). At the moment the 1070 is faster than the R9 Fury but it also costs 100€ more.

Third option: Wait for AMD Vega and think again. Maybe Vega will be a big thing, maybe it won’t. What I read and interpreted (from a well-informed point of view) Vega could be really awesome, so I would consider giving it a shot. Your old 780 ti / 970 / R9 390 will manage to work for another 2-3 month and then you might have the privilege of choosing from all that shiny new cards!

I also cranked up the power supply size for some crossfire / SLI experiments with lower tier cards (like 470s or 480s or 1060s) which I can’t recommend since SLI/CF is always a struggle. And the last point, I changed the CPU cooler to an all-in-one water loop for (some) better cooling performance since the Ryzen 5 is capable of XFR and I am not 100% sure what the future do for that feature, but if it becomes a thing, better being prepared.) (XFR will be explained later.)

The Enthusiast-Build:

CPU: (ca 400-500€)

[AMD] [Ryzen 1800x AM4]  / [Intel] [Core I7 6800k LGA 2011-3]

CPU-Cooler: (ca 75€)

[AMD and Intel] Enermax Liqmax II 240 AM4

Mainboard: (ca 180€)

[AMD] [MSI X370 GAMING PRO CARBON AM4]/[Intel] [Gygabyte Ga-X99-UD3 LGA 2011-3]

Ram: (ca 115€)

[AMD and Intel] [16GB G.Skill Flare X DDR4-2400 DIMM CL16]

Power Supply: (ca 100€)

850 Watt Corsair CX Series CX850M Modular 80+ Bronze

SSD (optional): (ca 55€)

120GB SanDisk Plus 2.5″

HDD: (ca 50€)

1000GB Seagate BarraCuda ST1000DM010 64MB 3.5″

GPU: (ca 1000€)

2x4GB R9 Fury X

or (ca 1000€)

2x8GB Gigabyte GeForce GTX 1080 Windforce 3x OC

or (ca 1000€)

11GB Gigabyte GeForce GTX 1080 Ti Gaming OC

Case: (ca 150€)

Corsair Crystal Series 460X RGB

Total: ca 2225€

I wouldn’t recommend doing this. You won’t need it, it’s overkill, and if you are an enthusiast you will be unhappy with it next year when the new hardware arrives.

Ok… well… I guess I’ll have to do it anyway, so here is my explanation.

The CPU. Logical choice Ryzen 7 1800x, the largest of the AMDs also suited for gaming since it is the fastest one of them… (Basically a 1600x + 2 physical cores). Blue side… Well since this is a gaming build I should mention one thing. It may happen that an I7 7700k performs better than the CPU I chose, but with the future in mind, I went for the 6800k since it has more cores and future game might benefit from it. Ok why am I not recommending the I7 6900… It’s easy… no gamer should ever buy this overpriced chunk of silicon for over 1000€. That’s why. Okay I can imagine exactly how some smartasses won’t like to hear that. Well I know… enthusiasts are enthusiasts, that does not make this a smart choice. Ok. Good example. Look at JayzTwoCents (If you read this, big fan btw.) for instance. Well his rig is completely overkill but at least he is content creator so he can benefit from such a CPU. I wonder what he would say if you ask him what he thinks about the price/performance (and especially gaming performance) ratio of the Intel octa-cores. I am pretty sure he will agree with me. And that’s why I didn’t recommend it. You won’t need it. And it might even happen that the third the price I7 outperforms the I7 6900 in gaming. Ok enough hating… If I were forced to choose between the Ryzen 7 1800x and the I7 6800 I probably would go with the Ryzen since in some cases (or maybe in the future always) it performs better than an I7 6800 and I favour AMD anyway 😉 (fanboyism and things). The Ryzen CPU is better suited for content creation but it’s gaming performance is still good enough. Still, at the moment the I7 will outperform the Ryzen 7 in most cases simply since there are still optimizations to be done with Ryzen which makes the I7 the better “gaming” CPU (if you want to force me calling one of those two a gaming CPU). If you are an overclocker you might take a look at the Ryzen 7 1700 since some people said to get better performance out of an OC’d 1700 than you could reach with the 1800x model.

The GPUs. Due to the lack of enthusiast AMD cards of this generation you are forced to use 2 Fury X cards in Crossfire or one Radeon Pro Duo if you want to go for the red team.

The green team gives you two options… SLI 1080’s or an 1080 ti.

Basically I can’t recommend any of these three options but if I were forced again I would go for the 1080 ti since one big card is always better than two small ones, but if I had a choice, I would wait for Vega.

The case: Well, you don’t spend 2000 bucks to not show the world how fancy it looks.

Puh, I am thankful that I am done with this one.

Hobby Content Creator PC:

CPU: (AMD ca 340€ Intel ca 500€)

[AMD] [Ryzen 1700 AM4]  / [Intel] [Core I7 6800k LGA 2011-3]

CPU-Cooler: (ca 75€)

[AMD and Intel] Enermax Liqmax II 240 AM4

Mainboard: (AMD ca 100€ Intel ca180€)

[AMD] [Asus Prime B350-Plus AM4]/[Intel] [Gygabyte Ga-X99-UD3 LGA 2011-3]

Ram: (ca 250€)

[AMD and Intel] [32GB Corsair Vengeance LPX schwarz DDR4-2400 DIMM CL14 Dual Kit]

Power Supply: (ca 80€)

600 Watt be quiet! Pure Power 10 CM Modular 80+ Silver

SSD: (ca 140€)

480GB SanDisk Ultra II 2.5″

HDD: (ca 100€)

2x1000GB Seagate BarraCuda ST1000DM010 64MB 3.5″ (For RAID 1)

GPU: (ca 250€)

8GB PowerColor Radeon RX 480 Red Devil

or (ca 220€)

8GB MSI Radeon RX 470 Gaming

or (ca 250€)

6GB Gainward GeForce GTX 1060

Case: (ca 80€)

be quiet! Pure Base 600

Total: AMD ca: 1415  Intel ca: 1625€

Ok, the hobby content creator rig. There will be a bit of explanation. First of all, (like always) the CPU. Let’s start with some general points. Media workloads like encoding, packing, Photoshop can benefit pretty good from multiple CPU cores and much RAM, that’s why I went for the Ryzen 7 1700 or the Intel I7 6800. By the way, that’s why I really CAN recommend using the I7 here. Personal I would still go with the Ryzen 7 here but at least the 6800 is no bad choice this time. Why would I go with AMD. Actually it’s pretty easy. Ryzen is really good at parallel workloads which makes it a really decent “content creation CPU”. In this kind of software the Ryzen 7 1700 is faster in almost every benchmark AND, it costs a lot less. You can run it really good with a 100€ Mainboard and the chip itself is 140€ cheaper than its competitor which makes him (in my opinion the more attractive choice. (Still the Intel I7 6800 is a really good chip for this purpose.

The RAM: I decided to go with 32 GB for this since from my experience a lot of RAM can be pretty handy if it comes to content creation. Usually 16 GB will fit everybody’s needs, but sometimes the additional 16 GB can pay off.

The GPU: As I already mentioned, there are special cards for content creation out there (The Nvidia Quardro or AMD Fire cards) and you are free to use one of them, they are really good in what they are designed for. Nevertheless, current gaming cards are also capable of content creation (and not even bad at it). And that’s where one of the little problems hits us. Actually Nvidia cards are better suited for need like Photoshop, Blender etc. since they are using Cuda (something AMD can’t use since it’s copyrighted by NV) for Nvidia cards and OpenCL for AMD cards. Cuda works better. Trust me. On the other hand is a lot of VRAM (video memory) also pretty handy for content creation. (Especially for video editing as far as I know) And that’s the point. Usually AMD cards had (not anymore) more video memory but the chips aren’t capable of Cuda. I think the best option at this point is the 1060 for hobby creators since 6GB VRAM are enough for the most things and it understands Cuda. And that’s why I recommend the 1060 for beginners. The 480 and 470 will also perform ok but I am pretty sure the 1060 will perform better. You are always free to choose a bigger card (like a 1070) but they also are more expensive, and this is ment to be a PC for hobbyists.

The SSD: In my opinion as a content creator you want to have an SSD to work at since you are save a lot of waiting time. The final products can be saved on the HDD but you should definitely work with an SSD:

The HDD: Here we are for one of the more interesting parts. I decided to take two HDDs and let them run in RAID 1 (which also will be explained later…;)) to be prepared for HDD failures. I think it would be pretty annoying if you worked weeks for something and you lost it due to a HDD failure.

The Case: I decided to go with an insulated pc case since I am annoyed of my PC if the fans ramp up (I only have a Corsair Spec 03 case so the full acoustic experience) and it really prevents me from concentrating while I am drawing or testing my game dev stuff. The BeQuiet Pure Base is not expensive and does its job pretty well.

Professional Content Creator PC:

CPU: (AMD ca 500€ Intel ca 1100€)

[AMD] [Ryzen 1800x AM4]  / [Intel] [Core I7 6900k LGA 2011-3]

CPU-Cooler: (ca 75€)

[AMD and Intel] Enermax Liqmax II 240 AM4

Mainboard: (AMD ca 100€ Intel ca180€)

[AMD] [Asus Prime B350-Plus AM4]/[Intel] [Gygabyte Ga-X99-UD3 LGA 2011-3]

Ram: (ca 250€)

[AMD and Intel] [32GB Corsair Vengeance LPX schwarz DDR4-2400 DIMM CL14 Dual Kit]

Power Supply: (ca 80€)

600 Watt be quiet! Pure Power 10 CM Modular 80+ Silver

SSD: (ca 270€)

960GB SanDisk Ultra II 2.5″

HDD: (ca 100€)

2x1000GB Seagate BarraCuda ST1000DM010 64MB 3.5″ (For RAID 1)

GPU: (ca 800€)

Nvidia 1080 Ti

or (ca 900€)

Radeon Pro Duo

Case: (ca 80€)

be quiet! Pure Base 600

Total: AMD ca: 2255€ Intel ca: 2935€

Basically for this one you can apply the same rules as you do to the hobby builds (with some little exceptions)

First of all: Now I can recommend the Ryzen 7 1800x or the I7 6900k since if you are a professional content creator, you will work in larger and also more projects. That means even if you save 2 minutes per project you are editing, it will add up. Let’s consider rendering a complicated scene in blender for instance would take 10 minutes. Now let’s consider you would save 10% with 2 additional physical cores ( + 2 virtual cores –> 4 additional cores) which means you save 1 minute. Now let’s consider you want to  render 450 scenes. Gratulation, you saved 45 minutes. Ok well this example is really set up and not to realistic but what I want to show off is that you will recognize the difference if you are using the stuff frequent enough and that’s why it’s not a bad idea to spend a bit more for your CPU if you do this at a professional level. But even at this point I would go with Ryzen in this case since the Ryzen 7 1800x is as fast (and often even faster) than the I7 6900k in applications and costs half of the I7. But still, the I7 is no bad choice here.

SSD: I cranked up the SSD size. Since you are doing more projects (sometimes parallel) as a professional user you will need mor storage for your current projects in progress as a hobbyist.

GPU: To be honest, in my opinion it would be the best to get a Quadro or FirePro card, but hell they are expensive. Even more expensive than the 1080 ti or Radeon Pro duo. And that’s why I would recommend the 1080 ti here. The Pro duo is just a doubled R9 Fury and the 1080 ti is a really fast card so you won’t regret it.

Case: Same Argument.

Okay that are my build suggestions at the moment. Later on I will add Vega and Ryzen 3 to the consideration but by now the only thing which is left are the optional explanations.

The “Maxwell/Pascal DirectX 12 problem”:

The short form? The Nvidia Maxwell and Pascal Architecture is lacking a more or less important DirectX 12 feature which could improve the performance.

The long way?

DirectX 12 brought us a feature which is named Async Compute. Basically Async Compute is (kind of)”lock free” multithreading for your GPU. Usually if you want to pass a task into a multithreaded environment you have to lock down the queue, append the task and then unlock the queue. Async Compute (kind of) allows to queues tasks up without locking the queue which leads to a better GPU load balancing since assigning a task to the GPU take less time and resources.

The people are always like wow, that’s no big deal, but actually it is. Yes DirectX 12 will take a while to be established in the gaming world, but things like this are delaying this process even more. If Nvidia cards can’t handle or even suffer under ac, the developer won’t use it that frequently. And especially with a feature like ac that’s pretty fatal if you ask me, since it has the potential for a decent improvement of my gaming performance.

And btw, hiding the lack of ac, and after it came out bashing the developers who found out is a dick move anyway.

RAID 1:

Basically, RAID 1 mirrors you hard drive. If you copy something to a RAID 1 drive, it get’s mirrored to the other RAID 1 drive and if one of the drives dies, the other one still has a backup of the data. RAID 1 is meant to prevent data losses if a hard drive fails.

XFR:

Ryzen CPUs (at least some of them) are capable of overclocking themselves if the temperature allows it. You shouldn’t expect oc wonders but with a good cooler you might get improvements of 100-300MHz and if development goes on, it might even get more.

Ok, here we are now… this is the end of this damn long post. I hope this one is helpful to someone and i’ll try to keep it up to date.

Now for the public amusements, here is my rig and a build I did recently with a friend of mine.

My rig:

(Ryzen 5 1600x, 16 GB ram, MSI Tomahawk B350, 2x240GB SSD 1x 480GB, R9 Fury)PCT01

PCT02

And my friend decided to purchase himself a in home disco. I like it.

(Ryzen 5 1600x, 16 GB ram, MSI X370 Gaming Pro Carbon, 1x 480GB, R9 390x Devil)PCL01

PCL02

And for those who want something to laugh, since Lepa was friendly enough, NOT to send us our AM4 mounting kits, here are our own ones, with blackjack and hookers.20170413_153850

(don’t worry, the zip ties can hold a higher temperature than the socket will reach 😉 trust me I’m an engineer)

It’s a start

Today I finished my first little animation. It may look a bit awkward, but I am pretty satisfied for my first animation and happy that is does not look completely stupid, well It’s a start.

Say hello to Tiki-Jack.

TikiJack1_0

I also started to develop in Unity and by now, it’s really nice as far as I can say. A lot of workflows aren’t new to me and the engine is actually pretty handy. I am looking forward to show you guys my first “real” game in Unity. But until then I will continue practicing drawing and designing.

That’s all for now. For those who are interested, some date next week I am going to release some build suggestions for gaming pc since Ryzen 5 is released and in my opinion it’s a perfect time to give some hints since I can take Vega into the picture later.

My first steps in character design

Some days ago I decided to start getting into character design. By now every time I tried to make a little game for practice (for example my sidescroller shooter) I were forced to search for free sprites on the internet (or use dummy sprites) which were pretty annoying.

Starting to deal with character design my self were one of the best decisions I made so far since making games became a lot more fun. My first steps are small ones, but at least it’s a start and I can try to figure out the complete progress of making games.

For those who are interested, this is my first “serious” character project (still in progress).

character_screenshot

It’s far away from finished, but it’s a start and I hope it will be a hilarious sprite sheet and artwork in the end.

If I am done, I am going to release all sketches, or interesting states of this project so maybe it helps someone to give him a point where he/she can start.