In keeping with the multi-platform spirit, finally did a test build on Linux tonight. Apart from some major annoyances related to case sensitivity, building wasn’t too bad. Ubuntu has made it really easy to install all necessary dependencies (clang, xorg-dev, SDL, freetype, etc).
Test run on linux
If my soul had a home, I think it’d be on the water.
Two days at the beach gave me some great insight on how to finish my design for tentative “level 1″ and make it work. I sketched it up in pixelmator using my stylus and I gotta say, designing levels outside of the development process is very fast and I finally see the utiliity in it now. But I’m not going to post any design sketches just yet.
Awesome progress on the level editor warrants some rest. I got saving and loading working pretty stable, and finally implemented basic parallax effects. One of these days I’ll start working on undo as well, as it is annoying that I can’t make any mistakes without having to close and reload the levels. Also updated the ios code so I can test the levels on my iPad.
Edit: Inlined animated gif’s on the main page are super annoying. Click here to see the parallax effect.
Not much new to say. Development picked up some pace but still is slow. I added a properties panel to the editor that allows me to set blending modes among other things. I also finally implemented basic layering.
I’m still racking my brain on level design and figuring out how to make the main idea behind this game work while remaining fun and easy to play. Not feeling all that creative today, so I’ll tackle that another day.
This weekend has proven itself to be frustrating and difficult. Trials and tribulations – I almost need them to remind me why I started making this game in the first place. Sometimes life takes unexpected turns.. so unexpected that you wonder if you’re dreaming – and if reality is sitting back somewhere waiting for you to wake up. Sometimes the dream, your current reality, is good. Other times, it isn’t. But our own reality, like dreams, can change as quickly as the weather.. and I think that’s what this game is going to be about.
Development progress has been slow, however I have reached a small milestone in that I can finally load XML level files back into the editor for the most part. This is a crucial piece of development, so that I can lay ideas down in the form of levels and revisit them later. Even with the help of tinyxml2, this is proving to be more complicated than I initially thought. I’m more used to working with binary or JSON file file formats instead, but I’m taking advantage of this opportunity to learn XML.
There is still much to be done, including the ability to edit the background and foreground layers. I’m intentionally leaving the default background color hardcoded to an ugly color, to force me to implement placing game objects on it sooner than later.
I also downloaded Pixelmator (sorry gimp) for the bamboo stylus and retina support so that I can start making more mock assets for the game. My artwork is still looking pretty ugly, but I’m hoping to improve over the next couple months.
“We become what we think about, and everything that we are right now…is the sum total of everything we’ve thought to this period.” -Brian Tracy
Does anyone remember this game? It was definitely ahead of its time.. at least for the Sega Genesis genre. There was something overly simplistic about it’s nature, especially how the game starts – the main character, and a single simple enemy to overcome. While some games prefer a slightly more aggressive learning curve, kid chameleon eased the player in slowly because it was going to be a long long journey. This game featured over 100 levels, which was pretty unheard of at the time. As a kid, the sheer length of this game always intrigued me. So much so, that after the game cartridge disappeared during a move, I actually bought a second copy.
It comes as no surprise then, that the development team for KC must’ve put a lot of work into putting the game together, especially with early 90′s game development hardware and technology.
An excerpt of the ending credits for kid chameleon
They say imitation is the most sincere form of flattery. There are definitely some elements of KC that I’d like to use in game design, and others not so much. The hit point system, and the crazy number of character abilities (helmets) makes for some hectic and somewhat frustrating gameplay. Additionally, all of the warp zones and “where am I” feel made me dizzy. On the other hand, the dynamic lighting effects and weather during some levels was very cool, not to mention the ability for some of the characters to fly. Either way, subconsciously or consciously, I can definitely see elements of kid chameleon coming out in some of my development.
So, I bit the bullet the other day and implemented something that I knew I’d be needing soon. Annoyed that I didn’t have a text-rendering system in place to display things like the current FPS on the screen (and because I hate reading console output), I sought out a decent portable text rendering solution for OpenGL that I could easily port to Direct3D later down the road if needed. Normally, on the mac platform, I’d just drop into Core Graphics and render the text string to a blank bitmap and roll that bitmap into a texture. But since I’m trying to be portable, I can’t rely on anything specific to mac os, or windows, or anything!
One thing became readily apparent was that any solution I devise will use FreeType2, a very useful portable font library for rendering TrueType fonts. One thing that I was not predicting however, was that there exists a multitude of libraries that run on top of FreeType2 (such FreeTypeGL) as whose sole purpose is to use freetype to render text on OpenGL. This annoyed me. I don’t want to drop in an entire heavy-weight font library complete with 30+ source files, with its own license, just to render a single static string to a texture. Furthermore, these libraries become another barrier for portability in terms of OpenGL/Direct3D abstraction. I’m ok with linking graphics-independent libs such as freetype, but entire subsystems relying on OpenGL, that’s where I draw the line.
So, I decided to do it myself. Freetype can’t be that hard anyway right? So it really only takes about 100 lines of code to use freetype to render to a image buffer suitable for rolling into an OpenGL texture. So here you have it, my experimental, non-optimized Text Texture class..
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
#include <ft2build.h>
#include <freetype/freetype.h>
#include "Texture2D.h"
namespace ssf
{
class TextTexture2D : public Texture2D
{
public:
TextTexture2D(const string &text,
const string &fontFilename, int fontPointSz, int texWidth, int texHeight);
protected:
void draw(FT_Bitmap &bitmap, int x, int y, GLubyte *data);
};
} |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 |
//http://www.freetype.org/freetype2/docs/tutorial/step2.html
#include <ft2build.h>
#include <freetype/freetype.h>
#include <freetype/ftglyph.h>
#include <freetype/ftoutln.h>
#include <freetype/fttrigon.h>
#include <vector>
#include <iostream>
#include "TextTexture2D.h"
using namespace std;
namespace ssf
{
///This function gets the first power of 2 >= the
///int that we pass it.
inline int next_p2(int a)
{
int rval=1;
while(rval<a) rval<<=1;
return rval;
}
void TextTexture2D::draw(FT_Bitmap &bitmap, int x, int y, GLubyte *data)
{
//TODO - use memcpy or mmx/sse to speed this up
for(int j = 0; j < bitmap.rows; j++)
{
for(int i = 0; i < bitmap.width; i++)
{
if(i+x > 0 && i+x < texWidth && j+y > 0 && j+y < texHeight)
{
data[(i+x+(j+y)*texWidth)] = bitmap.buffer[i + bitmap.width*j];
}
}
}
}
static void flip(GLubyte *src, GLubyte *dest, int w, int h, int pSz)
{
for(int i = 0; i < h; i++)
{
memcpy(dest+(h-1-i)*w*pSz, src+(i*w*pSz), w*pSz);
}
}
TextTexture2D::TextTexture2D(const string &text,
const string &fontFilename, int fontPointSz, int texWidth, int texHeight)
{
vector<float2> textureAtlasOffsets;
FT_Library library;
if(FT_Init_FreeType( &library ))
throw std::runtime_error("FT_Init_FreeType failed");
//TODO cache this stuff better
FT_Face face;
if(FT_New_Face(library, fontFilename.c_str(), 0, &face))
throw std::runtime_error("FT_New_Face failed (there is probably a problem with your font file)");
//For some twisted reason, Freetype measures font size
//in terms of 1/64ths of pixels. Thus, to make a font
//h pixels high, we need to request a size of h*64.
FT_Set_Char_Size(face, fontPointSz << 6, fontPointSz << 6, 96, 96);
GLubyte *data = new GLubyte[texWidth * texHeight];
memset(data, 0, texWidth*texHeight);
width = this->texWidth = texWidth;
height = this->texHeight = texHeight;
alpha = true;
mipmap = false;
FT_GlyphSlot slot = face->glyph; /* a small shortcut */
FT_UInt glyph_index;
FT_Bool use_kerning = FT_HAS_KERNING(face);
FT_UInt previous = 0;
int pen_x = 0, pen_y = texHeight, error;
for(int n = 0; n < text.length(); n++)
{
/* convert character code to glyph index */
glyph_index = FT_Get_Char_Index(face, text[n]);
/* retrieve kerning distance and move pen position */
if(use_kerning && previous && glyph_index)
{
FT_Vector delta;
FT_Get_Kerning(face, previous, glyph_index,
FT_KERNING_DEFAULT, &delta);
pen_x += delta.x >> 6;
}
/* load glyph image into the slot (erase previous one) */
error = FT_Load_Glyph(face, glyph_index, FT_LOAD_RENDER);
if(error)
continue; /* ignore errors */
/* now draw to our target surface */
draw(slot->bitmap, pen_x + slot->bitmap_left, pen_y - slot->bitmap_top, data);
/* increment pen position */
pen_x += slot->advance.x >> 6;
/* record current glyph index */
previous = glyph_index;
}
GLubyte *dataFlipped = new GLubyte[texWidth * texHeight];
flip(data, dataFlipped, texWidth, texHeight, 1);
glGenTextures(1, &tex);
glBindTexture( GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//Here we actually create the texture itself
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, width, height,
0, GL_RED, GL_UNSIGNED_BYTE, dataFlipped);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
delete dataFlipped;
delete data;
FT_Done_Face(face);
FT_Done_FreeType(library);
optimalTexCoords = NULL;
}
} |
Not very efficient yet, but it works!
To save memory, I decided to store the text image in a single channel texture (GL_RED format). So, I have to use a special swizzle in the GLSL code so the texture doesn’t render red.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
#ifdef GL_ES
precision highp float;
#endif
uniform sampler2D texture0;
varying vec2 varTexCoord0;
varying vec4 varColor;
void main()
{
vec4 texCol = texture2D(texture0, varTexCoord0).rrrr;
gl_FragColor = varColor * texCol;
} |
And.. it works!
Finally. I can show my FPS on the screen like a proper game.
Bringing the blog up to speed, here is more-or-less the current state of the game and tools.
The initial control system is done, font rendering, basic physics, texture rendering, basic shaders, etc.
From here, the plan is to focus fully on the level editor so I can save my ideas to level files and work up to an initial “first level” kinda demo.
Here we go, An early first test run of ssf/platform2D engine code. It’s so amazing!
My Journey started before I knew where I was headed..
About two years ago, I started work on one of my biggest software projects, Verto Studio 3D. I started the project because I wanted to prove myself as a software developer. I wanted to prove that if I put my mind to it, and really pushed myself, I could come up with a product that was a real accomplishment. Looking back, I’m satisfied with Verto. But something is missing.
I’ve lost touch with my roots. Ever since I was a kid, I’ve wanted to make video games. I learned C/C++ and OpenGL because I wanted to be a game developer. Yet, I haven’t ever made a good game. Good games are defined by critical acclaim, and every game I’ve ever made has had none. Furthermore, I’ve never really been proud of any game I’ve tried to make. Not since I was 18 years old anyway. The other day, my old game dev website got taken down, and it made me reminisce. Ever since I learned 3D graphics, I’ve always tried to make large epic 3D games by myself – focusing more on the programming and graphics techniques than the gameplay. This will change. It’s time to make a simple 2D game, and attempt to make it good. I’ll post my experiences here.
It’ll be fun to someday look back at some of these earlier posts, and see how bad the game was and watch it mature overtime… or descend into oblivion whichever happens first.
SimpleStormFront (ssf) is a 4th generation game API. It’s the 4th time I’ve rewritten my C++ OpenGL classes. This time, I’m focusing on modern graphics systems and OpenGL3.x/GLES2.x core capability, and am considering Direct3D10 down the road. I’ve also extracted out all system-specifics, so the code can be ran on any system I desire to port the core to (windows, mac, sdl, cocoa, iOS, xbox, etc). For now, It’s designed to run on any graphics system that supports shaders and VBOs.
Platform2D is currently the name of the set of c++ classes running on top of ssf. In-short Platform2D is the terrible name I’ve given to the game engine. Platform2D will be written 100% against ssf and other portable 3rd party libraries, not allowing it to touch anything but ssf API permits maximum portability down the road.
LevelEditor is the name of mac/cocoa tool that will be used to create the levels for Platform2D. All these “things” will come together to help me make “The Game”, a nameless, shapeless project that will mature over time. Apart from a few visions in my head, not much about the game or it’s designed is set in stone. All I know is that it will be a 2D platformer.
Stay tuned..
