Introducing C++ Part 2

This part of the tutorial takes a look at variables, automatic conversions, memory and pointers / references.
The concepts presented may seem a bit abstract if they’re new to you but it will get more concrete once you start writing some real code.

As for types of variables this section uses only the built-in basic types such as int, double, char and pointers.

In C++ the type of an object determines the possible data that an object may contain and what operations that object may perform.
At the same time, C++ gives the programmer a lot of control in terms of what to assign to variables of different types and will let you assign types that are not directly matching through the use of automatic conversions.
It is therefore vital to understand what happens if you assign a value to a variable that it isn’t defined to use.

Conversions of basic types

You can think of conversion with basic types as being either “widening” or “narrowing”.
Widening conversions happen when you assign data to a variable that is narrower in scope than what the type is capable of handling.

An example of a widening conversion could be when you assign a integer value to a floating type variable.

int i = 10;
double d = i;

In this example variable d would have the value 10.0 after the conversion has taken place, no information is lost in a widening conversion.

Widening conversions also happen automatically when you mix integer and floating types in an expression:

double sum = i + 5.5;

Here variable i will be auto converted into the double value 10.0 before being added to 5.5, resulting in 15.5.

Narrowing conversions

double pi = 3.14159;

int i = pi;

What value does i get? It gets 3, because when we put a fractional number into an integer variable, the fractional part is truncated, as in ignored, wasted.

This is an example of narrowing conversion.
The range of values that fits in an int is more narrow than what fits in a double.

Narrowing conversions can easily be a source of errors.

In expressions containing literal values, int is the default type for numbers without decimals and double is the default for numbers containing a decimal part. This can be overridden using type specifiers following the value and will be covered later.

bool b = false;
char c = 'A';
int i = c;
b = i;

Now, what is the value of i and b?

i gets the ASCII to integer value 65, and b gets the value true.

A Boolean may only contain 0 for false or 1 for true. Any value that is not 0 will be converted to true.

Also, if we use characters in an arithmetic expression, the result is converted to an integer.

int i = 5;

double d = i;

d gets the value 5.0, as one might expect.

But what happens in this example:

int i = 123456;

short s = i;

cout << s << endl;

This leads to Undefined behavior. You can put an int into a short, but It will overflow, literally if the value of the int is larger than what a short can handle.
But the compiler accepts it, so be aware!

Memory, Pointers and References

So what are pointers and references?
They are both a way to indirectly access stored memory locations.
When we assign a value to a variable, that variable is a named memory location and internally the variable has a memory address that contain the actual data.

By using pointers and references we can access and alter these dynamic memory locations indirectly from the variable itself.

Many attempts to explain pointers using various analogies have been tried out but in my view they mostly fail to convey the intentions and usefulness of pointers in C++ and its C heritage.

All though a shallow understanding of pointers may get you by your task at hand, a deep understanding of heap and stack memory and pointers are required for understanding C and C++ on a deeper level.
Whether you want or need this “deep” understanding is off course up to you, but I recommend wrapping your head around pointers if you wish to be able to manipulate data with persistence and confidence in C and C++.

Faster and more efficient code can be written because pointers are closer to the hardware.
That is, the compiler can more easily translate the operation into machine code. There
is not as much overhead associated with pointers as might be present with other
operators.

Going deep into various uses of pointers fall outside the scope of this basic tutorial, but I encourage you to read the following
book about C and Pointers which also for the most part relates directly to C++ as well.

Understanding and Using C Pointers by Richard Reese

As your programs get more complex and include things like multi-threading and concurrency, the need to understand pointers also increases significantly as you then have to work with multiple stacks and other goodies.

Memory

Both the heap and the stack is stored in RAM.
The stack is a limited source of memory, the heap is a dynamic source of memory.
The stack is set to a fixed size, and can not grow past it’s fixed size. If there is not enough room on the stack to handle the memory being assigned to it, a stack overflow occurs.
This can happen when a lot of nested functions are being called, or if there is an infinite recursive call.

If the current size of the heap is too small to accommodate new memory, then more memory can be added to the heap by the operating system. This is one of the big differences between the heap and the stack.

A program generally works with three types of memory:

Static / Global Memory
Includes static and global scope variables. The lifetime of these variables is the whole lifetime of the application.

All functions have access to the globally scoped variables but static variables are limited to the defining functions where they are created.
Static variables are basically global variables with limited scope and there are always only one copy.
Statics / globals are useful for memory that you know you will always need and you know that you don’t ever want to de-allocate.

Stored on the stack.

Automatic / Local
Variables declared within a function. Created when the function is called and the scope and lifetime is limited to the time the function is executing.

Stored on the stack.

Dynamic
Memory is allocated from the heap and can be managed manually as nessecary (released). A pointer references the allocated memory.
The scope is limited to the pointer or pointers that references the actual memory and they exist until they are released.
Stored on the heap.

How to define and use pointers and references

The symbols * and & are the two basic symbols used to obtain pointers and create references.

A reference can be thought of as an alias for a variable. Once you bind a reference to an object you can’t re-assign it to another object.
A reference is not a type. This is a distinctive difference between references and pointers.

int i = 42;
int &r1 = i;

You can create multiple references pointing to the same variable.

int &r2 = i;
r2 = 43;

This changes the value stored by variable i.

A pointer is an actual type, and is not bound to its initial assignment in the way references are.

int i2 = 43;

int *p1 = &i // & here means "address of" (see below)

Now p1 “points to” the location of i’s data and can change the data indirectly.

p1 = &i2;

Now p1 “points to” the location of i2’s data (43). variable i is not affected.

The & and * symbols are “context sensitive”. They mean different things in different contexts.
It’s very important to be able to interpret the symbols in the correct context!

Syntax for using * and &, an overview:

int i = 42;

int &r = i; // & following a type and is part of a declaration: & means reference
int *p; // * following a type and is part of a declaration: * means pointer
p = &i; // & used in an expression: & means "address of"
*p = i; // * used in an expression: * means "de-reference" (get value of)
int &r2 = *p; // & is part of a declaration (reference), * means de-reference

You can (should) only access or de-reference a pointer that is valid, e.g. that points to an object!

Null Pointers

A null pointer does not point to any object.
You can check if a pointer is null before using it and you should always do so.

There are a couple of ways to obtain a null pointer:

int *p3 = 0;
int *p4 = nullptr;

If you include the C Standard Library (cstdlib) you can also do:

int *p3 = NULL;

The preferred way in C++11 is to use the second option:

int *p = nullptr;

Nullptr is a literal and has a type that can be converted to any other pointer type.
In the next post I’ll go into some more details of constants and how they relate to pointers and references.

 

Introducing C++ Part 1

Hello again!

This post was initially meant to go straight on with the Unreal coding standards and the way they express C++ in the engine code.

I’ve made a little detour, as this series was meant to include both those new to C++ and those new to Unreal.

I don’t feel that the Unreal coding standard is much used outside of the Unreal Engine, so in the first posts that actually involves how to write C++ I’ve chosen to use my own coding standard.

All the content from the posts that contain C++ introductory material will also be posted to the C++ page on this blog, and it is also meant to be read by those that wish to learn C++ and not necessarily the Unreal Engine as well.

This might seem a bit clunky, and indeed it is, but this is the way I’ve decided to do it.

So this post and the next few posts will mainly contain C++ until I’ve presented what I believe is a minimum of required knowledge to get started with game development using any engine with a C++ API.

So, let’s get started.

C++ Introduction

C++ is a general purpose programming language with a bias towards systems programming that supports data abstraction, object oriented programming and generic programming.
C++ is a compiled, statically typed language, which means that the compiler must know the type of every object used in a program.

C++ is used in various fields of computer science including computer games.

It received a massive overhaul with the C++11 standard that introduced many new features, such as auto type deduction, lambdas and closures.

The development continues with the C++14 standard and compiler vendors have a great deal of work to do to make their compilers support all the latest features.

What makes C++ a good choice for mobile platforms and systems programming and games is that C++ produces very effective executable code that has low power consumption on mobile platforms combined with great performance in general.

This introduction will make use of some of the new features introduced in C++11, as these features makes C++ easier to understand and more safe to use in many ways.

Most popular compilers that I know of support most of the C++11 standard at the time of this writing, at least what we’ll present in this series of posts.

Why learn C++?

There are many reasons for learning any programming language. What makes C++ a good choice for those who plan on doing programming as a part of their careers?
First of all, C++ has been used in all kinds of systems since the language became an ISO Standard in 1998 and also before that.
Many of those systems that was created back then are still in heavy use today and demands maintenance programmers to keep them up to date.
A great deal of software that we use in our day to day lives today depends on C++ to keep running.

Many new software systems created today also uses C++ because of its universal properties, making it a safe, stable and long-term alternative for cross platform development of various systems, not tied to any manufacturer and not owned or governed by any company.

For more information on C++ as a language and links to various standards, compilers and libraries, visit:
http://www.stroustrup.com/C++.html

There is a ton of valuable information on that page, covering a vast amount of topics.

How to learn C++

If you’re reading this, my guess is that you either want to learn how to use C++ in your programs.
I do not claim that the introduction offered in this series of posts will be anywhere near sufficient to make you a C++ developer.

This is only meant as a starting point for learning more of the intricate nuances that C++ programming is all about.

I want to introduce you to some of the concepts that I found tricky to wrap my head around when I started learning about the C++ programming language, before the YouTube age and the massive amount of learning opportunities available today.

The fact that the sources for learning C++ has become so many and so diverse actually doesn’t make it that much easier, because you have to know what sources to trust as being good and that in it self is a rather hard task if you don’t know what to look for!

I’ve seen both paid and free resources available for learning C++ that range in quality from down right pathetic and plain wrong to excellent and well worth your precious time. Just remember: What you pay for is not necessarily what you get.

In these posts I’ve tried to extract knowledge from various books I wish I had when first learning C++, and turn it into easily digestible bits of information.

Some of the books I highly recommend and that I’ve used as inspiration for writing this series include:

Programming – Principles and Practice Using C++ 2nd Edition by Bjarne Stroustrup et. al
C++ Primer, 5th Edition by Lippman, Lajoie and Moo
Think Like a Programmer – An Introduction to Creative Problem Solving by V. Anton Spraul
Understanding and Using C Pointers by Richard Reese
Effective Modern C++ by Scott Meyers
Safe C++ by Vladimir Kushnir
The C++ Programming Language 4rd Edition by Bjarne Stroustrup

These are all books that are verified and accepted as good learning material by the C++ community at large and is a safe bet if you want to know more about the vast areas of programming and to find specific information about using C++ in the best ways possible.

How to structure the material

I’ve seen many attempts to divide the beginning concepts of C++ into logical parts that makes it “easy” or easier to understand.
Some introduce functions before references and pointers, some introduce classes before general compound types and some choose to ignore the concepts of memory, pointers and references all together in the beginning chapters.

To me that’s all a bit too abstract. I prefer a more direct path.
Before learning to use functions I feel that it is imperative to know something about constants and references, as this will get more important when trying to write various functions that can both manipulate its arguments directly or being denied to change its
arguments as a whole.

I also feel that even though Object Oriented Programming (OOP) has many important uses it is also maybe the most abused concept in modern programming. This is a direct consequence of pure OOP languages such as Java that requires you to create a class just to do a simple “Hello World!” program.

In C++ OOP is an option but not a requirement. You can choose when to start introducing objects into your code and if you can do without it, why complicate matters if it doesn’t lead to anything other than unnecessary complexity?

Well, enough said.
Let’s get on with the actual introduction to programming in C++.

Variables and Basic Types

C++ defines a set of built-in primitive types that include the arithmetic types and a special type named “void”.
Void will be described later when we start talking about functions.

Arithmetic types are divided into “integral” types (numbers) and also include characters (char), like ‘A’ and Boolean (true/false) and floating point types (numbers with a fractional part), like 3.14.

Before continuing on, let’s detour into how these types are stored in a computer.

How machines represent the built-in types

As many knows, computers store data as a sequence of bits. each holding either the value 0 or 1. This is referred to as the binary number system.

That is a stream of bits, like 0001110011001110 …

To keep track of the stored values in memory, computers group chunks of “bits” and the smallest chunk of addressable memory is referred to as a “byte” and is usually made up of 8 bits.

The computer’s basic character set is used to define the size of a byte and in C++ a byte has “at least” as many bits needed to hold a character.
Most machines operate with 8 bit bytes and the ASCII basic character set.

The basic unit of storage is called a “word” and consists of a small amount of bytes grouped together. On 32-bit systems this is usually 4 bytes (4 * 8 = 32) and on 64-bit systems it is the double of that, 8 bytes (8 * 8 = 64).

You can visually represent a word like this:

byte-ordering

There is also a concept of Big-Endian and Little-Endian that describes the order of the bytes in memory and in transmission over a digital link. This is not something you need to concern yourself with when starting out, but it is an important topic later on.
The concept of “Big-Endian” vs. “Little-Endian” can be further investigated here:

https://en.wikipedia.org/wiki/Endianness

The following is a short description of the various arithmetic types.

C++ is designed to let the programmer exploit hardware specific optimizations and therefor provides a number of different types to squeeze the most out of any given hardware platform.

In practice, and when beginning to learn about C++, don’t get caught up in all the details.
The provided information is only provided for the sake of completeness.

Characters

There are a few different character types available, to accommodate for various needs and extended character sets.
The basic character type is called char and big enough to hold numerical values corresponding to the machine’s basic character set.
In addition there is wchar_t, char16_t and char32_t, all used for extended character sets.

char16_t and char32_t are intended for Unicode characters. Unicode is an example of an extended character set.
wchar_t is guaranteed to be large enough to hold any character in the machine’s largest character set, whatever that may be.

The character types has corresponding numerical values that maps to the different characters thay can represent,
like the character ‘A’ correspond to the decimal number 65, ‘B’ is 66 and so on.

Floating Types

These represent single (float), double (double) and extended precision (long double) values.
The standard only specifies a minimum number of significant digits but most compilers provide more precision than the required minimum.
Typically a float is represented in 32 bits giving it around 7 significant digits of precision, a double is stored in 64 bits with around 16 digit precision and a long double is stored in either 96 or 128 bits. The precision of all floating types are hardware dependent and the use of long doubles are largely dependent on the given hardware support.

Signed and Unsigned Types

Except for bool and the extended character types, the integral types may be “signed” (can contain negative values) or “unsigned”
(can only contain values 0 or above).
One way to remember this is that to use a negative number, you have to use a sign (the – sign), hence you need a signed type.

The types int, short, long and long long are all signed types and can contain values below 0. (negative numbers).

We can get the corresponding unsigned type by adding the word “unsigned” before the name of the type, as in unsigned int.
In the case of int you can use the abbreviated form of just unsigned, as in:

unsigned count = 0;

Signed and Unsigned Characters

To complicate things a bit more, there are three different types of characters.
char, signed char and unsigned char are all distinct basic character types.
There are actually only two representations of characters in memory, signed or unsigned, but the plain char uses one of these depending on the compiler you use.

The 8-bit unsigned char can hold values from 0..255 (inclusive) while the signed char can hold values from -127..127.
Most modern machines use representations that allow -128..127, but the standard only guarantees -127..127 (inclusive).

What to use when?

As mentioned earlier, all though C++ provides a staggering amount of arithmetic types, you’ll find yourself using only a handful of these on a day to day basis.

Some rules for what to use when can include:

  • Use an unsigned type when you KNOW that the values should never be negative
  • Use regular int for integer arithmetic. (short is usually to small and long usually has the same size as int)
  • Use long long if you KNOW that the value will exceed the minimum guaranteed size of an int
  • Use double for floating point computations
  • Don’t use char or bool for arithmetic expressions. Only to hold characters or true / false respectively

Next time I’ll cover some information regarding type conversion!

Stay tuned.

INTRODUCTION TO GAME DEVELOPMENT WITH UNREAL 4 AND C++ – PART 2

This section will explain what a project in Unreal is about, and some of the terminology used in the Unreal Engine Documentation, such as objects, classes, actors and pawns.

Projects

So, what exactly does a UE4 project consist of and what is going on when you create one?

A project consists of everything you want to include in your game, all content and all code for interacting with the objects in this content and can be seen as a self-containing entity from which your game is created.

When you create a project you include the source code for the engine in the project and basically you’re working on a separate version of the engine for every game you create.

This is why the start-up of a new UE4 project is taking so long, as the source code must be compiled before you can use the engine in your game. The next time you open your project, things will start a lot faster.

From the Project Page in the Unreal Editor, you can define the basic properties for your project, such as whether you want to start off with a Blueprint or a C++ based solution.

As mentioned earlier, this choice does only concern how the initial gameplay is defined within your project and can be changed around later.

Also, the Project Page defines what Build Target you’re developing for, as in Desktop / Console, Mobile or any other target you plan on developing for.

This is also a setting that can be changed later, in the Project Properties page in the editor after creation.

You can chose between Scale-able 2D / 3D and Maximum Quality graphics. This setting is also configurable after initial creation and is mostly relevant if you create for mobile platforms.

The project I’ll be creating in this series is called “TheMadMan”, and will be a basic UE4 C++ project that contains no starter content.

blog_unreal_cpp_00

The assets used in the project can be downloaded from GitHub along with the source code and project files if you care to follow along.

I’ll cover setting up a GitHub repository for your own projects in a separate post, where I’ll also give you the address for my project files used in this series.

The different templates you can choose from are examples of different gameplay modes and will be discussed later. For now I’ll go with “Basic Code”.

When I hit “Create Project”, the UE4 Editor starts working with setting up the source code for my project and Visual Studio launches to work through the code produced by the editor.

The editor will detect changes to the code made in Visual Studio and reload any changes back into the editor, and changes initiated in the UE4 Editor will update in Visual Studio.

The default “map” or “level” or “scene” is created in the UE4 Editor. The terminology I’ll use for this is a “level” as this is what it is often referred to in the UE4 Documentation and I personally feel that it gives more meaning than “map”.

The level that starts up with your project is by default called “Untitled”, and you can see this in the lower right of the viewport and on the tab in the upper left corner of the screen.

You can save the level with a different name by choosing File → Save As, or using Ctrl+Shift+S and giving it a new name.

When the Unreal Editor starts your project it will look in the Project Settings to determine what level (map) that loads as default into the editor.

Even if you save your map with a new name, it will load the Untitled map when you start your project if you don’t specify otherwise in the Edit → Project Settings → Maps & Modes → Default Maps → Editor Startup Map.

You can see your newly saved level (map) in the Content Browser, which is a central component of the UE4 Editor.

ue4_new_project

A project is stored with a .uproject extension

Although a project is often referenced by the .uproject file associated with it, they are actually two separate files that exist alongside each other. The .uproject is a reference file used to create, open, or save a file, whereas the Project contains all of the files and folders associated with it.

You can create any number of different Projects which can all be maintained and developed in parallel. Both the Engine (and Editor) can easily switch between them, which will allow you to work on multiple games at once or have several test projects in addition to your main game Project open at any time.

Objects

The basic building blocks of the Unreal Engine are Objects of various kinds. The base that most elements in the engine gets functionality from or more correctly “inherits” from is the Object class, UObject.

From C++, UObject is the base class of all other Unreal Engine Objects and contains essential functionality for other objects you create, such as garbage collection and property support (through UProperty).

Actors

An actor is any object that you can add to your map (aka level). You could say that anything that can be “acted on” is an Actor. Actors support basic properties such as transformation (movement), rotation and scale in 3D space and actors can be made to spawn (get created) and destroyed by your gameplay code.

In C++ AActor is the base class for all actors. Actors can be static meshes, cameras, lights, particle emitters or skeletal meshes to name a few.

Actors will include “Components” that define their behavior and what they can do, like a light actor will include a component that defines what type of light it is, like a spot light will have a spot light component that defines how light is emitted and so on.

The actor will have access to and can use the functionality provided by the component.

Classes

Classes define the properties (state) and behavior of actors and objects in your game.
Classes in C++ defines a hierarchy where a given class can inherit from their parent classes and also pass information down to new child classes (sub class) that inherits from it.

I’ll have much more to say about classes when I start writing some actual code.
One thing worth mentioning is that you can also use Blueprints to define Unreal classes using the editor.

Pawns

A Pawn is a sub-class of Actor that can act as a character in your level and can be controlled by a human player or as an NPC (Non Player Character) controlled by the game’s AI. (Artificial Intelligence).

A player controlled by a human player is said to be “possessed” and an NPC is said to be “unpossessed”.

Characters

A Character is a sub-class of a Pawn that’s intended to be used as a player character.

It includes collision properties (how it reacts to other objects in the environment) and input bindings for bipedal (two legs) movement among other things that can be controlled by the player.

PlayerControllers

The PlayerController Class is used to take player input and translate that into interactions in the game and every game has at least one PlayerController in it. A PlayerController often possesses a Pawn or Character as a representation of the player in a game.

There are also many other terms that I’ll cover as the need shows up, but this is the fundemental terminology you’ll need to understand to follow tutorials on beginning game development in Unreal Engine 4.

What’s up next?

The next post will cover some more details on how to write C++ code in the “Unreal Style”, so that your code will blend easier with the existing code and the code that gets created by the Unreal Editor.

Unreal has their own coding standard that is slightly different from most mainstream coding standards used in C++ programming, so it deserves some attention.

Introduction to Game Development with Unreal 4 and C++ – Part 1

Welcome to the first post in the series I’ve called “Introduction to Game Development in Unreal 4”.

The posts will not be very long in the beginning, just bite-sized chunks of newly acquired wisdom.

You can start a new instance of the Unreal Engine through the Epic Launcher that gets installed when downloading UE from www.unrealengine.com.

First, off course you have to download and install the engine itself. This should be self-explanatory.

So, when you first fire up the Unreal 4 Engine, you’re presented with various options for creating a project from different templates. You can choose a “Blueprint” project or a C++ project, and you can enable or disable the option of including the “Starter Content”.

The choice of project type is not too important, as you’re free to create “Blueprints” in a C++ projects and vice versa. Content can also be imported into your project after its initial creation, so don’t worry too much about choosing the “correct” option early on.

First off, let’s spend some time (this first post) on describing a little bit about the difference between a Blueprint and a C++ project. What is a Blueprint?

The answer to this will depend on who you ask, and how competent this person is with Unreal Engine.

First of all, Blueprints are not necessarily a “beginners” way of creating a game in UE.

Basically one can say that Blueprints is a way to visually develop game logic using nodes and to configure the connections between these nodes with wires.

That’s not an overly technical definition, but I think you get the point.

blue_0

While it is easier to understand Blueprints initially, and most newcomers will indeed prefer to create their games this way, I’d say that if you try to create a fairly complex game using only Blueprints, you’re in for some serious headache. It WILL get complex and unwieldy pretty fast.

Rather, the way I see the most potential in Blueprints is in the prototyping stage of a level and for trying out different options in a game to present to a client or a friend, then, when you’ve settled on a prototype, you’ll start coding it in C++. This is a much more viable path to follow when creating a computer game.

It will be far easier to edit a class in an editor, than to drag wires along a path of hundreds or thousands of nodes in a Blueprint.

Here’s an example starting to get slightly out of control:

blue

This certainly doesn’t look like my idea of something simple to work with.

But for basic prototyping, Blueprints are a great tool to enhance productivity and development speed, especially in the early phases.

Blueprints can certainly be used for many purposes, but in essence it works best as a tool to extend a core C++ system. As mentioned, C++ can be used to call into a Blueprint and a Blueprint can call C++ code, so the synergy of the two is most often the ideal.

It exists similar tools as add-on’s to the Unity Engine as well, all though probably not as streamlined as the integrated Blueprints in Unreal.

Blueprints should be one of the areas you plan on learning when using Unreal 4, because many people are using them and it is important to be able to understand the concepts if you want to be able to transfer the logic behind a Blueprint graph into C++ code and to be able to send messages between the two.

Whether you choose to focus on learning Blueprints first or the C++ API’s first is a matter of preference.
You don’t have to know Blueprints to program a game in Unreal with C++.

I don’t think I’ll talk very much about Blueprints in this series, but instead focus on the basic interaction between the engine and the development environment, which in my case is Visual Studio 2015 at the time of this writing.

You can certainly use Unreal 4 on both Linux and Mac OSX as well and I’ve tried both.

In both cases you can choose to use the Qt Creator IDE, which is also available to use on Windows.

Qt Creator is a multi-platform, very nice IDE that’s a good alternative to Visual Studio, and can be used to create a wealth of different types of applications including GUI applications that runs on all supported platforms unchanged.

For some tips on using Qt Creator on Windows:

https://wiki.unrealengine.com/Using_QtCreator_With_UnrealEngine4

For more information on setting up the engine to work with Qt Creator on Mac OSX and Linux, refer to the Unreal Documentation and do some Google searching!

If you’re just starting out and have access to a computer running Windows, you’d probably want to use this setup, as it is the most widely tested configuration to run Unreal Engine 4 in and generally will give you the least problems early on.

This is a moving target though, and many people have started using Unreal 4 on both Linux and Mac machines, so expect this to be a truth with room for modification.

To keep this as simple as possible, I’ll use only Windows and Unreal 4 in this series, but may create some posts using Linux as well, because this is my favorite operating system in many ways.

I guess that’s all for this time!

I’ll be back.

Unreal Engine 4 vs Unity 5

Oh, great. Another post about Unreal vs. Unity…

This is not a Unreal vs Unity, “what is best” type of comparison, just my thoughts on why I decided to go all in with Unreal 4 instead of settling for the arguably more popular (and more forgiving) Unity 5 game engine for learning game programming.

First of all, let me point out that there is no clear cut way of saying that one option is “better” than the other, it all depends on your needs, prior knowledge and how much time you have available for learning new stuff.

My focus with this series of blog posts is to cover beginning game development using C++, so with that criteria, the choice between the two is self explanatory.

But if Unity is so popular and easy to use, why choose something more complex if all you want is to create some fun games? And if C# is so much more forgiving and easier for most people to understand, why use C++ in all its complex glory?

Good questions. The answer is not obvious, but for me, being able to access the game engine’s source code is of great value. I’m not a fan of obscurity, and if something is not doing what I want it to do, I want to be able to know why it is behaving as it does and to have the ability to change it. This is something you can’t do with a closed source engine like Unity, at least not at the time of this writing.

C# is a very productive language to code in, and it is easier to learn than C++, no doubt about that.
But C++ is the “lingua de franca” or common standard programming language in many areas of computing including games, also it is a platform neutral programming language.
C++ is also the common base that other languages such as Java and C# is influenced from, making it a very useful language to know in the world of programming.

Arguably, C++ also tends to produce faster executable code than other higher level languages, and when your programs get more complex, it is vital to be able to churn out all the juice your processors has to offer. Learning to code in C++ gives you the ability to do just that. It has a good mixture of low-level and high-level features making it ideal for something like games.

So, all though Unity and C# may be a better match for newcomers to programming, I do believe that investing the time to learn C++ and Unreal gives a better value in the long term.

Also, there are some annoyances associated with using Unity if you don’t pay for the Pro version, like not having the ability to customize the start screen you get when starting your games. It will say “Made with Unity Personal Edition” or something like that, and that doesn’t exactly portray a professional game as I see it. It is also a constant reminder of your limited freedom and the fact that there is better options available.

madewithunity

This may or may not be an issue if what you are developing is an indie game anyway, but I like to be in control and Unreal gives the developer more control.
There is no “Pro” version of Unreal, just the source code that is shared by all users of the engine, and that’s kind of how I like it to be.

The reason I chose to create these posts is because I’m now in a position in life where I have some time on my hands, and I’ve chosen to use this time to learn more about game development.

I already know a fair amount of programming, both using C# and C++ from previous jobs I’ve had and from my personal interests through the years which has involved programming in some form or the other.

For people new to both programming and game development, there is a great deal to learn and I will not be able to cover anywhere near what you need to learn as this would amount to around a three year full-time study at some university for being able to produce professional quality games.

But, I do hope that the posts about C++ and Unreal will give some insight into how this works and possibly making it easier for someone to grasp the overall picture of how creating games in this environment can work out.

unreal-logo-small

More to come…

Using Cygwin and making it behave more like a Package Manager

Using the possibilities of the next to nothing alternative

Sometimes you’re stuck at a Windows box, and you long for all those trusty, handy Unix/Linux tools.
Then it is good to know that you can install Cygwin, as I’m sure most developers have heard of.

Simply put, it is a “near POSIX” standard “Unix like” environment for MS Windows® that let’s you install your Korn shell or ZSH for that matter, and pretend you’re using a decent computer operating system.

And, quoting the site:

  • a DLL (cygwin1.dll) which provides substantial POSIX API functionality.

Anyway. I haven’t been using it much, so this “tip” might turn up to be old news for many, but there will always be new beginners, right?

The point of this tip is to inform you that the file you download from Cygwin’s web site actually takes command-line arguments worth knowing about.

According to their site they claim that each time you want to add or remove program packages to the Cygwin installation, you need to download the install file anew and make the desired changes to your installation.

This is something that has annoyed me, after being used to installing pre-built software with a decent Package Manager like dpkg and it’s front-ends or RPM tools.

A Google Search away (“Duck Duck Go search”, Actually), I found a list of handy cmd-line options to use with the downloaded .exe setup file.

One thing should be mentioned though: The installer, as any other piece of software tends to change over time.
I suspect this is why Cygwin thinks it is best to always use the latest version of their installer, and being a software developer myself I do agree.

So, the first time you install Cygwin using the installer (this is the 64-bit version) make sure to install the “curl” and the “wget” tools. Then you can easily make a .bat file to download the latest version to the directory of choice before running it with the command line parameters described.

Here is a descriptive list over command line arguments to the .exe installer.
If you’re on a machine with no administration rights, you could use the –no-admin switch as an example.

Command Line Options:
 -D --download                     Download from internet
 -L --local-install                Install from local directory
 -s --site                         Download site
 -O --only-site                    Ignore all sites except for -s
 -R --root                         Root installation directory
 -x --remove-packages              Specify packages to uninstall
 -c --remove-categories            Specify categories to uninstall
 -P --packages                     Specify packages to install
 -C --categories                   Specify entire categories to install
 -p --proxy                        HTTP/FTP proxy (host:port)
 -a --arch                         architecture to install (x86_64 or x86)
 -q --quiet-mode                   Unattended setup mode
 -M --package-manager              Semi-attended chooser-only mode
 -B --no-admin                     Do not check for and enforce running as
                                   Administrator
 -h --help                         print help
 -l --local-package-dir            Local package directory
 -r --no-replaceonreboot           Disable replacing in-use files on next
                                   reboot.
 -X --no-verify                    Don't verify setup.ini signatures
 -n --no-shortcuts                 Disable creation of desktop and start menu
                                   shortcuts
 -N --no-startmenu                 Disable creation of start menu shortcut
 -d --no-desktop                   Disable creation of desktop shortcut
 -K --pubkey                       URL of extra public key file (gpg format)
 -S --sexpr-pubkey                 Extra public key in s-expr format
 -u --untrusted-keys               Use untrusted keys from last-extrakeys
 -U --keep-untrusted-keys          Use untrusted keys and retain all
 -g --upgrade-also                 also upgrade installed packages
 -o --delete-orphans               remove orphaned packages
 -A --disable-buggy-antivirus      Disable known or suspected buggy anti virus
                                   software packages during execution.

Use Cygwins abilities as a Package Manager with Cygcheck

In fact, the cygcheck.exe program accompanying every installation makes Cygwin behave more like systems such as dpkg (apt-get) or RPM (Yum / Zypper)

Some common tasks using cygcheck:

The -c option checks the version and status of installed Cygwin packages. If you specify one or more package names, cygcheck will limit its output to those packages, or with no 
arguments it lists all packages.

$ cygcheck -c
Cygwin Package Information
Package             Version         Status

alternatives        1.3.30c-10      OK
autoconf            13-1            OK
autoconf2.1         2.13-12         OK
autoconf2.5         2.69-2          OK
...

If you list one or more programs on the command line with -s, cygcheck will diagnose the 
runtime environment of that program or programs, providing the names of DLL files of which 
the program depends.

$ cygcheck -s vim
Found: D:\cygwin64\bin\vim.exe
Found: D:\cygwin64\bin\vim.exe
D:\cygwin64\bin\vim.exe
D:\cygwin64\bin\cygwin1.dll
C:\Windows\system32\KERNEL32.dll
C:\Windows\system32\api-ms-win-core-rtlsupport-l1-2-0.dll
C:\Windows\system32\ntdll.dll
C:\Windows\system32\KERNELBASE.dll
C:\Windows\system32\api-ms-win-core-apiquery-l1-1-0.dll
C:\Windows\system32\api-ms-win-core-processthreads-l1-1-2.dll
...

Searching all packages for a specific file:

$ cygcheck -p 'cygintl-2\.dll'

Found 1 matches for 'cygintl-2\.dll'.
libintl2-0.12.1-3 GNU Internationalization runtime library

$ cygcheck -p 'libexpat.*\.a'
Found 2 matches for 'libexpat.*\.a'.
expat-1.95.7-1 XML parser library written in C
expat-1.95.8-1 XML parser library written in C.

Here is a more complete list of alternatives:

At least one command option or a PROGRAM is required, as shown above.
-c, --check-setup show installed version of PACKAGE and verify integrity 
(or for all installed packages if none specified)
-d, --dump-only just list packages, do not verify (with -c)
-s, --sysinfo produce diagnostic system information (implies -c -d)
-r, --registry also scan registry for Cygwin settings (with -s)
-k, --keycheck perform a keyboard check session (must be run from a
 plain console only, not from a pty/rxvt/xterm)
-f, --find-package find the package to which FILE belongs
-l, --list-package list contents of PACKAGE (or all packages if none given)
-p, --package-query search for REGEXP in the entire cygwin.com package

Repository (requires internet connectivity)

Search for software:
Note: -c, -f, and -l only report on packages that are currently installed. To search all 
official Cygwin packages use -p instead. The -p REGEXP matches package names, descriptions, and names of files/paths within all packages.
--delete-orphaned-installation-keys

Delete installation keys of old, now unused
installations from the registry. Requires the right to change the registry.
--enable-unique-object-names Cygwin-DLL
--disable-unique-object-names Cygwin-DLL
--show-unique-object-names Cygwin-DLL

Enable, disable, or show the setting of the
\"unique object names\" setting in the Cygwin DLL
given as argument to this option. The DLL path must
be given as valid Windows(!) path.
See the users guide for more information.
If you don't know what this means, don't change it.

-v, --verbose produce more verbose output
-h, --help annotate output with explanatory comments when given
with another command, otherwise print this help
-V, --version print the version of cygcheck and exit
-c, --check-setup show installed version of PACKAGE and verify integrity 
(or for all installed packages if none specified)
-d, --dump-only just list packages, do not verify (with -c)
-s, --sysinfo produce diagnostic system information (implies -c -d)
-r, --registry also scan registry for Cygwin settings (with -s)
-k, --keycheck perform a keyboard check session (must be run from a
 plain console only, not from a pty/rxvt/xterm)
-f, --find-package find the package to which FILE belongs
-l, --list-package list contents of PACKAGE (or all packages if none given)
-p, --package-query search for REGEXP in the entire cygwin.com package

Repository (requires internet connectivity)

Search for software:
Note: -c, -f, and -l only report on packages that are currently installed. To search all 
official Cygwin packages use -p instead. The -p REGEXP matches package names, descriptions, and names of files/paths within all packages.

--delete-orphaned-installation-keys

Delete installation keys of old, now unused
installations from the registry. Requires the right to change the registry.
--enable-unique-object-names Cygwin-DLL
--disable-unique-object-names Cygwin-DLL
--show-unique-object-names Cygwin-DLL

Enable, disable, or show the setting of the
\"unique object names\" setting in the Cygwin DLL
given as argument to this option. The DLL path must
be given as valid Windows(!) path.
See the users guide for more information.
If you don't know what this means, don't change it.

-v, --verbose produce more verbose output
-h, --help annotate output with explanatory comments when given
with another command, otherwise print this help
-V, --version print the version of cygcheck and exit
-c, --check-setup show installed version of PACKAGE and verify integrity 
(or for all installed packages if none specified)
-d, --dump-only just list packages, do not verify (with -c)
-s, --sysinfo produce diagnostic system information (implies -c -d)
-r, --registry also scan registry for Cygwin settings (with -s)
-k, --keycheck perform a keyboard check session (must be run from a
 plain console only, not from a pty/rxvt/xterm)
-f, --find-package find the package to which FILE belongs
-l, --list-package list contents of PACKAGE (or all packages if none given)
-p, --package-query search for REGEXP in the entire cygwin.com package

Repository (requires internet connectivity)

Search for software:
Note: -c, -f, and -l only report on packages that are currently installed. To search all 
official Cygwin packages use -p instead. The -p REGEXP matches package names, descriptions, 
and names of files/paths within all packages.

--delete-orphaned-installation-keys

Delete installation keys of old, now unused
installations from the registry. 
Requires the right to change the registry.

--enable-unique-object-names Cygwin-DLL
--disable-unique-object-names Cygwin-DLL
--show-unique-object-names Cygwin-DLL

Enable, disable, or show the setting of the
\"unique object names\" setting in the Cygwin DLL
given as argument to this option. The DLL path must
be given as valid Windows(!) path.
See the users guide for more information.
If you don't know what this means, don't change it.

-v, --verbose produce more verbose output
-h, --help annotate output with explanatory comments when given
with another command, otherwise print this help
-V, --version print the version of cygcheck and exit

For those of you that want more in-depth information on using Cygwin for programming or just as a way to use Windows more like a decent OS, here is a direct link to the Cygwin PDF User Guide.

Until next time, happy Cygwin hacking…

Chris

I’m going away for 4-6 months, but please stay subscribed because…

New stuff is coming up!

Keywords: Game Development, Python, C, C++ and (hold your breath) Lisp!

New ways of thinking about the good old OOP, including functional development in Haskell and Test Driven Development and re-factoring legacy code in C++.

More 3D stuff, like Allegorithmic Substances and Modo 701.

The Blender Game Engine (programmed via Python) gets a thorough examination.

A taste of my upcoming book, called “Becoming a Real Life Developer” vol. 1 “The Stuff you Need-to-Know”.
This is a planned three-volume book series covering multiple programming languages, paradigms and languages plus how life unfolds in the real world of software development with version control systems, code reviews, the art of problem-solving and thinking “outside the box”.
It will also be geared towards team building and how to fit in to an established team of developers.
The art of becoming a software developer is very much a psychological challenge with a constant need to stay on top of the latest technologies.
My goal is to make one realize that this business is not always a bed of roses, but an extremely satisfying way of making a living if you know the right way to walk forward and get promoted without pushing yourself off the edge…

Until next time:

The Mad Man (going on a spiritual ride)

Follow-Up: Reasons to NOT only learn .Net / C#

A modern developer should master at least 3 languages!

A while ago I was all exited about finally “getting it” in sense of the more advanced parts of C#, like Generics, Events, Delegates, and Lambdas. So I wrote a post about 18 reasons you should use C# / .Net / Mono.  it kinda sounded like I’d found a salvation in it or something.

Well, I did not. I was just “on a roll”!

I’m often on these rolls. This is what gets me ahead of the competition and it’s what get’s developers with master degrees in Computer Science and programming  asking ME for help while at work from time to time. That’s wicked cool, but it has its downsides.   logoLispSpillerGlossy

I seldom sleep more than 4 hours per night, because I just HAVE to finish up a stupid project so I can understand a concept in a programming language I probably never going to use, like Cobol or something. But who knows right?

This brings me to the main theme of this blog post:

I’ve been interested in programming for a long time. Long before I started to work as a developer, I snuck in some developer tasks when working as a network and security administrator, and when working as a server and system administrator.
I managed to convince my boss that I really needed this and that book  or course so we could do this and that so much better. It worked all the time.

My job back then was basically sitting in my office with a self-made monitoring system that alerted me if some fiber link was down or a router to a branch office went bananas, something that didn’t happen very frequently. So, my responsibility was to make sure the systems ran 24/7, and that was that.
I make it sound a bit easier than it was from time to time, but the point is that I had a lot of time to study programming!

I started learning the C Language from the ubiquitous K&R book that I still keep in sight for the kicks emacs6-256of it. This was the first standardized version of C, so it had some quirks to put it mildly, but when you understood it, nothing could beat it! At least not in terms of efficiency and performance… Time to market is a nother story.
I was doing a good deal of scripting as part of my job, for automating mass installations, upgrades log-on scripts and those things, but that was in VBScript! Can you believe it? VBScript! I hated it.

So I started to replace many of the scripts with Perl and Python using the Win32 libraries, something that was way cooler.

Then I got interested in cross-platform programming in Java, because I missed a real GUI from the stripped out Tk I managed to get out of Perl and Python, and it had to run on both Windows, Linux and FreeBSD servers. While I probably would get a compile-time error writing “Hello World” in Java today I thought it was fun while it lasted.

Then the real shit hit the fan. I decided to change jobs and work as a full-time developer. My responsibilities where diverse and involved working with Legacy Borland C++ code and some C# 2.0 written in C++ style. So I had to get really serious about learning C++ and C#. The first months I went to work, did what I could, then I wrote down everything I didn’t know how to do.
When I got home I thought it to myself through books, tutorials and Googling so I could fix it the next day.

This went on for almost a year, and I was totally up to my neck in deadlines and trouble.
It wasn’t really my vision of having a job doing what I liked most.
But somehow I managed to get by and new projects came along that demanded the same level of commitment.
That’s the price to pay for adding a bit extra on the resume…the-ruby-mine-logo

Today I feel a lot safer about my skills in the “major languages” C, C++ and C#, but I’ve realized that I’ve only been doing one kind of paradigm type programming and that is the Object Oriented type of programming.

So I’ve now started to learn two new languages (or three actually), namely Common Lisp, Erlang and TCL/Tk.
What I discover each day is that the new things I learn about the more functional approach to programming could have saved my ass plenty of times if I’d known some of the same techniques when working with the projects I barely got through earlier,
I could have done many things so much simpler and more elegantly.

So my advice to all aspiring or maybe even more to all the mounted old dogs that refuses to learn new tricks is to actually do just that. Learn at least one purely functional language, one strictly OOP and one that blends it all together, like C++ or Objective-C if that’s your cup of tea. Plus I’d invest in learning one strictly interpreted language like Python or Ruby, as it makes prototyping and easier tasks, well, so much easier!.

erlang

Put a NoSQL database like MongoDB on top of this and you have an incredible toolbox for handling almost any programming task thrown at you. Word.

PS! Don’t forget those that  work hard for free to bring us some fantastic tools to develop cool things with! 

Get a  Member Sponsorship at the Free Software Foundation Today! 

fsfButton     <– LINK!

These guys are Funding the GNU Project.

Until next time, The MadMan.

Using LINQ and EntityFramework, Measuring and analyzing the LINQ effectiveness

Some Entity Framework Components

When you use something like the extensive “Entity Framework” or any other ORM (Object Relational Mapping) tool, the process of writing sophisticated database driven applications becomes a lot easier.
It eliminates most of the data access code used to be required to create object-based data applications, and contains tools that makes it possible to create object-oriented data applications from an existing database, by using .edmx files that describes the CLR (Common Language Run-time) objects and these can be “extracted” from any existing relational database that the Entity Framework has a driver for.

This enables developers to program directly against data types defined at the conceptual level, presented as regular object instances.

But.
The responsibility to create clean queries and dispose the resources that’s being used, are just as important as it was in more “old fashioned” database connected applications that does all the SQL manually.

Many people assume that, as long as the application compiles and runs without complaining loudly, everything is probably done correctly, right?
This is .Net we’re talking about, so if something was wrong I would probably get a warning or something, right?

Sadly life is not that simple in this case.

The risk of introducing data-access “anti-patterns” in your code that may decrease the performance of your application and greatly slow down your organization’s database server is highly possible, and  actually quite likely to happen if you’re new to ORM and the Entity Framework in particular.

How Can You Measure the LINQ query’s Efficiency?

To reduce the chances of creating inefficient ORM based applications, we need some way to easily (or it won’t be used) analyze exactly what goes on in the EF brain when it executes our code.

This post focuses on a product called LINQ Insight by DevArt, that addresses this problem (and a lot of other LINQ related problems) and may be downloaded for free from the DevArt site:

Download LINQ Insight Standard

NB! The FULL functionality is free for 30 days, before it changes to the more restricted, but highly useful Free Edition.

Data access anti-patterns decreases performance greatly and must be avoided.

When you write applications using for example LINQ to Entities with the Entity Framework, what goes on behind the scenes is something like:

1) The Entity Framework “Mapped” Objects are created with a ObjectQuery() method, run against an existing ObjectContext instance.

The ObjectContext instance is a container for in-memory objects and metadata extracted from the relational database.
It manages the object identities and states, keeps a pointer to original and current values of the objects properties, and tracks changes made to each object in its cache store.

The ObjectContext provides the connection and metadata information that is required to compose and execute queries, and should therefore be set up in advance.

2) Entity Framework components like the ObjectQuery class are compiled behind the scenes, and generate “regular” SQL statements that does the “actual” query against the database.

The queried data is returned as entity objects, most often as anonymous class instances, and the application works with these objects instead of directly querying the SQL database.
This is an important point to understand.
Using LINQ in this way, to offload the database server is a fundamental aspect of ORM frameworks.

Constructing an ObjectQuery Instance

The ObjectQuery returns a collection of zero or more typed entities.  The ObjectQuery generic class implements the IQueryable generic interface, whose methods enable LINQ queries to be incrementally built. You can also let the compiler infer the type of entities by using the C# var keyword, which is something that simplifies specific query situations considerably.

Instances of the ObjectQuery generic class, which implements the generic IQueryable interface, serve as the data source for LINQ to Entities queries. In a query, you specify exactly the information that you want to retrieve from the data source. A query can also specify how that information should be sorted, grouped, and shaped before it is returned. In LINQ, a query is stored in a variable. This query variable takes no action and returns no data; it only stores the query information. After you create a query you must execute that query to retrieve any data.

// Call ctor with query for "persons" and the named ObjectContext
var personsQuery = new ObjectQuery("Persons", context);

3) You can get access to the entities via the reference and collection properties, and this in turn produces additional SQL queries to get the necessary data.

4) When your application finishes working out what entities are needed, the “mapping” process of EF is more or less done.

BUT: if there are any changes to the queried entities, the application will have to save them to database somehow.
It does this by transforming your LINQ, like SubmitChanges() to “regular” SQL statements, like SELECT, UPDATE etc.

All of this happens without you being able to “see” exactly what’s going on at a “lower” level. That’s kinda the idea, to abstract away the unnecessary details from the user, and let you think about designing the flow of the application, not the technicalities used to make things work.

Though all these actions are performed by Entity Framework run-time, and are transparent for the application that works with entities, they may be complex and affect application performance greatly. That’s why you probably need a good Entity Framework profiler to create efficient applications using Entity Framework for data access. Entity Framework profiler in LINQ Insight really profiles ORM events and allows you to see how much time LINQ statement or SubmitChanges call takes to execute as a whole even if it generated multiple SQL statements.

Example Application

Let’s show how to profile Entity Framework applications on a simple example. We have used the widely used NorthwindEF sample database for our example, and generated the model for it with EDM wizard using default settings. The application is a simple console application with the following code:

The Future Of Decent 3D Software for Enthusiasts and Professionals alike

Blender Image
Create what you want for free!

Ok. We all know and love Blender. But let’s face it, it has its quirks that needs some ironing out before it can totally     replace a package like Autodesk XSI or Autodesk Maya for many professional artists, or at least they think it does.

Don’t get me wrong here, it is definitely the tool of choice if you want an open source solution that can do “almost      anything”.

This is not to say that Blender has missing features, on the contrary, it has features that Maya tries to include, but has shipped with pretty serious bugs since around version 2009.
Now they have snatched a perfectly good plugin called NEX and “integrated” a.k.a. “slammed” it on top of their existing buggy tools, creating somewhat of a monster. Again. Those guys really never seem to learn the basics of Software Lifecycle Management. I’ve tried using it, but it’s so buggy that it ruins my models from time to time.

The 2014 Edition is already in SP3 and still bugs aren’t sorted. This is a frustration for many small studios that depends on stable software and don’t have the resources to create their own in-house work-around using the SDK. But what do they do? Soon they’ll release a new 2015 version with even more features and new bugs on top of that.

Then we have Modo. Once my favorite polygonal modeler, back in the version 3 days. Now the whole company has been snatched by The Foundry, and all clues given leads in the direction of massive feature and price increases. So, no more Modo for me I guess. I have my stable commercial license for Modo 401 that never stops to be valid, but hey, things evolve right? Who knows if it will be compatible with the next operating system I’m forced to update to because of other applications demands?

It still amazes me to see a company like Newtek still being alive and actually even kicking these days with the new Chronosculpt and Nevronmotion applications that lets you sculpt in time based layers and record motion data via a cheap $99 Kinect Sensor! Way to go!
How much this will be used remains to be seen, but they are on a creative roll and they NEVER give up. That is the true spirit of life. In addition they’ve released a free update to existing v. 11 (maybe also v. 10?) customers in form of Lightwave 11.6.
This edition is the most groundbreaking release since version 9.6 in my eyes. It actually is a NEW LIGHTWAVE.
A lot of new cool modeling tools and a great deal of new features on the rigging and animation side with the introduction of the Genoma system and off course an updated integration of the Bullet Physics engine, so sorely needed.
To bad I only have an educational license for version 9.6. But they do have a good offer these days, letting me upgrade to 11.6 for around $350 or something.
But, it’s Christmas and I have other posts on my budget screaming for coverage…

When it comes to a simple, fast and stable polygonal modeler we have the option of using Silo. It’s a $159 application and is an extremely competent modeler application.
But it hasn’t been actively developed for over two years.
So the reason for starting this article was really to investigate the possibility to crowd-fund a purchase of the Silo source code from Nevercenter and turn it into an actively maintained Open Source project. Personally, I have an hour or two now and then for coding some C++, Python or whatever they’ve used to create the product.

The question is: How many others are in on a project like this?

I’ve posted a poll over at CG SOCIETY (CGTalk) and for those that would be so kind, I urge you to give your vote to one of the options presented there.

I’ve been lousy at posting new stuff to my blog lately and probably have lost a lot of readers, but hopefully some remain truthful to the old madman.

Here is the link to the post on CGC:

Poll for Open Sourcing Silo 

For those that does not have a CGC account, get one! Kidding.

I’ll present the poll in this post as well, though it won’t be linked with the results on CGC, so the best is if you take the time to register over there. They even have a $19 / Year deal for a premium subscription right now (normally $79) with a lot of goodies.

All the best,

The MadMan