SDLTutorials.com

Keep an eye out…

Tim Jones — Tue, 20 Jul 2010 19:48:09 +0000

Upgrading to WordPress 3.0 – let me know if any of you experience any issues. Thanks.

Edit: Updated. Everything seem okay?

SDL Video Tutorials

Tim Jones — Fri, 16 Jul 2010 10:55:33 +0000

I’m just kind of throwing this idea out there – but would any of you benefit from video tutorials with me explaining things as each tutorial is coded?

Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

As an aside, here’s a quick plug for Skylar Payne. He has made some video tutorials that you can check out:

Contest Ideas Needed

Tim Jones — Fri, 16 Jul 2010 10:55:23 +0000

The new tutorials are well under way (I’ve decided to make a side-tutorial for game states, but it’s tightly integrated into the space shooter tutorial). But while we’re waiting for that, I think I’d like to run another contest. But before we get to any sort of contest announcement, I’d like to get everyone’s ideas out there on what we should do. Donations are also welcome that will be pooled directly into a contest prize.

C++ Tip – Packing Data

Tim Jones — Thu, 15 Jul 2010 12:25:19 +0000

Here’s a quick tip that is useful if you are sending data over a network. If you ever messed with any sockets in programming then you know you can only send bytes of data. Why is this problem? Well, you can’t exactly send over a 4 byte integer in a single 1 byte char. To get around this, we do something called packing.

char Buffer[3];
int Data = 1024;

#if SDL_BYTEORDER == SDL_BIG_ENDIAN
Buffer[0] = (Data >> 24) & 0xFF;
Buffer[1] = (Data >> 16) & 0xFF;
Buffer[2] = (Data >> 8) & 0xFF;
Buffer[3] = (Data) & 0xFF;
#elseif
Buffer[3] = (Data >> 24) & 0xFF;
Buffer[2] = (Data >> 16) & 0xFF;
Buffer[1] = (Data >> 8) & 0xFF;
Buffer[0] = (Data) & 0xFF;
#endif

Now, we can easily send over the Buffer char array. Two things to note here. First, depending on the system you are working on, the endianness can change (to read up on what endianness is, look here: http://en.wikipedia.org/wiki/Endianness) – that is what the #if SDL_BYTEORDER == SDL_BIG_ENDIAN statement is for. Secondly, we did nothing here to specify if the data being packed is signed or unsigned. You will need to know on the other end what type of data you are receiving.

Here’s how you can unpack this data:

char Buffer[3];
int Data = 0;

#if SDL_BYTEORDER == SDL_BIG_ENDIAN
Data = ((((Uint8 *)Buffer)[0] << 24) | (((Uint8 *)Buffer)[1] << 16) | (((Uint8 *)Buffer)[2] << 8) | ((Uint8 *)Buffer)[3] << 0);
#elseif
Data = ((((Uint8 *)Buffer)[3] << 24) | (((Uint8 *)Buffer)[2] << 16) | (((Uint8 *)Buffer)[1] << 8) | ((Uint8 *)Buffer)[0] << 0);
#endif

SDL_ttf 2.0.10 RELEASED!

Tim Jones — Fri, 09 Jul 2010 15:37:20 +0000

Official SDL announcment:

Announcing the latest release of SDL_ttf!

http://www.libsdl.org/projects/SDL_ttf/

CHANGES:
* Find the Unicode or symbol character map if it’s available in the font
* Set the appropriate font styles for bold and italic fonts
* Added font style TTF_STYLE_STRIKETHROUGH
* Fixed size calculations taking outline and underline into account
* Added API for font outlining: TTF_GetFontOutline()/TTF_SetFontOutline()
* Added API to disable kerning: TTF_GetFontKerning()/TTF_SetFontKerning()
* Fixed height calculation for fonts that extend below the font height
* Added access to font hinting: TTF_GetFontHinting()/TTF_SetFontHinting()
* Added TTF_GlyphIsProvided() to check whether a glyph is in a given font

Thanks to everybody who contributed feedback and patches for this release!
–
-Sam Lantinga, Founder and President, Galaxy Gameworks LLC

Next Tutorial ???

Tim Jones — Wed, 16 Jun 2010 18:11:34 +0000

I’m pondering over what tutorial should be next. What do you think should be next?

Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

Update:
I think it’s pretty obvious. I’ll go for making the space shooter the next tutorials. Bits and pieces will be taken from Ace of Space (of course). I may throw in Game States in the same tutorial, or make a side tutorial (as it would be relevant here).

Thanks everyone.

C++ Tip – Literals

Tim Jones — Tue, 08 Jun 2010 10:56:44 +0000

A common area that people don’t even know exist in C++, is called literals or literal constants. But even though you may not have heard of the term before, you no doubt have been using them all the time. For example, 2.0f is a float literal, while 2.0 is a double literal. 0×1 is a hex int literal, while 0x1L is a long int literal. This is important to remember, especially when precision and data size is involved. You may be losing out on data, and you didn’t even know you were!

Here’s a quick table run-down, taken from http://cpp.comsci.us/etymology/literals.html.

Type	Base	Example	Description
char *	ASCII	“hello”	Any string of characters enclosed in double quotes (“) (see Note 1)
char	ASCII	’1′	One character in single quotes (‘)
unsigned short int	ASCII	L’ab’	One or two characters in single quotes (‘), preceded by the letter L
int	octal	01	Any octal number (digits 0-7) beginning with a 0 (zero)
	decimal	1	Any decimal number (digits 0-9) not beginning with a 0 (zero)
	hexadecimal	0×1	0X (zero X) or 0x (zero x) followed by any hexadecimal number (digits 0-F)
	ASCII	‘ABC’	Two to four characters in single quotes (‘)
unsigned int	octal	01U	Any octal number (digits 0-7) beginning with a 0 (zero) and followed by U or u
	decimal	1U	Any decimal number (digits 0-9) not beginning with a 0 (zero) and followed by U or u
	hexadecimal	0x1U	0X (zero X) or 0x (zero x) followed by any hexadecimal number (digits 0-F) and followed by U or u
long int	octal	01L	Any octal number (digits 0-7) beginning with a 0 (zero) and followed by L or l
	decimal	1L	Any decimal number (digits 0-9) not beginning with a 0 (zero) and followed by L or l
	hexadecimal	0x1L	0X (zero X) or 0x (zero x) followed by any hexadecimal number (digits 0-F) and followed by L or l
unsigned long int	octal	01UL	Any octal number (digits 0-7) beginning with a 0 (zero) and followed by U or u and L or l
	decimal	1UL	Any decimal number (digits 0-9) not beginning with a 0 (zero) and followed by U or u and L or l
	hexadecimal	0x1UL	0X (zero X) or 0x (zero x) followed by any hexadecimal number (digits 0-F) and followed by U or u and L or l
float	decimal	12.3F	Any number (digits 0-9) containing a decimal point (.) and followed by F or f
float	decimal	12E1F	Any number (digits 0-9) followed by E or e, followed by an exponent of 10 (12E1 = 12 * 101 = 120.), and followed by F or f
double	decimal	12.3	Any number (digits 0-9) containing a decimal point (.)
double	decimal	12E1	Any number (digits 0-9) followed by E or e and followed by an exponent of 10 (12E1 = 12 * 101 = 120.)
long double	decimal	12.3L	Any number (digits 0-9) containing a decimal point (.) and followed by L or l
long double	decimal	12E1L	Any number (digits 0-9) followed by E or e, followed by an exponent of 10 (12E1 = 12 * 101 = 120.), and followed by L or l
Notes: String constants are stored as the literal characters followed by a byte of binary 0. The value returned is a pointer to the first character.

SDL + OpenGL Tutorial Basics

Tim Jones — Sat, 05 Jun 2010 16:25:18 +0000

In this new tutorial series, we will be looking at using SDL along with OpenGL. SDL as it stands is nice for basic 2D graphics/composition, but when it comes to more intensive gaming applications or 3D graphics, we need to leverage the use of other libraries. SDL works so well with OpenGL because we can use OpenGL to manage only graphical rendering, and leave SDL for everything else (Events, Window management, etc).

So, lets get started. We’ll be basing our code off of the “SDL Tutorial Basics” tutorial – so head on over there first if you haven’t had a chance to look at it. Primarily what we’ll be doing here is making any necessary changes to the code for use with OpenGL. What’s nice about SDL is that it provides an easy way to setup OpenGL. On the technical side of things, whenever a window is created on an operating system, an OpenGL context must also be created (with certain properties) and linked to that window. SDL makes this rather easy for us.

Before we get started with modifying our code, open up your project file (the one from SDL Tutorial Basics). Because we are using another library now, we are going to need to link to it. So, open up your Project Properties, and add “opengl32″, “glu32″ to your linker settings (this is the same area that has mingw32, SDLmain, SDL). If you are another operating system besides Windows, your library names will most likely be “opengl”, “glu.” Most people already have the OpenGL library installed (as it usually comes with CodeBlocks). If you don’t, make sure you downloaded the CodeBlocks with mingw. If you are on some Linux flavor, try installing Mesa. Also, as a last note, put the new libraries after the SDL libraries.

That’s it for project settings, lets move on to modifying our code. Open up CApp.h and include our OpenGL header file.

#ifndef _CAPP_H_
#define _CAPP_H_

#include
#include
#include

// … other code below

If you are wondering what the difference between gl and glu, gl contains the primary functions from the OpenGL specification, and glu contains several helper/utility functions for creating complex shapes, moving the camera, etc. So now that we have that, lets actually get OpenGL up and running. Open up CApp_OnInit.cpp. Right now this is what we have:

#include "CApp.h"

bool CApp::OnInit() {
if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
return false;
}

if((Surf_Display = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) {
return false;
}

return true;
}

The first thing we need to do is tell SDL that we are going to be using OpenGL. Thankfully, SDL provides an easy way to do this. Add the flag SDL_OPENGL just after SDL_DOUBLEBUF, and change SDL_DOUBLEBUF to SDL_GL_DOUBLEBUFFER:

if((Surf_Display = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_GL_DOUBLEBUFFER | SDL_OPENGL)) == NULL) {
return false;
}

Now, there are several settings you can set for OpenGL. By default, most are fine just as is, but I want to make you aware of them:

SDL_GL_SetAttribute(SDL_GL_RED_SIZE,    8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,    8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,    8);

SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);

SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 8);

SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2);

These are all basic memory sizes for how much data OpenGL will store (except SDL_GL_MULTISAMPLEBUFFERS/SDL_GL_MULTISAMPLESAMPLES, those are for something else). By increasing these, you will effectively increase how much memory OpenGL will use for color information, and the buffer. As I mentioned before, the default on all of these is usually just fine. If you wish to set these, the values I have up above are pretty good. Be sure to call SDL_GL_SetAttribute before calling SDL_SetVideoMode. One thing I want to mention is on SDL_GL_MULTISAMPLEBUFFERS. This is basically your anti-aliasing flag. By turning this on, you are turning on anti-aliasing. SDL_GL_MULTISAMPLESAMPLES is how much to anti-alias. A value of 2 is pretty standard if turned on, 4 is also commonly used. Just keep in mind that this can be resource intensive for some systems. Also, not every computer is able to perform anti-aliasing. And one last note! Make sure your SDL_GL_DEPTH_SIZE is a power of two (16, 32 works), otherwise anti-aliasing may not work for you.

Moving on. Now we basically have OpenGL setup with our window, but the problem is that OpenGL requires additional information about the rendering area. What I mean by this is that because OpenGL is a 3D rendering library, it needs to know some basic things like where the camera is, what our 3D world looks like, what color is our rendering area, etc.

So, lets add a few more lines of code after SDL_SetVideoMode.

glClearColor(0, 0, 0, 0);
glClearDepth(1.0f);

glViewport(0, 0, 640, 480);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glOrtho(0, 640, 480, 0, 1, -1);

glMatrixMode(GL_MODELVIEW);

glEnable(GL_TEXTURE_2D);

glLoadIdentity();

Okay, this is where we actually get to start using OpenGL. First, note that OpenGL is a C library (like SDL), and that all function calls begin with gl* (much like all SDL function calls begin with SDL_*). So what are we doing here exactly? The first function call, glClearColor, tells OpenGL what color to render the view when the color buffer is cleared. The color buffer is the buffer OpenGL uses to render pixels to the screen. glClearDepth does something similar. It tells OpenGL what value to reset the depth buffer when it is cleared. The depth buffer is used to determine the z-axis of a pixel. There are other buffers as well, but only worry about these two for now. The 4 arguments are basically Red, Green, Blue, Alpha. With 1.0f being full color, and 0.0f being no color. If you want to define values as regular RGB 255 values, do this:

glClearColor((128.0f / 255.0f), 1.0f, 1.0f, 1.0f); //Cyan color

Next, we setup the viewport for opengl. This, in essence, is the window area OpenGL will use. If you set it smaller to the SDL window size you’ll have black borders, and if you set it larger then the SDL window, you’ll have your view clipped. Usually, this will always be the same as the regular window size, but there are certain cases you would want it smaller (you can actually create multiple viewports, and have them all display different camera angles of a single scene). Arguments are X, Y, Width, Height.

After that, we tell OpenGL to change to GL_PROJECTION mode. OpenGL contains certain matrix modes that affect certain things. I don’t want to confuse you with technical details, but you’ll only ever want to use GL_PROJECTION when you are setting up the “projection” of the scene (which is what the glOrtho call does). Other possible projection functions are glLoadIdentity / gluPerspective / glFrustum / gluOrtho2D. Otherwise, you’ll almost always want to be in GL_MODELVIEW mode.

So, after we are in projection mode, we call glLoadIdentity (which is basically a “reset matrix” call). Then, we call glOrtho. Now, to take a quick aside for a moment, we have been working in 2D thus far in all the tutorials on this website. This tutorial is no different, so we are going to use glOrtho to setup a “2D Perspective.” An ortho, or orthogonal, perspective is one that flattens a 3D environment into a 2D one. This more or less elmiminates any 3D look, and makes it render like a regular 2D game. Please note though, you can still using the z-axis for layering. On the flip side, if you wanted a 3D environment, you would use gluPerspective or similar to setup a “3D Perspective.” So, in simple basic terms, for 2D us glOrtho, and for 3D use gluPerspective. Regarding the arguments of the function, they are Left, Right, Bottom, Top, Near, Far. So, by setting Left to 0, and Right to 640, I am defining the perspective area. If you set these values to something different than the window size, it’d basically stretch / shrink everything.

Moving on, we switch to GL_MODELVIEW mode, reset it, and also enable GL_TEXTURE_2D (By default, textures are not enabled). What is a texture? A texture is very much like an SDL_Surface. It’s an image stored in memory that can be rendered to the display, but unline SDL_Surface’s, Textures cannot be rendered to the screen on there own. They must be attached to some sort of primitive. Meaning, if you want to render a basic texture like an SDL_Surface, you have to “Bind” the texture (make it active), render a square, and then attach the texture to the four corners of that square. It sounds more complex then it really is, and we’ll take a look at doing that in future tutorials.

This is how our OnInit methods ends up looking like:

bool CApp::OnInit() {
if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
return false;
}

SDL_GL_SetAttribute(SDL_GL_RED_SIZE,    8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,    8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,    8);

SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);

SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 8);

SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);

SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2);

if((Surf_Display = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_GL_DOUBLEBUFFER | SDL_OPENGL)) == NULL) {
return false;
}

glClearColor(0, 0, 0, 0);

glViewport(0, 0, 640, 480);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glOrtho(0, 640, 480, 0, 1, -1);

glMatrixMode(GL_MODELVIEW);

glEnable(GL_TEXTURE_2D);

glLoadIdentity();

return true;
}

Okay, that’s it for our OpenGL setup. Please note that there are other setup options I haven’t mentioned, but I am sure we will get to them in future tutorials.

Jump on over to OnRender and lets get something to show up on the screen.

void CApp::OnRender() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

glBegin(GL_QUADS);
glColor3f(1, 0, 0); glVertex3f(0, 0, 0);
glColor3f(1, 1, 0); glVertex3f(100, 0, 0);
glColor3f(1, 0, 1); glVertex3f(100, 100, 0);
glColor3f(1, 1, 1); glVertex3f(0, 100, 0);
glEnd();

SDL_GL_SwapBuffers();
}

We should be able to get through this fairly quickly. The first line clears our color and depth buffer. For all simplistic purposes, this does a type of reset, and makes our screen blank again. This is similar to calling SDL_FillRect on SDL’s primary display surface. Keep in mind though it does more than that. Then, we reset our GL_MODELVIEW matrix. Why? Whenever you move around in the 2D / 3D world in OpenGL to render things you are modifying the model view matrix. This matrix is what OpenGL uses to determine where and how to render something to the screen. So, if you are moving around rendering things, you need to reset it on every loop.

Next is where the magic starts to happen. glBegin is used to signal the start of the rendering of a primitive. The parameter is used to simply define what primitive you are going to render. In this case, we are going to render a Rectangle (called a Quad – 4 sides). glEnd is used to signal the end you rendering that primitive.

Now, when we go to render our primitive what we have to do is define each corner of that primitive. So, we start with the first corner (or vertex), specify the coordinates, and then move to the next, and so on. At the same time, I am defining the colors of each corner (each corner will have a different color). What OpenGL will do for us is color the entire primitive blending those four corner’s colors together. It ends up looking like this:

Lastly, we call SDL_GL_SwapBuffers which basically takes the buffer and moves it to the primary display – much like SDL_Flip.

And that’s it! I hope you see how easy it is to setup OpenGL. There’s quiet a bit to memorize at first, but once you have it down, it’s not that bad at all.

If you want more information about specific functions, check out the docs here:
http://www.opengl.org/sdk/docs/man/

SDL + OpenGL Tutorial Basics – Tutorial Files:
Win32: Zip

Featured SDL Library – Net2

Tim Jones — Wed, 02 Jun 2010 16:36:03 +0000

This post is part of something new I will be doing every once in a while. I will choose at random from a bunch of SDL libraries (that are good) and feature them here for all of you to check out. Today, we have a library called Net2 created by Bob Pendleton. He has been a frequent SDL contributor for quite a while now, and if you’ve ever subscribed to the SDL Mailing List, you probably have seen emails from him.

So what is Net2? In a nutshell, it’s a layer on top of SDL_net that passes all network communication over SDL’s existing event system. In other words, when something happens on the network (such as a new connection, or received data), you will receive an SDL_Event in your primary thread. Additionally, Net2 runs in its own thread and is thread-safe (SDL_net by itself is not thread safe). And lastly, it’s super simple to use and it just plain works.

Here’s an example TCP Client/Server from the Net2 documentation:

Client

#include
#include

// The following libraries all have to be included to get all of SDL
// plus the net2 and fastevents libraries. I include my SDLUtils
// library because I have used my initialization and quit functions to
// simplify the code.

#include "SDL.h"
#include "net2.h"
#include "SDLUtils.h"

int main(int argc, char **argv)
{
char buf[100]; // storage for a message
int i; // a counter
int s = -1; // the socket, just an int
int count = 0; // how many messages to send
int limit = 1000;

mySDLInitOrQuit(SDL_INIT_EVENTTHREAD | // initialize SDL. We need
SDL_INIT_VIDEO | // events and it doesn’t
SDL_INIT_NOPARACHUTE); // work without video.

// Here we ask for a connection to the computer. In this case we are
// just trying to connect to the computer we are on at port 6666. We
// check to make sure we have a valid connection before going on with
// the rest of the program. Note that the socket id winds up in s.

if (-1 == (s = NET2_TCPConnectTo("localhost", 6666)))
{
printf("ConnectTo failed\n");
exit(0);
}

// All we do here is create a message and send it. The message is just
// the words "TCP message" followed by a message number.

for (i = 0; i < limit; i++)
{
memset(buf, 0, sizeof(buf));
sprintf(buf, "TCP message #%08d\n", i); // create the message to send
NET2_TCPSend(s, buf, sizeof(buf)); // send it and count it.
count += sizeof(buf);
//printf("%d\n", i);
//SDL_Delay(1);
}

printf("count=%d\n", count); // tell how many were sent

mySDL_Quit(); // clean up.
}

Server

#include

#include "SDL.h"
#include "fastevents.h"
#include "net2.h"
#include "SDLUtils.h"

int main(int argc, char **argv)
{
SDL_Event ev; // an SDL event
char buf[1024]; // a message buffer
int len = 0; // some counters
int count = 0;
int socks = 0; // the number of
// connected sockets,
// which is also the
// number of connected
// clients.

mySDLInitOrQuit(SDL_INIT_EVENTTHREAD | // initialize SDL. We need
SDL_INIT_VIDEO | // events and it doesn’t
SDL_INIT_NOPARACHUTE); // work without video

// This is where we tell NET2 to start accepting TCP/IP connections on
// port 6666. This call does not wait for a connection to come in. It
// tells NET2 to do the waiting and it returns immediately. After this
// call returns your program will get an event any time a computer
// trys to connect to the port given in this call.

NET2_TCPAcceptOn(6666);

while (FE_WaitEvent(&ev)) // wait for events
{
//printSDLEvent(&ev);

switch (ev.type)
{

// all NE2 events are SDL_USEREVENTs but not all user events are NET2
// events. If you use user events in your code you need to be careful
// to make sure you are not using the same event codes that NET2 uses.

case SDL_USEREVENT:
switch(NET2_GetEventType(&ev))
{

// This next piece of code handles an accept event. This event tells
// us that an connection has been accepted. Here, all we do is count
// it. You would normally take some other action.

case NET2_TCPACCEPTEVENT:
printf("accept(%d)\n", NET2_GetSocket(&ev));
printNET2Event(&ev);
socks++;
break;

// This next piece of code is for handling receive
// events. This kind of event tells us we have input waiting
// on a socket. You need to grab all of it. No that we get the
// socket from the event. You can use the socket to tell you
// which user sent the information to you.

case NET2_TCPRECEIVEEVENT:
while (0 != (len = NET2_TCPRead(NET2_GetSocket(&ev), buf, sizeof(buf))))
{
count += len;
}
break;

// If an error occurs on a socket or the other computer closes
// the connection you will get a close event. When you get a
// close event you must close the socket. Use the socket in
// the event to tell you which connection went away.

case NET2_TCPCLOSEEVENT:
printf("close(%d)\n", NET2_GetSocket(&ev));
printNET2Event(&ev);
NET2_TCPClose(NET2_GetSocket(&ev)); // close the socket

printf("count=%d\n", count); fflush(NULL);
socks–;
if (0 >= socks)
{
//exit(0);
}
//count = 0;
break;

// Sometimes you will get errors. It is best to keep track of
// them and try to figure out what is causing them.

case NET2_ERROREVENT:
printf("Error: %s(%d)\n", NET2_GetEventError(&ev), NET2_GetSocket(&ev));
printNET2Event(&ev);
break;
}
break;

case SDL_QUIT: // time to quit
mySDL_Quit(); // clean up and exit
exit(0);
break;
}
}

mySDL_Quit();
}

So what are some of the cons of this library? Mostly that the author likes to extensively use his own custom functions for things unrelated to the library. In addition, his “Fast Events” library is required to use Net2 at all (unless you want to modify the source).

Check out the Net2 Library here:
http://www.gameprogrammer.com/net2/net2-1.html

And the Tetris Contest winner is…

Tim Jones — Sat, 22 May 2010 15:19:59 +0000

Bloc!

Download

Congratulations! I encourage all of you to continue working on your projects, and polish them up.

Regarding the winner, I found it to be well thought out, has snazzy effects, and has some pretty good source code.

View past entries

Tetris Contest – Your Turn

Tim Jones — Wed, 12 May 2010 11:25:18 +0000

Alright everyone, it’s your turn to take a look at the contest entries and let me know what you think. Vote for the one you like best, and let us know in the comments what you like / dislike.

Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

Bloc

Download

Blockzorz

Download

Falling in Pieces

Download

Tetris with a Twist

Download

Yage

Download

Zeetrix

Download

The Humble Indie Bundle

Tim Jones — Thu, 06 May 2010 18:09:33 +0000

Check this out. 5 indie games for any price you specify. Games are World of Goo, Aquaria, Gish, Lugaru, and Penumbra. Money goes toward the developers, charity, or EFF (and can be split however you want). Please be a generous giver for this awesome opportunity.

http://www.wolfire.com/humble

P.S.
Time is running out on this bundle – about 5 days left.

Top Gaming Resource Sites

Tim Jones — Wed, 05 May 2010 11:58:20 +0000

A lot of you out there are working on the next “big” game. Often, you’ll find yourself without the necessary resources to finish your game. Usually this means you just plain suck at graphics or audio, and don’t have the skills to pull anything cool together. Here’s my list of top websites to go to if you are need of some resources for your game. Please keep in mind some of these sites can be used for commercial purposes, while others cannot.

Sprites
http://sdb.drshnaps.com/
http://www.spriters-resource.com/
http://opengameart.org/
http://charas-project.net/

Textures
http://mayang.com/textures/
http://www.cgtextures.com/
http://www.morguefile.com/
http://www.turbosquid.com/Textures
http://www.deviantart.com/ (Also might find some sprites here)

Music
http://ocremix.org/

Sound Effects
http://www.soundjay.com/
http://www.a1freesoundeffects.com/

Fonts
http://www.dafont.com/

Even more resources here…

Got a cool website to share? Let us know in the comments.

C++ Tip – Being safe with Pointers

Tim Jones — Wed, 05 May 2010 11:46:34 +0000

Arguably no other area of C++ confuses more people and causes more frustration than pointers. Here’s a few quick tips to keep safe while using them.

Always check pointers

void MyFunc(int* X) {
std::cout << *X; //Bad!
}

void MyFunc(int* X) {
if(!X) return; //Better

std::cout << *X;
}

Always initialize pointers

int* MyPointer; //Bad!

std::cout << *MyPointer; //Potential Boom!

int* MyOtherPointer = NULL; // or, = 0

std::cout << *MyOtherPointer; //Still not good

int* MyLastPointer = NULL;

//Check for a valid pointer!
if(MyLastPointer) {
std::cout << *MyLastPointer; //Good
}

Always free allocated memory

int* X = new int[3];
int* Y = new int;

X[0] = 0;
X[1] = 1;
X[2] = 2;

*Y = 3;

//End of program – BAD!

int* X = new int[3];
int* Y = new int;

X[0] = 0;
X[1] = 1;
X[2] = 2;

*Y = 3;

delete [] X; //Note the []
delete Y; //Note no []

//Even better
int* X = new int[3];
int* Y = new int;

if(X) {
X[0] = 0;
X[1] = 1;
X[2] = 2;
}

if(Y) {
*Y = 3;
}

if(X) delete [] X;
if(Y) delete Y;

Welcome to GSoC 2010!

Tim Jones — Sat, 01 May 2010 20:06:42 +0000

Official SDL Announcement:

We had some amazing applicants for this year’s Google Summer of Code, and I would like to thank everyone who applied. It was very difficult to narrow down the final list, but in the end we picked 5 excellent students for this year’s project.

I’d like to introduce them and invite everyone to welcome them to the SDL community!

Introducing the Students:

* Daniel Wyatt is working on the Windows IME implementation, working with Jiang (a GSoC student from last year) to update the API and build working Japanese input support. I will be mentoring Danial and coordinating his collaboration with Jiang. You can find out more
about his project at:
http://socghop.appspot.com/gsoc/student_project/show/google/gsoc2010/sdl/t127230762719

* Eli Gottlieb is working on shaped window support for Linux, Mac OS X, and Windows. He will be mentored by Andreas Schiffler, who has
actually implemented shaped window support for commercial SDL projects. You can find out more about his project at:
http://socghop.appspot.com/gsoc/student_project/show/google/gsoc2010/sdl/t127230762740

* Jim Grandpre is working on adding support for multi-touch devices and developing a complete gesture recognition framework. He will be mentored by Ryan Gordon, who among many other things, is working on porting games to the iPad. You can find out more about his project at:
http://socghop.appspot.com/gsoc/student_project/show/google/gsoc2010/sdl/t127230762583

* Paul Hunkin is working on an official port of SDL 1.3 to the Android. I will be mentoring him and testing his code on my development Google Ion. You can find out more about his project at:
http://socghop.appspot.com/gsoc/student_project/show/google/gsoc2010/sdl/t127230762779

* Sunny Sachanandani is working on integrating X11 XRender support into SDL 1.3, with support for hardware accelerated blending and more.
I will be mentoring him and testing his code on a variety of Linux distributions. You can find out more about his project at:
http://socghop.appspot.com/gsoc/student_project/show/google/gsoc2010/sdl/t127230762857

Introducing the Mentors:

* Andreas Schiffler is an architect/dev for a commercial SDL based windows+linux application with shaped-window support. He is volunteering as a mentor this year to help Eli with his project.

* Ryan Gordon is a long time friend and SDL developer, and is currently rewriting the SDL multi-mouse support. He will be mentoring Jim on his touch input project this year.

* I am the original author of SDL and founder of Galaxy Gameworks LLC, a small company devoted to commercial development and support of
SDL 1.3 and beyond. I am looking forward to mentoring Daniel, Paul, and Sunny.

Welcome!
–
-Sam Lantinga, Founder and President, Galaxy Gameworks LLC