Jump to content
  • Advertisement
Sign in to follow this  
VitaliBR

OpenGL Texture in all?

This topic is 2997 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

I have a very strange error, I looked on google and here on GameDev about on it. But unsuccessfully.

When I start loading a texture (. Tag), before you even apply in a polygon (GL_QUADS), this texture is already applied to it by the coordinates passed (glTexCoord2f) and modify the colors of other polygons.

tgaload.h

/* Definitions for bitflags */
typedef unsigned int tgaFLAG;

#define TGA_DEFAULT 0x0000000000000000 /* In case we don't want any parameters */
#define TGA_FREE 0x0000000000000001 /* Bit flag 0 */
#define TGA_NO_PASS 0x0000000000000010 /* Bit flag 1 */
#define TGA_ALPHA 0x0000000000000100 /* Bit flag 2 */
#define TGA_LUMINANCE 0x0000000000001000 /* Bit flag 3 */
#define TGA_NO_MIPMAPS 0x0000000000010000 /* Bit flag 4 */
#define TGA_LOW_QUALITY 0x0000000000100000 /* Bit flag 5 */
#define TGA_COMPRESS 0x0000000001000000 /* Bit flag 6 */


/*
** GL_ARB_texture_compression
**
** Support:
** GeForce
** Radeon
** ???? <- Any suggestions?
*/

#ifndef GL_ARB_texture_compression
#define GL_ARB_texture_compression 1

#define GL_COMPRESSED_ALPHA_ARB 0x84E9
#define GL_COMPRESSED_LUMINANCE_ARB 0x84EA
#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
#define GL_COMPRESSED_INTENSITY_ARB 0x84EC
#define GL_COMPRESSED_RGB_ARB 0x84ED
#define GL_COMPRESSED_RGBA_ARB 0x84EE
#define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF
#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0
#define GL_TEXTURE_COMPRESSED_ARB 0x86A1
#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3

typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)(GLenum target, GLint level,
GLenum internalFormat, GLsizei width,
GLsizei height, GLsizei depth,
GLint border, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)(GLenum target, GLint level,
GLenum internalFormat, GLsizei width,
GLsizei height, GLint border,
GLsizei imageSize, const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)(GLenum target, GLint level,
GLenum internalFormat, GLsizei width,
GLint border, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)(GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLint zoffset, GLsizei width,
GLsizei height, GLsizei depth,
GLenum format, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)(GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height,
GLenum format, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)(GLenum target, GLint level,
GLint xoffset, GLsizei width,
GLenum format, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)(GLenum target, GLint lod,
GLvoid *img);


#endif /* GL_ARB_texture_compression */



typedef struct {
unsigned char id_length;
unsigned char colour_map_type;
unsigned char image_type;

// colourmap spec. 5 bytes
short int colour_map_first_entry; // Ignore
short int colour_map_length; // Usually 256
unsigned char colour_map_entry_size; // Usually 24-bit

// image spec. 10 bytes
short int x_origin; // Ignore
short int y_origin; // Ignore
short int width;
short int height;
unsigned char pixel_depth; // Usually 24 or 32
unsigned char image_descriptor; // Ignore

// Added for 'compeletness' :)
int components;
int bytes;

GLenum tgaColourType;

} tgaHeader_t;


typedef struct {
tgaHeader_t info;
unsigned char *data; /* Image data */
} image_t;


/* 'Public' functions */
void tgaLoad ( char *file_name, image_t *p, tgaFLAG mode );
GLuint tgaLoadAndBind ( char *file_name, tgaFLAG mode );

void tgaSetTexParams ( unsigned int min_filter, unsigned int mag_filter, unsigned int application );

void tgaFree ( image_t *p );







tgaload.cpp

/*
...

From: http://nehe.gamedev.net

Aug 19th:
Added support for runlength encoding - changed some stuff around to make this
possible. Works well :)

Sept 7th:
Improved error trapping and recovery.

Oct 22nd:
Major source clearout & Can compress the image using S3_TC algorithm if the
driver supports it.

Nov 10th:
'Settled' version of the code - traps for nearly all errors - added a
LoadAndBind function for even lazier people :)
TGA_NO_PASS was added in case you need to load an image and pass it yourself.
Finally exorcised all the paletted texture code...
*/


#include <windows.h>
#include <GL\glu.h>
#include <stdio.h>
#include <stdlib.h>
#include "tgaload.h"

/* Extension Management */
PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB = NULL;
PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB = NULL;

/* Default support - lets be optimistic! */
bool tgaCompressedTexSupport = true;


void tgaGetExtensions ( void )
{
glCompressedTexImage2DARB = ( PFNGLCOMPRESSEDTEXIMAGE2DARBPROC )
wglGetProcAddress ( "glCompressedTexImage2DARB" );
glGetCompressedTexImageARB = ( PFNGLGETCOMPRESSEDTEXIMAGEARBPROC )
wglGetProcAddress ( "glGetCompressedTexImageARB" );

if ( glCompressedTexImage2DARB == NULL || glGetCompressedTexImageARB == NULL )
tgaCompressedTexSupport = false;
}


void tgaSetTexParams ( unsigned int min_filter, unsigned int mag_filter, unsigned int application )
{
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter );

glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, application );
}


unsigned char *tgaAllocMem ( tgaHeader_t info )
{
unsigned char *block;

block = (unsigned char*) malloc ( info.bytes );

if ( block == NULL )
return 0;

memset ( block, 0x00, info.bytes );

return block;
}

void tgaPutPacketTuples ( image_t *p, unsigned char *temp_colour, int &current_byte )
{
if ( p->info.components == 3 )
{
p->data[current_byte] = temp_colour[2];
p->data[current_byte+1] = temp_colour[1];
p->data[current_byte+2] = temp_colour[0];
current_byte += 3;
}

if ( p->info.components == 4 ) // Because its BGR(A) not (A)BGR :(
{
p->data[current_byte] = temp_colour[2];
p->data[current_byte+1] = temp_colour[1];
p->data[current_byte+2] = temp_colour[0];
p->data[current_byte+3] = temp_colour[3];
current_byte += 4;
}
}


void tgaGetAPacket ( int &current_byte, image_t *p, FILE *file )
{
unsigned char packet_header;
int run_length;
unsigned char temp_colour[4] = { 0x00, 0x00, 0x00, 0x00 };

fread ( &packet_header, ( sizeof ( unsigned char )), 1, file );
run_length = ( packet_header&0x7F ) + 1;

if ( packet_header&0x80 ) // RLE packet
{
fread ( temp_colour, ( sizeof ( unsigned char )* p->info.components ), 1, file );

if ( p->info.components == 1 ) // Special optimised case :)
{
memset ( p->data + current_byte, temp_colour[0], run_length );
current_byte += run_length;
} else
for ( int i = 0; i < run_length; i++ )
tgaPutPacketTuples ( p, temp_colour, current_byte );
}

if ( !( packet_header&0x80 )) // RAW packet
{
for ( int i = 0; i < run_length; i++ )
{
fread ( temp_colour, ( sizeof ( unsigned char )* p->info.components ), 1, file );

if ( p->info.components == 1 )
{
memset ( p->data + current_byte, temp_colour[0], run_length );
current_byte += run_length;
} else
tgaPutPacketTuples ( p, temp_colour, current_byte );
}
}
}


void tgaGetPackets ( image_t *p, FILE *file )
{
int current_byte = 0;

while ( current_byte < p->info.bytes )
tgaGetAPacket ( current_byte, p, file );
}


void tgaGetImageData ( image_t *p, FILE *file )
{
unsigned char temp;

p->data = tgaAllocMem ( p->info );

/* Easy unRLE image */
if ( p->info.image_type == 1 || p->info.image_type == 2 || p->info.image_type == 3 )
{
fread ( p->data, sizeof (unsigned char), p->info.bytes, file );

/* Image is stored as BGR(A), make it RGB(A) */
for (int i = 0; i < p->info.bytes; i += p->info.components )
{
temp = p->data;
p->data = p->data[i + 2];
p->data[i + 2] = temp;
}
}

/* RLE compressed image */
if ( p->info.image_type == 9 || p->info.image_type == 10 )
tgaGetPackets ( p, file );
}


void tgaUploadImage ( image_t *p, tgaFLAG mode )
{
/* Determine TGA_LOWQUALITY internal format
This directs OpenGL to upload the textures at half the bit
precision - saving memory
*/

GLenum internal_format = p->info.tgaColourType;

if ( mode&TGA_LOW_QUALITY )
{
switch ( p->info.tgaColourType )
{
case GL_RGB : internal_format = GL_RGB4; break;
case GL_RGBA : internal_format = GL_RGBA4; break;
case GL_LUMINANCE : internal_format = GL_LUMINANCE4; break;
case GL_ALPHA : internal_format = GL_ALPHA4; break;
}
}

/* Let OpenGL decide what the best compressed format is each case. */
if ( mode&TGA_COMPRESS && tgaCompressedTexSupport )
{
switch ( p->info.tgaColourType )
{
case GL_RGB : internal_format = GL_COMPRESSED_RGB_ARB; break;
case GL_RGBA : internal_format = GL_COMPRESSED_RGBA_ARB; break;
case GL_LUMINANCE : internal_format = GL_COMPRESSED_LUMINANCE_ARB; break;
case GL_ALPHA : internal_format = GL_COMPRESSED_ALPHA_ARB; break;
}
}

/* Pass OpenGL Texture Image */
if ( !( mode&TGA_NO_MIPMAPS ))
gluBuild2DMipmaps ( GL_TEXTURE_2D, internal_format, p->info.width,
p->info.height, p->info.tgaColourType, GL_UNSIGNED_BYTE, p->data );
else
glTexImage2D ( GL_TEXTURE_2D, 0, internal_format, p->info.width,
p->info.height, 0, p->info.tgaColourType, GL_UNSIGNED_BYTE, p->data );
}


void tgaFree ( image_t *p )
{
if ( p->data != NULL )
free ( p->data );
}


void tgaChecker ( image_t *p )
{
unsigned char TGA_CHECKER[16384];
unsigned char *pointer;

// 8bit image
p->info.image_type = 3;

p->info.width = 128;
p->info.height = 128;

p->info.pixel_depth = 8;

// Set some stats
p->info.components = 1;
p->info.bytes = p->info.width * p->info.height * p->info.components;

pointer = TGA_CHECKER;

for ( int j = 0; j < 128; j++ )
{
for ( int i = 0; i < 128; i++ )
{
if ((i ^ j) & 0x10 )
pointer[0] = 0x00;
else
pointer[0] = 0xff;
pointer ++;
}
}

p->data = TGA_CHECKER;

glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE4, p->info.width,
p->info.height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, p->data );

/* Should we free? I dunno. The scope of TGA_CHECKER _should_ be local, so it
probably gets destroyed automatically when the function completes... */

// tgaFree ( p );
}


void tgaError ( char *error_string, char *file_name, FILE *file, image_t *p )
{
printf ( "%s - %s\n", error_string, file_name );
tgaFree ( p );

fclose ( file );

tgaChecker ( p );
}


void tgaGetImageHeader ( FILE *file, tgaHeader_t *info )
{
/* Stupid byte alignment means that we have to fread each field
individually. I tried splitting tgaHeader into 3 structures, no matter
how you arrange them, colour_map_entry_size comes out as 2 bytes instead
1 as it should be. Grrr. Gotta love optimising compilers - theres a pragma
for Borland, but I dunno the number for MSVC or GCC :(
*/

fread ( &info->id_length, ( sizeof (unsigned char )), 1, file );
fread ( &info->colour_map_type, ( sizeof (unsigned char )), 1, file );
fread ( &info->image_type, ( sizeof (unsigned char )), 1, file );

fread ( &info->colour_map_first_entry, ( sizeof (short int )), 1, file );
fread ( &info->colour_map_length , ( sizeof (short int )), 1, file );
fread ( &info->colour_map_entry_size , ( sizeof (unsigned char )), 1, file );

fread ( &info->x_origin , ( sizeof (short int )), 1, file );
fread ( &info->y_origin , ( sizeof (short int )), 1, file );
fread ( &info->width, ( sizeof (short int )), 1, file );
fread ( &info->height, ( sizeof (short int )), 1, file );

fread ( &info->pixel_depth, ( sizeof (unsigned char )), 1, file );
fread ( &info->image_descriptor,( sizeof (unsigned char )), 1, file );

// Set some stats
info->components = info->pixel_depth / 8;
info->bytes = info->width * info->height * info->components;
}

int tgaLoadTheImage ( char *file_name, image_t *p, tgaFLAG mode )
{
FILE *file;

tgaGetExtensions ( );

p->data = NULL;

if (( file = fopen ( file_name, "rb" )) == NULL )
{
tgaError ( "File not found", file_name, file, p );
return 0;
}

tgaGetImageHeader ( file, &p->info );

switch ( p->info.image_type )
{
case 1 :
tgaError ( "8-bit colour no longer supported", file_name, file, p );
return 0;

case 2 :
if ( p->info.pixel_depth == 24 )
p->info.tgaColourType = GL_RGB;
else if ( p->info.pixel_depth == 32 )
p->info.tgaColourType = GL_RGBA;
else
{
tgaError ( "Unsupported RGB format", file_name, file, p );
return 0;
}
break;

case 3 :
if ( mode&TGA_LUMINANCE )
p->info.tgaColourType = GL_LUMINANCE;
else if ( mode&TGA_ALPHA )
p->info.tgaColourType = GL_ALPHA;
else
{
tgaError ( "Must be LUMINANCE or ALPHA greyscale", file_name, file, p );
return 0;
}
break;

case 9 :
tgaError ( "8-bit colour no longer supported", file_name, file, p );
return 0;

case 10 :
if ( p->info.pixel_depth == 24 )
p->info.tgaColourType = GL_RGB;
else if ( p->info.pixel_depth == 32 )
p->info.tgaColourType = GL_RGBA;
else
{
tgaError ( "Unsupported compressed RGB format", file_name, file, p );
return 0;
}
}

tgaGetImageData ( p, file );

fclose ( file );

return 1;
}

void tgaLoad ( char *file_name, image_t *p, tgaFLAG mode )
{
if ( tgaLoadTheImage ( file_name, p, mode ))
{
if ( !( mode&TGA_NO_PASS ))
tgaUploadImage ( p, mode );

if ( mode&TGA_FREE )
tgaFree ( p );
}

}

GLuint tgaLoadAndBind ( char *file_name, tgaFLAG mode )
{
GLuint texture_id;
image_t *p;

glGenTextures ( 1, &texture_id );
glBindTexture ( GL_TEXTURE_2D, texture_id );

if ( tgaLoadTheImage ( file_name, p, mode ))
{
tgaUploadImage ( p, mode );
tgaFree ( p );
}

return texture_id;
}








Part of the main code responsible for loading the texture:

#define MAX_NO_TEXTURES 1
#define TEXTURE_FPS 0
// vector with the numbers of textures
GLuint texture_id[MAX_NO_TEXTURES];

void World::setup()
{

//===================================================================
// Load Texture
//===================================================================
image_t temp_image; // variable that will store the texture to be used

// Enables the use of texture
glEnable ( GL_TEXTURE_2D );

// Defines how to store the pixels in texture (1 = byte-alignment)
glPixelStorei ( GL_UNPACK_ALIGNMENT, 1 );

// Define quantas texturas serão usadas no programa
glGenTextures (1, texture_id); // 1 = one texture
// texture_id = vector that guards the numbers of textures

//Sets the numbers of the texture
texture_id[TEXTURE_FPS] = 1;

// ****
// Sets the texture
// ****

// Defines what type of texture will be used
// GL_TEXTURE_2D ==> that defines a 2D texture is used (bitmaps)
// texture_id[TEXTURE_FPS] ==> define the number of texture
glBindTexture ( GL_TEXTURE_2D, texture_id[TEXTURE_FPS] );
// Load the image .TGA
tgaLoad ( "fps.tga", &temp_image, TGA_FREE | TGA_LOW_QUALITY );

}






main game loop:
    try
{
game->setup(); //Here init texture
while (!game->ended())
{

processEvents(game);
game->processLogics();
game->draw();

SDL_GL_SwapBuffers();

}

}






The texture should be applied when it was called:
glBindTexture ( GL_TEXTURE_2D, 1 ); // define texture 1 to use






Exemple:
    //
// Polygon
//
glPushMatrix();
glScalef(0.1,0.2,0.0);
glColor3f(1.0,1.0,1.0);
glBindTexture ( GL_TEXTURE_2D, 1 ); // HERE!! define texture 1 to use
glBegin(GL_QUADS); // Draw A Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 0.0f);// Top Left
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 0.0f);// Top Right
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,-1.0f, 0.0f);// Bottom Right
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,-1.0f, 0.0f);// Bottom Left
glEnd(); // Done Drawing The Quad
glPopMatrix();






But even without calling the function to apply the texture, it is applied to it and leaving the other strange polygons


Only the polygon in the middle of the screen that should receive the texture
After

If I remove the code that loads the texture, it back to normal

Normal

Thus we note that there was a change in all polygons drawn on the screen (which should not happen)

Thanks!

Share this post


Link to post
Share on other sites
Advertisement
openGL is a state machine. There's no such thing as applying texture.
You enable texturing, thus everything (points, lines, quads, everything) will be textured.
If you disable texturing, nothing will be textured.
If you bind a texture (what you refer as "applying") that texture will be active: that particular texture will be "applied" to everything, until another texture is bound. So if you have only one texture, you don't have to bind it over and over again.

Texture settings (every settings) apply to the currently bound texture.

This state machine thing applies to pretty much everything in openGL. Texture coordinates too. So texture coordinates are always valid, and the values are always the values set last time. That's why you have to call it before the glVertex calls.

The same applies to color, blending, fog, almost everything.

I hope that helps.

Share this post


Link to post
Share on other sites
Thanks szecs, I understand your explanation.

In short, I will not be able to apply the texture only to a polygon?
Leaving the rest without texture?

Sorry for the stubbornness :)

Thanks

I looked at your videos on youtube, great job! congratulations!
Regarding the "Tank simulator openGL demo III" as you did to show the fps onscreen?
I have an fps counter, but do not know how to show it. I'm using Opengl (and SDL for window-manager and control of events)

Share this post


Link to post
Share on other sites
Um.., you haven't understood the explanation...
Maybe this:
"openGL is a state machine. There's no such thing as applying texture.
You enable texturing, thus everything (points, lines, quads, everything) will be textured."
Is a bit fishy. Sorry, I'm not a native speaker, and I1m sleepy, I can't express it better...

glEnable(GL_TEXTURE_2D);
draw_that_you_want_to_be_textured();
glDisable(GL_TEXTURE_2D);
draw_untextured_stuff();

Thanks for you comment on the demos.

FPS counter: look into "render text" or "render fonts" it's a pretty commonly asked question here.

Share this post


Link to post
Share on other sites
szecs thanks!


As for your demo, it is very professional! I hope to get there someday!


[Edited by - VitaliBR on July 8, 2010 9:04:06 PM]

Share this post


Link to post
Share on other sites
Quote:
Original post by VitaliBR
szecs thanks!

as you can not see? lol
sorry!


As for your demo, it is very professional! I hope to get there someday!

Hugs


Um... What?

There's nothing to hope on it. It's a pretty demo, and pretty useless (it's not a big deal to throw some effects and physics, I never did the real and hard stuff). You will get there probably soon.

Share this post


Link to post
Share on other sites
Quote:
Original post by szecs
Quote:
Original post by VitaliBR
szecs thanks!

as you can not see? lol
sorry!


As for your demo, it is very professional! I hope to get there someday!

Hugs


Um... What?

There's nothing to hope on it. It's a pretty demo, and pretty useless (it's not a big deal to throw some effects and physics, I never did the real and hard stuff). You will get there probably soon.


Okay, I'm gone to sleep [grin]

Share this post


Link to post
Share on other sites
#define TGA_DEFAULT 0x0000000000000000 /* In case we don't want any parameters */
#define TGA_FREE 0x0000000000000001 /* Bit flag 0 */
#define TGA_NO_PASS 0x0000000000000010 /* Bit flag 1 */
#define TGA_ALPHA 0x0000000000000100 /* Bit flag 2 */


These defines are not correct. You don't address single bits because it's a hexadecimal formatting. That means 0x0000000000000010 is not bit 1, it's bit 5.

Use (1<<0), (1<<1), (1<<2) etc. to address bits.

Share this post


Link to post
Share on other sites
Quote:
Original post by Clausomat
#define TGA_DEFAULT 0x0000000000000000 /* In case we don't want any parameters */
#define TGA_FREE 0x0000000000000001 /* Bit flag 0 */
#define TGA_NO_PASS 0x0000000000000010 /* Bit flag 1 */
#define TGA_ALPHA 0x0000000000000100 /* Bit flag 2 */


These defines are not correct. You don't address single bits because it's a hexadecimal formatting. That means 0x0000000000000010 is not bit 1, it's bit 5.

Use (1<<0), (1<<1), (1<<2) etc. to address bits.


Sorry, I didn't understand

Thanks szecs, I solved the problem

Normal

:D

how to show FPS on screen, I found an interesting GLFT_font lib. if someone already used it and can tell if it's good


EDIT:

I link the librarie FreeType in my project to use the GLFT, But at compile, appears the following errors:

D:\...\GLFT_Font.cpp||In member function 'void GLFT_Font::open(const std::string&, unsigned int)':|
D:\...\GLFT_Font.cpp|165|error: 'memset' is not a member of 'std'|
D:\...\GLFT_Font.cpp||In member function 'void GLFT_Font::drawText(float, float, const char*, ...) const':|
D:\...\GLFT_Font.cpp|270|error: 'vsnprintf' is not a member of 'std'|
D:\...\GLFT_Font.cpp|276|error: 'strlen' is not a member of 'std'|
||=== Build finished: 3 errors, 0 warnings ===|



[Edited by - VitaliBR on July 8, 2010 8:37:22 PM]

Share this post


Link to post
Share on other sites
To be honest, I don't understand Clausomat either.

Start a new thread with fonts. I use the NEHE method. Look NEHE up.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!