 |
| Basic windows (taken from an OS X build)! |
 |
| Hard to find an original screenshot, but Blackbox kind of looked like this. |
 |
| Without MLAA: Lots of ugly, hard edges. |
 |
| With MLAA: Hard edges blended/blurred together. |
ENUM_CLASS(TestEnum, TE_A, TE_B = 2, TE_C, TE_D = 6);
void testEnum
{
ASSERT(TE_A == 0);
ASSERT(TE_B == 2);
ASSERT(TE_C == 3);
ASSERT(TE_D == 6);
ASSERT(MAX_TestEnum == 7);
TestEnum te;
ASSERT(te == TestEnum::max());
ASSERT(te == MAX_TestEnum);
te.setFromString("TE_A");
ASSERT(te == TE_A);
te.setFromString("TE_B");
ASSERT(te == TE_B);
ASSERT(TestEnum::getEnum("TE_C") == TE_C);
ASSERT(TestEnum::getString(TE_D) == "TE_D");
}
#define ENUM_CLASS(Name, ...) enum E##Name { __VA_ARGS__, MAX_##Name }; \
struct Get##Name##EnumString \
{ \
static const Char *get() \
{ \
return #__VA_ARGS__ ", MAX_" #Name; \
} \
}; \
typedef EnumT Name
void tokeniseEnumString(String *enumArray, Size enumArrayCapacity, const String &enumString);
template <class Enum, const Size MAX_ENUM, class GetEnumString>
class EnumT : public EnumBase
{
public:
static const String &getString(Size i)
{
ASSERT(i <= MAX_ENUM);
return enumNames()[i];
}
static Enum getEnum(const String &s)
{
for (Size i = 0; i < MAX_ENUM; ++i)
{
if (enumNames()[i] == s)
return static_cast(i);
}
return static_cast<Enum>(MAX_ENUM);
}
static Size max() { return MAX_ENUM; }
EnumT() : m_value(static_cast<Enum>(MAX_ENUM)) {}
EnumT(Size value) : m_value(static_cast<Enum>(value)) {}
EnumT(Enum value) : m_value(value) {}
EnumT &operator=(Enum e) { m_value = e; return *this; }
operator Enum() const { return m_value; }
virtual bool setFromString(const String &s) { m_value = getEnum(s); return m_value != MAX_ENUM; }
const Char *str() const { return *getString(m_value); }
private:
static String *enumNames()
{
static bool s_init = false;
static String s_enumNames[MAX_ENUM + 1];
if (!s_init)
{
s_init = true;
tokeniseEnumString(s_enumNames, MAX_ENUM + 1, GetEnumString::get());
}
return s_enumNames;
}
Enum m_value;
};
void tokeniseEnumString(String *enumArray, Size enumArrayCapacity, const String &enumString)
{
Size enumArraySize = 0;
Size cIndex = 0;
while(cIndex < enumString.len())
{
String name;
bool hasExplicitValue = false;
for (; cIndex < enumString.len(); ++cIndex)
{
const Char nameChar = enumString[cIndex];
if (nameChar == ',')
{
++cIndex;
break;
}
if (nameChar == '=')
{
hasExplicitValue = true;
++cIndex;
break;
}
if (std::isspace(nameChar))
continue;
name += nameChar;
}
if (hasExplicitValue)
{
String numberStr;
for (; cIndex < enumString.len(); ++cIndex)
{
const Char numberChar = enumString[cIndex];
if (std::isspace(numberChar))
continue;
if (numberChar == ',')
{
++cIndex;
break;
}
ASSERT(std::isdigit(numberChar));
numberStr += numberChar;
}
Int intValue;
ASSERT(numberStr.toInt(intValue));
ASSERT(intValue >= 0);
const Size value = static_cast(intValue);
ASSERT(value >= enumArraySize);
while (enumArraySize < value)
++enumArraySize;
}
enumArray[enumArraySize] = name;
++enumArraySize;
}
ASSERT(enumArraySize == enumArrayCapacity);
}
 |
| Before - no simplification |
 |
| After - with simplification! |
m_top = m_near * Math::tan(0.5f * m_verticalFov);
m_right = m_top * m_display->aspectRatio();
vec3 viewSpacePos(vec2 winPos, vec2 winSize, vec4 depthSample, vec2 nearFar)
{
vec3 position;
float depth = depthSample.x;
position.z = -nearFar.x / (nearFar.y - (depth * (nearFar.y - nearFar.x))) * nearFar.y;
position.x = (((winPos.x / winSize.x) * 2.0) - 1.0) * u_right;
position.y = (((winPos.y / winSize.y) * 2.0) - 1.0) * u_top;
float scale = -position.z / nearFar.x;
position.x *= scale;
position.y *= scale;
return position;
}
I've been getting back into doing work on my Balloon Fight clone again. I decided to rename it to Battle Balloons, just to avoid infringing any potential naming legalities. I kind of started getting back into this as an experiment to see if I could avoid writing a game in C++. I battle it out with C++ all day at work, so I would prefer something a little nicer when writing my own hobby projects. :) Kind of worrying I am spending what little time I have on this too. More late hours. I wish sleep was optional.
Basically, it's written in a mix of C and Ruby. The C is used for accessing the SDL library, which is a portable gaming library that works on many operating systems including Windows, OS X, and Linux. The rest I intend to be all Ruby. I'll jump back into C as needed.
As for the game itself, I don't really have much to show at the moment. I have just been working on infrastructure so far. :/ If you're a curious coder, then you can take a peek at what I've done so far at: http://code.google.com/p/battleballoons/
Anyway, time for some Battlestar Galactica... and then sleep. :)
Have not really had time to do much on this site. Even though it is nearly done (just need to clean up the code a bit more and also the side bar on the right there). I will soon hopefully. :) Anyway, I spent this morning uploading a short clip of a game I am making, Balloon Fight. I have been working on it in the little spare time I have (when I am not working on Fury, which is a real game). Speaking of which, we will be releasing the game VERY SOON (early October), which means I will have even less time for doing other things... oh well. -_-
Anyway, here's the YouTube video (http://www.youtube.com/watch?v=WtQfQoILXvg):