Jump to content
  • Advertisement
Sign in to follow this  
  • entries
    8
  • comments
    6
  • views
    7505

Starting my new project

Sign in to follow this  
evillive2

293 views

Well, a few days ago I started looking into moving into OpenGL for 2d stuff again. I took about a whole day of fiddling around with stuff and I got a good start thanks to using the hxRender library by PnP Bios. Now I want to move on and make an SDL like library for my own knowledge as well as hopefully give something back to the community as well. The main thing i am looking for now is how to render to a specific texture instead of the screen and how to switch back and forth. Otherwise the SDL like functions of specifying a destination to blit to won't quite feel right. I suppose that is my own opinion but ow well...

Here is a quick look at the header for the library. I haven't written any actual code yet since most of my time has been spent researching how to do most of these tasks. I still don't know how to change a colorkey value for a texture or if it is even possible and the rotation thing is kind of giving me a headache with the pushing and popping matrix thing which I don't even know if it is necessary yet.

Well, here it is so far.


/***************************************************************************
* GL2D_defs.h *
* *
* GL2D #define macros *
* type defines for using the GL2D library *
* prototypes for library functions *
* *
***************************************************************************/


// for the most part functions with a return value that isn't a pointer
// return 0 for success and -1 if a failure occured
// use these macros as -1 will be true and 0 will be false on most machines
#define GL2D_ERROR -1
#define GL2D_SUCCESS 0

// an easy way to check if functions failed or not
#define GL2D_OK(val) ( (val)==GL2D_SUCCESS ? TRUE : FALSE )

// GL2D's version of a color
// almost the same as SDL :)
typedef struct GL2D_COLOR
{
unsigned char red;
unsigned char green;
unsigned char blue;
unsigned char alpha;
};

// GL2D's version of a rectangle with integer
// will be used in some API blit functions
// to resemble SDL_Blit*
typedef struct GL2D_RECTI
{
GLint x;
GLint y;
GLuint w;
GLuint h;
};

// GL2D's version of a rectangle with floating point values
// for better translation by opengl.
// will be used in some API blit functions
// to resemble SDL_Blit*
typedef struct GL2D_RECTF
{
float x;
float y;
float w;
float h;
};

// GL2D version of a vertex
typedef struct GL2D_VERTEX
{
float x;
float y;
};

// if it helps to name it differently:
typedef GL2D_VERTEX GL2D_POINT;

// GL2D structure to hold 4 verticies making up a quad
typedef struct GL2D_QUAD
{
GL2D_VERTEX v0;
GL2D_VERTEX v1;
GL2D_VERTEX v2;
GL2D_VERTEX v3;
};

// GL2D's version of an SDL surface.
// Since surfaces have some large differences
// from OpenGL textures I am sure this will
// operate differently than most people are used to but
// the purpose of this library is to hide the 3d bs from
// the user so I won't go into too much detail.
typedef struct GL2D_SURFACE
{
GLuint texture_id; // the texture id of the surface
GLuint width; // the width in pixels of the surface
GLuint height; // the height in pixels of the surface
GLuint bpp; // the bits per pixel of the surface
GLuint pitch; // the pitch of the surface (the actual width of a scanline in memory)
GLuint colors; // number of colors in the palette ( 0 if bpp > 8 )
void *palette; // pointer to the palette colors ( NULL if bpp > 8 )
void *pixeldata; // pointer to raw pixel data of the surface
};


// lirary startup/quit functions
GLint GL2D_Init(); // init GL2D - not sure if this will be necessary
GLint GL2D_Quit(); // exit GL2D - or if they will wrap regular SDL_Init and Quit

// init the video surface
// the return value isn't very useful since rendering functions in OpenGL
// do not require a destination surface/texture to render. The screen is the
// default render target.
GL2D_SURFACE *GL2D_SetVideoMode( GLuint width, GLuint height GLuint bpp, GLboolean fullscreen );

// Surface creation
GL2D_SURFACE *GL2D_CreateRGBSurface( GLuint width, GLuint height, GLuint bpp );
GL2D_SURFACE *GL2D_CreateRGBSurfaceFrom( void *pixeldata, GLuint width, GLuint height, GLuint bpp );
GL2D_SURFACE *GL2D_LoadBMP( char *bitmap );

// free a GL2D_SURFACE from memory
void GL2D_FreeSurface( GL2D_SURFACE *surface );

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// pixel and primitives drawing functions
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// pixel functions
GLint GL2D_GetPixel( GL2D_SURFACE *surface, GLuint x, GLuint y, GL2D_COLOR *pixel );
GLint GL2D_SetPixel( GL2D_SURFACE *surface, GLuint x, GLuint y, GL2D_COLOR *pixel );
// line function
GLint GL2D_DrawLine( GL2D_SURFACE *surface, GL2D_VERTEX *start, GL2D_VERTEX *end, GL2D_COLOR *color );
GLint GL2D_DrawLine( GL2D_SURFACE *surface, GLuint x1, GLuint y1, GLuint x2, GLuint y2, GL2D_COLOR *color );
GLint GL2D_DrawLine( GL2D_SURFACE *surface, float x1, float y1, float x2, float y2, GL2D_COLOR *color );
// rectangle functions
GLint GL2D_DrawRect( GL2D_SURFACE *surface, GL2D_RECTI *rect, GL2D_COLOR *color );
GLint GL2D_FillRect( GL2D_SURFACE *surface, GL2D_RECTI *rect, GL2D_COLOR *color );
// circle functions
// no idea how to do this in a good way other than points or as a polygon
/*
GLint GL2D_DrawCircle( GL2D_SURFACE *surface, float origin_x, float origin_y, float radius, GL2D_COLOR *color );
GLint GL2D_FillCircle( GL2D_SURFACE *surface, float origin_x, float origin_y, float radius, GL2D_COLOR *color );
*/

// polygon functions
GLint GL2D_DrawPolygon( GL2D_SURFACE *surface, GL2D_VERTEX *verts, GLuint num_verts, GL2D_COLOR *color );
GLint GL2D_FillPolygon( GL2D_SURFACE *surface, GL2D_VERTEX *verts, GLuint num_verts, GL2D_COLOR *color );

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Blitting functions
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// If the destination quad differs in size from the source quad then scaling is done.
// If the alpha value is less than 1.0 then alpha blending is applied.
// Returns 0 on success and -1 if failure.
GLint GL2D_BlitSurface( GL2D_SURFACE *source_surface, GL2D_QUAD *source_quad, GL2D_SURFACE *destination_surface, GL2D_QUAD *destination_quad, float alpha );
GLint GL2D_BlitSurface( GL2D_SURFACE *source_surface, GL2D_RECTI *source_rect, GL2D_SURFACE *destination_surface, GL2D_RECTI *destination_rect, float alpha );
GLint GL2D_BlitSurface( GL2D_SURFACE *source_surface, GL2D_RECTF *source_rect, GL2D_SURFACE *destination_surface, GL2D_RECTF *destination_rect, float alpha );

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Conversion functions
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
GL2D_QUAD GL2D_RECTF_TO_QUAD( GL2D_RECTF *rect );
GL2D_QUAD GL2D_RECTI_TO_QUAD( GL2D_RECTI *rect );
GL2D_RECTF GL2D_RECTF_TO_QUAD( GL2D_QUAD *quad );
GL2D_RECTI GL2D_RECTI_TO_QUAD( GL2D_QUAD *quad );



I will keep posting stuff here as I continue to work on it. I am planning on keeping the C style functions since both OpenGL and SDL use them but I imagine this stuff should be easy to wrap up into a class or classes of some sort.


Sign in to follow this  


0 Comments


Recommended Comments

There are no comments to display.

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
  • 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!