Du bist nicht angemeldet.

  • Anmelden
  • Registrieren

[TUT] Wallhack XQZ2/Asus/ Wireframe/Solid-Wireframe/WH-Window

suxx-

unregistriert

1

28.06.2004, 17:55

[TUT] Wallhack XQZ2/Asus/ Wireframe/Solid-Wireframe/WH-Window

In diesem Tutorial geht es um die verschiedensten Arten von Wallhacks

Welche Arten werden beschrieben ?


  • XQZ2
  • Asus
  • Wireframe
  • Solid Wireframe
  • WH-Window (my Style)
Nun zur Theorie der einzelnen Wallhacks

XQZ2:
Dies ist der wohl einfachste Wallhack den es gibt, denn er deaktiviert einfach die Tiefenkontrolle der einzelnen Objekte. Dafür überprüfen in glBegin den Modus, wenn der mode == GL_TRIANGLES || mode == GL_TRIANGLE_FAN || mode == GL_TRIANGLE_STRIP dann deaktivieren wir GL_DEPTH_TEST. Eine Altanative bietet die Funktion glShadeModel denn auch dort können wir den GL_DEPTH_TEST deaktivieren was ich bevorzuge.

Asus:
Dieser Wallhack verändert den Alpha-Wert der Wände so dass die Wände transparent werden. Dafür überprüfen wir in glBegin ob der mode == GL_POLYGON && mode != GL_TRIANGLES && mode != GL_TRIANGLE_STRIP && mode != GL_TRIANGLE_FAN und nun aktivieren wir GL_BLEND und deaktivieren den GL_DEPTH_TEST setzten die glBlendFunc Parameter auf GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA und setzten den Alpha-Wert der farbe herrunter. Zum Schluss setzten wir noch bClearbit damit der Buffer gecleard wird.

Wireframe:
Bei diesem Wallhack wird der PolygonMode verändert und zwar von dem standard Wert GL_FILL zu entweder GL_LINE oder GL_POINT. Dies geschieht in glBegin wenn der mode == GL_POLYGON ist. Und auch hier wieder das bClearbit setzten damit der Buffer gecleard wird.

Solid-Wireframe:
Ansich ist dies kein Wallhack er ein Object-Redrawen mit veränderten Parametern demnach ist dies auch sehr Framelastig. In glBegin speichern wir den Mode in einer Structur, in glVertex3f und glVertex3fv speichern wir die Daten ebenfalls in der Structur und zum Ende des Objectes in glEnd() Drawen wir die Daten nochmals jedoch wiegesagt mit veränderten Parametern.

WH-Window:
Dies ist eine eigen Kreation die entstand als ich mit dem Viewport herum experimentiert. Ich Speicher alle PlayerVertex wie in Solid-Wireframe beschrieben jedoch veränder ich den Viewport beim Re-Drawn somit sieht es so aus als entstunde ein neues Fenster und nur in diesem Fenster ist ein XQZ2 Wallhack an. Jedoch Ohne Texturen und nur die Player, Wände usw. werden aus Framegründen nicht Re-Drawed.

XQZ2 - 1:

Quellcode

 
1
2
3
4
5
6

void __stdcall pHooked_glBegin ( GLenum mode )
   {
      if (mode == GL_TRIANGLES || mode == GL_TRIANGLE_FAN || mode == GL_TRIANGLE_STRIP)
             glDisable(GL_DEPTH_TEST);
      glBegin ( mode );
   }


XQZ2 - 2:

Quellcode

 
1
2
3
4
5
6

void __stdcall pHooked_glShadeModel ( GLenum mode )
   {
      if ((cvar.wall == 1) && (mode == GL_SMOOTH))
             glDisable(GL_DEPTH_TEST);
      glBegin ( mode );
   }




Asus:

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void __stdcall pHooked_glBegin ( GLenum mode )
   {
      if (mode==GL_POLYGON)
      {
             if ((mode!=GL_TRIANGLE_STRIP) && (mode!=GL_TRIANGLE_FAN))
             {
                    bClearbit = true;
                    glDisable(GL_DEPTH_TEST);
                    glEnable(GL_BLEND);
                    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                    float asuscolor[4];
                    glGetFloatv(GL_CURRENT_COLOR, asuscolor);
                  glColor4f(asuscolor[0], asuscolor[1], asuscolor[2], 0.5f); // Der letzte Wert ist der Alpha-Wert 
             }
      }
      glBegin ( mode );
   }


WireFrame:

Quellcode

 
1
2
3
4
5
6
7
8
9
10

void __stdcall pHooked_glBegin ( GLenum mode )
   {
      if (mode==GL_POLYGON)
      {
             glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
             glLineWidth(1.0f);
             glColor3f(0.0f,1.0f,0.0f);
      }
      glBegin ( mode );
   }


Solid-Wireframe:

Quellcode

 
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

typedef struct {
           int vertexcount;
           GLenum mode;
           float vbuffer[8192][3];
   } redraw_s;
    
   redraw_s swire;
    
   hooked_glBegin(GLenum mode)
   {
           swire.vertexcount = 0;
           swire.mode = mode;
         if(mode!=GL_QUADS && mode!=GL_TRIANGLES && mode!=GL_TRIANGLE_FAN && mode!=GL_TRIANGLE_STRIP)
           {
                   bClearbit = true;
                   glDisable(GL_TEXTURE_2D);
                   float c[4] = {1,1,1,1};
                   glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, c);
                   glEnable(GL_BLEND);
                   glBlendFunc(GL_ZERO,GL_ONE);
                   glColor4f(0.5,0.5,0.5,1.0);
           }
   }
    
   hooked_glVertex3f (GLfloat x,  GLfloat y,  GLfloat z)
   {
           swire.vbuffer[swire.vertexcount][0] = x;
           swire.vbuffer[swire.vertexcount][1] = y;
           swire.vbuffer[swire.vertexcount][2] = z;        
           swire.vertexcount++;
   }
    
   hooked_glVertex3fv (const GLfloat *v)
   {
           swire.vbuffer[swire.vertexcount][0] = v[0];
           swire.vbuffer[swire.vertexcount][1] = v[1];
           swire.vbuffer[swire.vertexcount][2] = v[2];        
           swire.vertexcount++;
   }
    
   hooked_glEnd (void)
   {
           int i=0;                
   
           if((swire.mode==GL_TRIANGLE_STRIP) || (swire.mode==GL_TRIANGLE_FAN))
           { // Wenn es ein Player ist ...
                   glEnable(GL_BLEND);
                   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
                   if(swire.vertexcount > 0)
                   {
                           glDisable(GL_DEPTH_TEST);
                  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Hier stehen verschiedene Modes zur auswahl GL_POINT, GL_LINE,GL_FILL jedoch zieht GL_FILL viele Frames
                           glLineWidth(1);
                           glDisable(GL_TEXTURE_2D);
                           glBegin(swire.mode);
                           for(i = 0; i < swire.vertexcount;i++))
                           {
                                   glColor4f(0.5, 0.5, 1.0, 0.2);
                                   glVertex3fv(swire.vbuffer[i]);
                           }
                           glEnd();
                           glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                           glEnable(GL_TEXTURE_2D);
                           glEnable(GL_DEPTH_TEST);
                   }
                   glDisable(GL_BLEND);
           }
   
         if((swire.mode!=GL_QUADS) && (swire.mode!=GL_TRIANGLES) && (swire.mode!=GL_TRIANGLE_FAN) && (swire.mode!=GL_TRIANGLE_STRIP))
           { //Wenn es gegenstände sind ... sprich Kisten, Wände oder der Boden
                   glDisable(GL_BLEND);
                   if (swire.vertexcount > 0)
                   {
                           glLineWidth(3);
                  glBegin(GL_LINE_LOOP); // Line_Loop deswegen weil wir ja einen Wireframe-Effekt wünschen
                           for(i=0; i < swire.vertexcount;i++)
                           {
                                   glColor4f(1.0,0.5,0.5,1.0);
                                   glVertex3fv(wire.vbuffer[i]);
                           }
                           glEnd();
                           glEnable(GL_TEXTURE_2D);
                   }
           }
   }


WH-Window:

Quellcode

 
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

typedef struct {
           int vertexcount;
           GLenum mode;
           float vbuffer[8192][3];
   } redraw_s;
    
   redraw_s whwin;
    
   GLint vp[4];
   GLsizei viewport_width;
   GLsizei viewport_height;
   GLint viewport_x;
   GLint viewport_y;
    
   hooked_glBegin(GLenum mode)
   {
           glViewport(viewport_x,viewport_y,viewport_width,viewport_height);
           whwin.vertexcount = 0;
           whwin.mode = mode;
   }
    
   hooked_glVertex3f (GLfloat x,  GLfloat y,  GLfloat z)
   {
           whwin.vbuffer[whwin.vertexcount][0] = x;
           whwin.vbuffer[whwin.vertexcount][1] = y;
           whwin.vbuffer[whwin.vertexcount][2] = z;        
           whwin.vertexcount++;
   }
    
   hooked_glEnd (void)
   {
         glViewport((vp[2]/2)-(vp[2]/4/2),vp[3]-(vp[3]/4),vp[2]/4,vp[3]/4); // Hier setzten wir den neuen Viewport
           
           glEnable(GL_BLEND);
           glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
           if((whwin.mode==GL_TRIANGLE_STRIP) || (whwin.mode==GL_TRIANGLE_FAN))
           {
                   glDisable(GL_DEPTH_TEST);
                   glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                   glLineWidth(1);
                   glPointSize(10.0f);
                 glDisable(GL_TEXTURE_2D); // Hiermit müsst ihr experimentieren wie es euch besser gefällt
                   glBegin(whwin.mode);
                           
                   for(int i = 0; i < whwin.vertexcount;i++)
                   {
                           glColor4f(0.5, 0.5, 1.0, 0.5);
                           glVertex3fv(whwin.vbuffer[i]);
                   }
                   glEnd();
                 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // entweder GL_FILL, GL_LINE oder GL_POINT wobei GL_FILL oder GL_LINE anschaulich sind
                   glEnable(GL_TEXTURE_2D);
                   glEnable(GL_DEPTH_TEST);
           }
           glDisable(GL_BLEND);
   
           glViewport(viewport_x,viewport_y,viewport_width,viewport_height);
   }
   
   hooked_glViewport(GLint x,  GLint y,  GLsizei width,  GLsizei height)
   {
           viewport_x = x;
           viewport_y = y;
           viewport_width = width;
           viewport_height = height;
   }
   
   
   
   Für alle: bool bClearbit = false; // Im Header
    
   hooked_glClear(GLbitfield mask)
   {
           if ((mask & GL_DEPTH_BUFFER_BIT) && bClearbit)        
           {                
                 bClearbit = false;                                                          
                   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
                   mask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
           }
   }


Ich hoffe auch dieses Tutorial hat euch weiter geholfen

mfg Suxx


Thanks Tabris for his nice Solid-Wireframe Tutorial on game-decetion.com

leo-gecko

unregistriert

2

28.06.2004, 18:04

Einfach Hammer

BIG thX für diese Mühe :D


:busch:

suxx-

unregistriert

3

28.06.2004, 18:06

guckt lieber mal auf der Tutorialpage vorbei tutorials.spieletermine.de
Thema bewerten