To start off, let’s go over some basics. A scene graph is a tree-like data structure which holds information about the scene you want to display. Every node has a parent and every node may have children. In this post we’ll use the std::vector to store the scene nodes but you can substitute this with whatever you want. A scene graph can be visualized like so:

             [root node]
                  |
        o=========o=========o
        |         |         |
    [child 1] [child 2] [child 3]
        |
    o===o====o
    |        |
[child 4][child 5]
             |
         [child 6]

Any node may have any number of children who’s children may have any number of children, etc. Each node in the scene graph may have a name for lookup functionality so a very lookup system will be implemented. We will also need functionality to add a child node, remove a child node, set/get a node’s parent and an update function for updating the graph hierarchically.

Beware that this scene graph is for educational purposes only, I do not recommend that you implement this scene graph into your engine as it uses very simple algorithms and general-purpose classes from the C++ Standard Template Library. Also, keep in mind that a scene graph is not used for rendering your objects, it is used to keep hierarchical information and for applying hierarchical transformations.

Rendering your objects is done through a different type of structure such as a Binary Space Partitioning Tree (BSP-Tree) or an Octree which are structures more suitable for visibility testing and quite a bit faster. Your scene graph is updated each cycle of your simulation or game so that all the objects in your scene have their correct transformations.

Let’s start off with declaring our base class, the Node (below is the entire Node.h file):

#ifndef __node_h_
#define __node_h_ 1
#include <vector>

class Node
{
public:
	Node(Node* Parent = NULL, const char* Name = NULL);
	virtual ~Node(void);

	virtual void Update(void);

	Node* GetParentNode(void) const;
	void SetParentNode(Node* NewParent);

	void AddChildNode(Node* ChildNode);
	void RemoveChildNode(Node* ChildNode);

	const char* GetNodeName(void) const;
	const size_t CountChildNodes(const bool& RecursiveCount = false) const;
	virtual const bool IsRootNode(void) const = 0;

	Node* GetChildNodeByName(const char* SearchName);

private:
	Node* m_Parent;
	const char* m_Name;
	std::vector<Node*> m_Children;

}; // class Node

#endif

There are not many methods in this class so you have room for expansion if you feel like it. Beware that this class can only be used as a base class and cannot be initialized as new Node(). Let’s continue by examining the individual methods of this class:

Node::Node(Node* Parent, const char* Name)

Node::Node(Node* Parent, const char* Name)
	: m_Name(Name)
{
	m_Parent = Parent;
} // Constructor

As you can see I’ve kept the constructor very simple. The default for both parameters is NULL as both are optional. A node does not necessarily need a parent and a node does not require a name. You can of course change this by removing the = NULL sections out of the header file and throwing and exception if NULL was found in the source file.

Node::~Node(void)

Node::~Node(void)
{
	m_Parent = NULL;
	m_Children.clear();
} // Destructor

The class destructor is also very simple, it simply sets the pointer to the parent node to NULL and clears the children-vector.

void Node::Update(void)

void Node::Update(void)
{
	if(!m_Children.empty())
	{
		for(size_t i = 0; i < m_Children.size(); ++i)
		{
			if(NULL != m_Children[i])
			{
				m_Children[i]->Update();
			}
		}
	}
} // Update()

Still pretty simple, this method goes through the children-vector and calls the Update method on each child that does not equal NULL. The child object in return calls the Update method so the behavior is recursive.

This method was designed to be overriden and called as Node::Update() by the overriding method.

Node* Node::GetParentNode(void) const

Node* Node::GetParentNode(void) const
{
	return(m_Parent);
}; // GetParentNode()

A “property” which simply returns a pointer to the parent node.

void Node::SetParentNode(Node* NewParent)

void Node::SetParentNode(Node* NewParent)
{
	if(NULL != m_Parent)
	{
		m_Parent->RemoveChildNode(this);
	}
	m_Parent = NewParent;
}; // SetParentNode()

This method sets a new parent node for the selected node and removes the node from the old parent node’s children-vector.

void Node::AddChildNode(Node* ChildNode)

void Node::AddChildNode(Node* ChildNode)
{
	if(NULL != ChildNode)
	{
		if(NULL != ChildNode->GetParentNode())
		{
			ChildNode-<SetParentNode(this);
		}
		m_Children.push_back(ChildNode);
	}
}; // AddChildNode()

Adds the node to the children-vector and updates the parent to the new parent if a parent was set.

void Node::RemoveChildNode(Node* ChildNode)

void Node::RemoveChildNode(Node* ChildNode)
{
	if(NULL != ChildNode && !m_Children.empty())
	{
		for(size_t i = 0; i < m_Children.size(); ++i)
		{
			if(m_Children[i] == ChildNode)
			{
				m_Children.erase(m_Children.begin() + i);
				break; // break the for loop
			}
		}
	}
}; // RemoveChildNode()

This method loops through all of the child nodes and will remove the selected child node from the children-vector if found.

const char* Node::GetNodeName(void) const

const char* Node::GetNodeName(void) const
{
	return(m_Name);
}; // GetNodeName()

A “property” which returns the name of the current node.

const size_t Node::CountChildNodes(const bool &RecursiveCount) const

const size_t Node::CountChildNodes(const bool &RecursiveCount) const
{
	if(!RecursiveCount)
	{
		return(m_Children.size());
	}
	else
	{
		size_t Retval = m_Children.size();
		for(size_t i = 0; i < m_Children.size(); ++i)
		{
			Retval += m_Children[i]->CountChildNodes(true);
		}
		return(Retval);
	}
}; // CountChildNodes()

Method counts all of the child nodes, recursive if required. If the recursive Boolean is set to true, the function will iterate over the entire hierarchy from the current node down and return a full node-count.

Node* Node::GetChildNodeByName(const char *SearchName)

Node* Node::GetChildNodeByName(const char *SearchName)
{
	Node* Retval = NULL;
	if(!m_Children.empty())
	{
		for(size_t i = 0; i < m_Children.size(); ++i)
		{
			if(0 == strcmp(m_Children[i]->m_Name, SearchName))
			{
				Retval = m_Children[i];
				break; // break the for loop
			}
		}
	}
	return(Retval);
}; // GetChildNodeByName()

This method will return a node referenced by name if it exists, otherwise it will return NULL. The function is fairly expensive and should be replaced with something more efficient but is fine for small trees and demos.

Conclusion:
As you can see, the scene graph is quite simple but once you understand how to implement one customization isn’t hard. Things you might want to change are passing a time value to the Update() method of Node so that your nodes may have a notion of time passed between calls, something faster than std::vector for storage and implementing a type-checking mechanism.

Regardless of the above, if you’re slapping together a quick demo that’s not performance sensitive the code with tweaks should do fine. Let me know if I missed or something or screwed something up since this post has been sitting in limbo for quite a while.

For example, Little-Endian machine A has an integer that it needs to write to disk: 12345. Big-Endian machine B has the same integer that it needs to write to disk as well.

The hexadecimal representation of the file on machine A would look like: 00 00 30 39 while machine B’s output would look like: 39 30 00 00.

If we were to read machine A’s file on machine B, the output would not be 12345 as expected but 245618442240 instead. Now that’s quite a problem. Any file written on machine A would be useless in any other environment.

In the meantime, be aware that there’s no way to determine if a file is Big or Little Endian so you would need to set a standard for your file. I use Little-Endian byte ordering since that’s my machine’s native format and 99% of the time, yours as the x86 family of processors is Little-Endian.

So in order to read any of the files we have on disk, regardless of endianness, we first need to detect the endianness of our current machine and somehow detect the endianness of the file we’re trying to read. This is not a big pain in the ass as you might suspect since machines, in addition to files, also order their memory in Big- or Little-Endian byte ordering.

C++ Code:

const bool IsLittleEndian(void)
{
	static const signed int Bytes = 58;
	static const bool Test = (*(&Bytes) != 58);
	return(Test);
}

A little explanation to the code above: the first line in the function sets the value of the integer to 58 (the integer is static, so this will only be declared once) so that the value in hexadecimal becomes: 3A 00 00 00.
An integer is four bytes long so on a Little-Endian machine, the first byte should be our number, 58, which is smaller than the maximum size of one byte, 255, meaning that the number will not overflow to the next byte.
The next line retrieves the address of the integer and compares the first byte of the integer at index zero with the number 58. If the machine is Big-Endian, the function will return false and true for Little-Endian.

Now that we have this out of the way, you can save your file in the endianness that you want so you retain portability. From this point on, I’m going to assume you have a Little-Endian system.

The next obstacle I faced in trying to convert an array of bytes into an integer was the actual conversion. Consider again our previous example of integer 12345 in Little-Endian: 39 30 00 00. If we were to read this sequence of bytes into an integer from left to right, the number would be wrong again. Because of this we need to read the bytes one-by-one and insert them into the desired integer.

C++ Code:

const size_t IntSize = sizeof(int);

const int DecodeInt(const char ByteArray[])
{
	int RetVal = 0;

	for(int i = int(IntSize - 1); i > -1; ––i)
	{
		RetVal |= int(ByteArray[i] & 0xFF);
		if(0 != i)
		{
			RetVal <<= 8;
		}
	}

	return(RetVal);
}

Alright, that’s a bit of code there, let’s go over it line by line.

const size_t IntSize = sizeof(int);
The first line is simply a constant I’ve added to improve readability a bit, it equals the size of an integer in bytes (4).

int RetVal = 0;
The return value is a signed integer initialized to zero (so we don’t have numerical surprises).

const int DecodeInt(const char ByteArray[])
The actual function takes a byte-array as parameter but will only process 4 bytes of information from it.

for(int i = int(IntSize - 1); i > -1; ––i)
As you might have noticed, the loop inside the function loops backwards, this is to convert from the format on disk to the format of a regular integer.The loop stops when the index -1 has been reached because we also want to process index 0.

RetVal |= int(ByteArray[i] & 0xFF);
This line is part one of the bread and butter of this function. The line logically OR-s the clamped (max 255, or 0xFF) byte value to the integer. This basically would result in something like:

10011101 (0x9D, some value from a byte-array)
11111111 (0xFF, the 255 mask for clamping)
-------- AND
10011101 (0x9D, result is the same as 0x9D < 255)

10011101 (0x9D, the result of the AND operation)
00000000 (0x00, the integer RetVal's value at this point)
-------- OR
10011101 (0x9D, the result is the same, no clamping was necessary)

If you're sure that the values you're using are between 0 and 255, you don't have to clamp to 255 but it's in there regardless. This is specifically handy for freak negative values that might pop up when reading from files and unsigned to signed casting.

if(0 != i){ RetVal <<= 8; }
Translates to: if the current index is not the last (0), shift the value of RetVal 8 (amount of bits in a byte) positions to the left. This assures that the value that were assigned are in the correct position, the last iteration is not shifted since it will be inserted at the correct place.

Sample iteration for value: 3258794

{ 0xAA 0xB9 0x31 0x00 } = Byte Array for value 3258794

0000 0000 0000 0000 0000 0000 0000 0000 RetVal = 0x00
0000 0000 0000 0000 0000 0000 0000 0000 After OR-ing 0x00
0000 0000 0000 0000 0000 0000 0000 0000 After Left Shift of 8
0000 0000 0000 0000 0000 0000 0011 0001 After OR-ing 0x31
0000 0000 0000 0000 0011 0001 0000 0000 After Left Shift of 8
0000 0000 0000 0000 0011 0001 1011 1001 After OR-ing 0xB9
0000 0000 0011 0001 1011 1001 0000 0000 After Left Shift of 8
0000 0000 0011 0001 1011 1001 1010 1010 After OR-ing 0xAA

Result: 1100011011100110101010, or the decimal value of 3258794

Good luck

const size_t intlen(long long int Num)
{
	size_t out = 1;
	while (Num /= 10) ++out;
	return out;
}; // numlen

Looks simple enough; simply count the amount of times we can divide the number by 10 without the result being zero. This function takes a copy of an int (or long long) so that we don’t have to copy the number inside the body of the function and returns a size_t (unsigned int).

As for the usage example, it’s a bit more complex and might seem a bit “obfuscated” at first, but fear not, I will explain below.

void inttoa(long long int Num, char** RetVal)
{
	size_t neg = (Num < 0);
	size_t len = intlen(Num) + (neg ? 1 : 0); // add one for the "-" character
	size_t i;

	*RetVal = (char *) malloc(sizeof(char) * (len + 1));

	if (NULL == (*RetVal))
		return; // bad malloc

	if (neg)
		Num = -Num; // make pos if neg

	for (i = len; i; (Num /= 10), --i) // loop backwards
		(*RetVal)[i-1] = (char)((Num % 10) + '0'); // add modulo to char zero

	if (neg)
		(*RetVal)[0] = '-'; // first char

	(*RetVal)[len] = 0; // last char, null terminator
}; // intttoa

As you might have suspected, this function converts an integer to character string. First, we determine if the number is negative and retrieve its length with the help of the previous function. We allocate a character string with the length determined and start appending a character to the string.

You can use it like so:

char* mystring; // don't allocate, don't do anything
inttoa(42, &mystring); // simply pass it to the function

// do things with the string

free(mystring); // you *do* have to free() the string though

In an effort to produce a better performing multidimensional array, I would like to share the following with you. Say we have a Matrix (or multidimensional array) of 5 x 5 integer elements, M. In order to allocate such an array in C++, we use the following code:

const size_t Width = 5;
const size_t Height = 5;
int** Array = new int*[Height]; // 2-Dimensional

for (size_t i = 0; i < Height; ++i)
	Array[i] = new int[Width];

// etcetera.

for (size_t i = 0; i < Height; ++i)
	delete[] Array[i];
delete[] Array;

In order to counter-act this looping behavior, which, in many cases will slow down the program upon allocation and freeing of memory (due to the loops), the array may be flattened like so:

const size_t Width = 5;
const size_t Height = 5;
int* Array = new int[Width*Height]; // 1-Dimensional

// etcetera.

delete [] Array;

Thus causing fewer allocations than before, and eliminating loops entirely. You might think that the array is entirely out of order, and no logical index can be obtained for selecting e.g.: Array[2][3];. This is where a simple calculation comes in handy.

AX,Y = (Y x Width) + X

With this calculation we can select our element by doing the following:

[...]
// desired position:
const size_t X = 2;
const size_t Y = 3;
[...]
int RequestedInteger = Array[(Y*Width)+X];

This works because if we visualize our flattened array's indexes in a table (right →), we can see that if we take Y (3) and multiply it by the Width (5) we get the appropriate first index of the row (15, or 0,3). If we add X (2) we have selected index 17, which is the index we want (X₂, Y₃).

This implementation is faster because we only allocate one single block of memory of X*Y instead of X*Y blocks of memory. The disadvantage of this is that to select any index from the array, you will have to calculate the expression, but this is a minor operation compared to the allocation/de-allocation loops.

#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#include <pthread.h>
#endif

/**
 * @class A wrapper-class around Critical Section functionality, WIN32 & PTHREADS.
 */
class CriticalSection
{
public:
	/**
	 * @brief CriticalSection class constructor.
	 */
	explicit CriticalSection(void)
	{
	#ifdef _WIN32
		if (0 == InitializeCriticalSectionAndSpinCount(&this->m_cSection, 0))
			throw("Could not create a CriticalSection");
	#else
		if (pthread_mutex_init(&this->m_cSection, NULL) != 0)
			throw("Could not create a CriticalSection");
	#endif
	}; // CriticalSection()

	/**
	 * @brief CriticalSection class destructor
	 */
	~CriticalSection(void)
	{
		this->WaitForFinish(); // acquire ownership
	#ifdef _WIN32
		DeleteCriticalSection(&this->m_cSection);
	#else
		pthread_mutex_destroy(&this->m_cSection);
	#endif
	}; // ~CriticalSection()

	/**
	 * @fn void WaitForFinish(void)
	 * @brief Waits for the critical section to unlock.
	 * This function puts the waiting thread in a waiting
	 * state.
	 * @see TryEnter()
	 * @return void
	 */
	void WaitForFinish(void)
	{
		while(!this->TryEnter())
		{
		#ifdef _WIN32
			Sleep(1); // put waiting thread to sleep for 1ms
		#else
			usleep(1000); // put waiting thread to sleep for 1ms (1000us)
		#endif
		};
	}; // WaitForFinish()

	/**
	 * @fn void Enter(void)
	 * @brief Wait for unlock and enter the CriticalSection object.
	 * @see TryEnter()
	 * @return void
	 */
	void Enter(void)
	{
		this->WaitForFinish(); // acquire ownership
	#ifdef _WIN32
		EnterCriticalSection(&this->m_cSection);
	#else
		pthread_mutex_lock(&this->m_cSection);
	#endif
	}; // Enter()

	/**
	 * @fn void Leave(void)
	 * @brief Leaves the critical section object.
	 * This function will only work if the current thread
	 * holds the current lock on the CriticalSection object
	 * called by Enter()
	 * @see Enter()
	 * @return void
	 */
	void Leave(void)
	{
	#ifdef _WIN32
		LeaveCriticalSection(&this->m_cSection);
	#else
		pthread_mutex_unlock(&this->m_cSection);
	#endif
	}; // Leave()

	/**
	 * @fn bool TryEnter(void)
	 * @brief Attempt to enter the CriticalSection object
	 * @return bool(true) on success, bool(false) if otherwise
	 */
	bool TryEnter(void)
	{
		// Attempt to acquire ownership:
	#ifdef _WIN32
		return(TRUE == TryEnterCriticalSection(&this->m_cSection));
	#else
		return(0 == pthread_mutex_trylock(&this->m_cSection));
	#endif
	}; // TryEnter()

private:
#ifdef _WIN32
	CRITICAL_SECTION m_cSection; //!< internal system critical section object (windows)
#else
	pthread_mutex_t m_cSection; //!< internal system critical section object (*nix)
#endif
}; // class CriticalSection