Sebenarnya saya kurang mengerti di OpenGL, tapi mungkin ini akan berguna untuk master2 OpenGL disini
Tutorialnya terlampir di dalam Source, Silahkan di terjemahkan sendiri yak

Source :
/*
  This is a simple tutorial on basic Counter-Strike hacking.. Everything I talk about here
  will be based on OpenGL hooking... OpenGL is where 75% of all thing's will be done at
  for Counter-Strike.. Well, everything that has to do with the textures(wallhacks, wireframes,
  etc..etc.. Everything(mostly everything) that has to do with walls with be done in the glBegin
  section.. So lets start this...

*/

/*

  Key Terms used in this tutorial:

  glDisable(); -> Will disable whatever you place in the ().. Think of it almost like Pointer, meaning that
  whatever is placed in the () will be destroyed...

  glEnable(); -> Will enable whatever you place in the ().. Think of it almost like a Pointer, meaing that
  whatever is placed in the () will be enabled and not destroyed, like glDisable...

  glBlendFunc(); -> Will blend any two functions you choose... Transparency is is best implemented using blend function 
  (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) with primitives sorted from farthest to nearest...

*/

/*

  Useful glBlendFunc() functions...

  GL_ZERO
  GL_ONE
  GL_SRC_COLOR
  GL_ONE_MINUS_DST_COLOR
  GL_DST_COLOR
  GL_SRC_ALPHA
  GL_ONE_MINUS_SRC_COLOR
  GL_ONE_MINUS_SRC_ALPHA
  GL_DST_ALPHA
  GL_ONE_MINUS_DST_ALPHA
  GL_SRC_ALPHA_SATURATE


  Also note these modes need to be called in "pairs": i.e -> (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) after calling
  the glBlendFunc function...

*/

/*

  Useful GLenum Mode Shapes...

  GL_LINES
  GL_POINTS
  GL_LINE_STRIP
  GL_LINE_LOOP
  GL_TRIANGLES
  GL_TRIANGLE_STRIP
  GL_TRIANGLE_FAN
  GL_QUADS
  GL_QUAD_STRIP
  GL_POLYGON

  Also note, these "Modes" can only be called where the GLenum Mode is called: i.e -> void sys_glBegin(GLenum "mode")

*/

/*

  GL_DEPTH_TEST explanation:

  The depth buffer contains a value for every pixel on the screen. This value is in the range [0,1].
  This represents the distance between the object and the viewer. Every coordinate has an associated depth value.
  When two depth values are compared, the lower of the two values will appear on the screen. A coordinate that is
  in front of another will have a lower depth value.

  I said that the lower the depth value, the closer the coordinate is to the viewer. This can be changed by using the
  glDepthFunc function. This function specifies how values in the depth buffer will be compared. The values that can be
  passed onto the function are given below:

  GL_NEVER
  GL_LESS
  GL_EQUAL
  GL_LEQUAL
  GL_GREATER
  GL_NOTEQUAL
  GL_GEQUAL
  GL_ALWAYS

*/



/*

  Go down to glBegin... This is probably the most underrated part in OpenGL hooking since a good
  part of your 1st working hack will be done here...

*/


//Your hack will most likely have something to the similiar:

void sys_glBegin(GLenum mode)
{
(*orig_glBegin) (mode);
}

/*

  This is where almost everything will be hooked through for this segment of the tutorial.. The modes I stated
  above will go here... Simply disable any of the functions used for mode:

  if(mode==GL_TRIANGLE) -> This means if function calls that specific mode you called...
  {
  glDisable(GL_DEPTH_TEST); -> To Simply disable it from being drawn...
  }


*/

void sys_glBegin(GLenum mode)
{
if(mode==GL_TRIANGLES)
{
glDisable(GL_DEPTH_TEST);
}

(*orig_glBegin) (mode);
}

/*

  Now, if you want to get complicated.. Try adding simple booleans... Bools declare either two things..
  Something being true(on) or false(off)... So, lets implement that below...

*/

void sys_glBegin(GLenum mode)
{
if(wallhack)
{
if(mode==GL_TRIANGLES)
{
glDisable(GL_DEPTH_TEST);
}
}

(*orig_glBegin) (mode);
}

/*

  That tells the hack, hey, if the bool for wallhack is set to true, then lets do what we have to do and simply
  disable every function that calls a Triangle...

  Booleans will look something like this until we get further later on and start using menu's for toggling...

  bool wallhack = true; -> That tells the hack, hey, the bool for the wallhack code below is true, so lets do what
  there telling me to do in glBegin...

*/

/*

  Now, since weve got our feet wet there, let's get into something a bit deeper... Let's try out some other neat
  things... But before we dive too deep.. Let's go over the glClear function... glClear is a great function, meaning
  that it will clear the screen when called correctly of all that unwanted and unneeded blurness you seem to get
  when doing things like a wireframe or a wallhack... Let's head down to our glClear section and add something to
  stop all that unwanted mess..

*/

//Your glClear should look something like the following:

void sys_glClear(GLbitfield mask)
{
(*orig_glClear)(mask); 
}

//This is where we are going to stop all that mess and stop blending of textures to occur

void sys_glClear(GLbitfield mask)
{
if(mask == GL_DEPTH_BUFFER_BIT)
{
mask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
}

(*orig_glClear)(mask); 
}

//That will make sure nothing blends resulting in not leaving your eyes in pain =P


/*

  Now lets head back up to the glBegin part and start messing with some other things.. We will add a simple wireframe..
  Remember, bool wireframe = true;...It doesnt have to be wireframe, the bool name can be whatever you like, however,
  it is easier to keep up with things when named proplerly..

*/

void sys_glBegin(GLenum mode)
{
if (wireframe)
{
if (mode==GL_POLYGON) //If mode is a polygon, then lets draw an outline over it...
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); //Draws a line over all the Polygon functions..
glLineWidth(3.0); // Sets the width of the line, the lower the #, the less wide it is...
glColor3f(255,255,255); //Sets the color of the RGB... 255,255,255 is black by default
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // If there isnt anything there, just fill it like normal..
}
}

(*orig_glBegin) (mode);
}


/*

  Now, we have a wallhack and wireframe.. Lets try adding a wireframe to our people.. Now, lets create our bool for this:
  bool wiremodels = true;

*/

void sys_glBegin(GLenum mode)
{
if(wiremodels)
{
if(mode==GL_TRIANGLE_STRIP||mode==GL_TRIANGLE_FAN)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glLineWidth(3.0);
glColor3f(255,255,255);
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
}

(*orig_glBegin) (mode);
}


/*

  Well, thats the end of this tutorial.. Have fun finding out new things... Remember, the bools are called at the top
  of your project under all the #includes... [JAPS-t]MrsSmith, use this wisely.. Now you have no reason to be ripping..
  I will write a few more of these later after you get the grasp of coding... And please dont rip/copy/paste this...
  Until then, later everyone...

  DoraTehExploda

*/