'
'   /////////////////////////////////////////////////////////////
'   // Autor:   BlackZeroX ( Ortega Avila Miguel Angel )       //
'   //                                                         //
'   // Web:     http://InfrAngeluX.Sytes.Net/                  //
'   //                                                         //
'   //    |-> Pueden Distribuir Este codigo siempre y cuando   //
'   // no se eliminen los creditos originales de este codigo   //
'   // No importando que sea modificado/editado o engrandecido //
'   // o achicado, si es en base a este codigo                 //
'   /////////////////////////////////////////////////////////////
'   //                                                         //
'   // * Esta es una lista de 1 solo Orden... es decir no es   //
'   // de ordenamiento en arbol...                             //
'   //                                                         //
'   /////////////////////////////////////////////////////////////
'   // http://infrangelux.hostei.com/index.php?option=com_content&view=article&id=29:clistlink&catid=15:catmoduloscls&Itemid=24
'   /////////////////////////////////////////////////////////////
 
Option Explicit
 
Private Const MEM_DECOMMIT = &H4000
Private Const MEM_RELEASE = &H8000
Private Const MEM_COMMIT = &H1000
Private Const MEM_RESERVE = &H2000
Private Const MEM_RESET = &H80000
Private Const MEM_TOP_DOWN = &H100000
Private Const PAGE_READONLY = &H2
Private Const PAGE_READWRITE = &H4
Private Const PAGE_EXECUTE = &H10
Private Const PAGE_EXECUTE_READ = &H20
Private Const PAGE_EXECUTE_READWRITE = &H40
Private Const PAGE_GUARD = &H100
Private Const PAGE_NOACCESS = &H1
Private Const PAGE_NOCACHE = &H200
Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (ByVal pDest As Long, ByVal pSrc As Long, ByVal ByteLen As Long)
Private Declare Function VirtualAlloc Lib "kernel32" (ByVal lpAddress As Long, ByVal dwSize As Long, ByVal flAllocationType As Long, ByVal flProtect As Long) As Long
Private Declare Function VirtualFree Lib "kernel32" (ByVal lpAddress As Long, ByVal dwSize As Long, ByVal dwFreeType As Long) As Long
Private Declare Function VirtualLock Lib "kernel32" (ByVal lpAddress As Long, ByVal dwSize As Long) As Long
Private Declare Function VirtualUnlock Lib "kernel32" (ByVal lpAddress As Long, ByVal dwSize As Long) As Long
'Private Declare Function IsBadReadPtr Lib "kernel32" (ByVal lp As Long, ByVal ucb As Long) As Long
'Private Declare Function IsBadWritePtr Lib "kernel32" (ByVal lp As Long, ByVal ucb As Long) As Long
'Private Declare Function IsBadStringPtr Lib "kernel32" Alias "IsBadStringPtrA" (ByVal lpsz As Long, ByVal ucchMax As Long) As Long
'Private Declare Function lstrcpy Lib "kernel32" Alias "lstrcpyA" (ByVal lpStringDest As String, ByVal lpStringSrc As Long) As Long
'Private Declare Function lstrlen Lib "kernel32" Alias "lstrlenA" (ByVal lpString As Long) As Long
Private Declare Sub ZeroMemory Lib "kernel32.dll" Alias "RtlZeroMemory" (ByVal Destination As Long, ByVal Length As Long)
 
Private Declare Sub PutMem4 Lib "msvbvm60" (ByVal Addr As Long, ByVal NewVal As Long)
Private Declare Sub GetMem4 Lib "msvbvm60" (ByVal Addr As Long, ByVal RetVal As Long)
 
Dim pfirst          As Long
Dim pLast           As Long
Dim lSize           As Long
 
Const SIZEAB        As Long = &H8
Const BEFORESIZE    As Long = &H0
Const AFTERSIZE     As Long = (BEFORESIZE + &H4)
 
Public Function release(ByVal pStream As Long) As Boolean
Dim lSizeF      As Long
Dim pAfter       As Long
Dim pBefore     As Long
    If (pStream = &H0) Then Exit Function
    lSizeF = (SIZEAB + lSize)
    pAfter = after(pStream)
    pBefore = before(pStream)
    VirtualUnlock pStream, lSizeF
    VirtualFree pStream, lSizeF, MEM_DECOMMIT
    VirtualFree pStream, 0, MEM_RELEASE
    If (pAfter) Then putBefore pAfter, pBefore
    If (pBefore) Then putAfter pBefore, pAfter
    If (pStream = pfirst) Then pfirst = pBefore
    If (pStream = pLast) Then pLast = pAfter
    release = True
End Function
 
Public Function getPtr(ByVal lIndex As Long) As Long
'   //  Retorna el puntero del elemento indicado en lIndex.
Dim pTmp            As Long
Dim i               As Long
    pTmp = first()
    Do Until (pTmp = &H0)
        i = (i + &H1)
        If (i > lIndex) Then Exit Do
        pTmp = after(pTmp)
    Loop
    getPtr = pTmp
End Function
 
Public Property Get size() As Long
    size = lSize
End Property
 
Public Property Let size(ByVal lVal As Long)
    Call clear
    lSize = lVal
End Property
 
Friend Sub writeStream(ByVal pStruct As Long, ByVal pData As Long)
'   //  Setea los valores en el bloque de la memoria de la lista enlazada.
    CopyMemory pStruct, pData, lSize
End Sub
 
Friend Function readStream(ByVal pStruct As Long, ByVal pData As Long)
'   //  Retorna los valores del bloque de la lista enlazada a una bloque.
    CopyMemory pData, pStruct, lSize
End Function
 
 
'   //  Estas funciones otienen el 1er y ultimo elemento agregado a la lista.
Friend Function first() As Long
    first = pfirst
End Function
 
Friend Function last() As Long
    last = pLast
End Function
 
 
'   //  funciones iteradoras.
Friend Function after(ByVal pStruct As Long) As Long    '   //  Rectorna del puntero al bloque que se agrego despues de pStruct
Dim pTmp            As Long
    If (pStruct = &H0) Then Exit Function
    GetMem4 ByVal (pStruct + lSize + AFTERSIZE), VarPtr(pTmp)
    after = pTmp
End Function
 
Friend Function before(ByVal pStruct As Long) As Long   '   //  Rectorna del puntero al bloque anteriormente agregado de pStruct
Dim pTmp            As Long
    If (pStruct = &H0) Then Exit Function
    GetMem4 ByVal (pStruct + lSize + BEFORESIZE), VarPtr(pTmp)
    before = pTmp
End Function
 
Friend Function addNew() As Long                        '   //  Agrega un nuevo bloque y lo enlaza.
Dim lSizeF      As Long
Dim pNew        As Long
    lSizeF = (SIZEAB + lSize)
    pNew = VirtualAlloc(ByVal 0&, lSizeF, MEM_COMMIT, PAGE_EXECUTE_READWRITE)
    VirtualLock pNew, lSizeF
    ZeroMemory pNew, lSizeF                             '   //  llenamos de 0 el bloque.
    If (pLast) Then                                     '   //  Actualizamos el ultimo...
        putBefore pNew, pLast
        putAfter pLast, pNew
    End If
    If (pfirst = &H0) Then pfirst = pNew
    pLast = pNew
    addNew = pNew
End Function
 
Private Sub putAfter(ByVal pStruct As Long, ByVal pAfter As Long)
    If (pStruct = &H0) Then Exit Sub
    PutMem4 (pStruct + lSize + AFTERSIZE), pAfter        '   //  pNew.After
End Sub
 
Private Sub putBefore(ByVal pStruct As Long, ByVal pBefore As Long)
    If (pStruct = &H0) Then Exit Sub
    PutMem4 (pStruct + lSize + BEFORESIZE), pBefore     '   //  pNOW.BEFORE
End Sub
 
Public Function clear() As Long                         '   //  Libera la memoria asignada y retorna la cantidad liberada en bytes.
Dim lSizeRet        As Long
Dim pTmp            As Long
    pTmp = first()      '   //  Seteamos el 1ro.
    Do Until (release(pTmp) = False)
        lSizeRet = (lSizeRet + lSize + SIZEAB)
        pTmp = first()
    Loop
    clear = lSizeRet
End Function
 
Private Sub Class_Terminate()
    Call clear
End Sub
 
 

 
Option Explicit
 
Private Type DATOSPERSONALES
    edad        As Long
    categoria   As Long
    nombre      As String * 20
    apellidoP   As String * 10
    apellidoM   As String * 10
End Type
 
Private Sub Form_Load()
Dim oList       As cListLink
Dim tDatosP     As DATOSPERSONALES      '   //  Plantilla...
Dim pElement    As Long                 '   //  Puntero al elemento...
 
    Set oList = New cListLink
 
    oList.size = LenB(tDatosP)                                  '   //  Tamaño de la estructura (bloque de datos).
 
    With tDatosP
        .edad = 22
        .categoria = 1
        .nombre = "Miguel Angel"
        .apellidoP = "Ortega"
        .apellidoM = "Avila"
    End With
    Call oList.writeStream(oList.addNew(), VarPtr(tDatosP))     '   //  Escribimos la estructura en una lista enlazada.
 
    With tDatosP
        .edad = 42
        .categoria = 2
        .nombre = "Angel"
        .apellidoP = "Ortega"
        .apellidoM = "Hernandez"
    End With
    Call oList.writeStream(oList.addNew(), VarPtr(tDatosP))     '   //  Escribimos la estructura en una lista enlazada.
 
    With tDatosP
        .edad = 19
        .categoria = 2
        .nombre = "Maria Luisa"
        .apellidoP = "Beltran"
        .apellidoM = "Ramirez"
    End With
    Call oList.writeStream(oList.addNew(), VarPtr(tDatosP))     '   //  Escribimos la estructura en una lista enlazada.
 
 
    'Call oList.release(oList.before(oList.firts()))             '   //  Liberamos el 2 registro ("Angel Ortega Hernandez"), para eso obtenemos el 1 elemento y obtenemos el siguiente elemento con before...
    Call oList.release(oList.getPtr(1))                         '   //  Eliminamos el elemento con Index 1
 
    '   //  Retornamos los elementos...
 
    pElement = oList.first()
 
    Do Until (pElement = &H0)
 
        oList.readStream pElement, VarPtr(tDatosP)
        With tDatosP
            Debug.Print "Nombre:", .nombre
            Debug.Print "ApellidoP:", .apellidoP
            Debug.Print "ApellidoM:", .apellidoM
            Debug.Print "Edad:", .edad
            Debug.Print "Categoria:", .categoria
            Debug.Print
            Debug.Print
            Debug.Print
        End With
        pElement = oList.after(pElement)
    Loop
 
    Set oList = Nothing
 
End Sub
 
 

http://foro.elhacker.net/programacion_visual_basic/reto_reemplazo_de_funcion_isnumeric-t336067.0.html;msg1652210#msg1652210

main.cpp

 
#include "main.h"
 
/**
    @Autor          BlackZeroX
    @Web            http://infrangelux.sytes.net/blog/
    @Reference      http://foro.elhacker.net/programacion_visual_basic/reto_reemplazo_de_funcion_isnumeric-t336067.0.html;msg1652210#msg1652210
    @Description    Libreria para verificar si una Cadena de texto ANSI/UNICODE es numerica con los siguientes formatos:
                    * ###e[+/-]###  {+/-646.45e+546,45}.
                    * ###d[+/-]###  {+/-646.45d+546,45}.
                    * Base 16       {&H4561abcdef}.
                    * Base 10       {+/-456,541.456,545}.
    @Returns        0 si la cadena no contiene ningun formato.
                    1 si la cadena pertenece a algun tipo de formato numerico.
**/
 
#define PUNTO_DECIMAL     0x10000
#define SIGNO_SRC         0x20000
#define NUMBER_HEX        0x40000
#define NUMBER_HEX_ZERO   0x80000
#define NUMBER_HEX_FLAGS  (NUMBER_HEX | NUMBER_HEX_ZERO)
#define NUMBER_POW        0x100000
#define NUMBER_POW_FINISH 0x200000
#define NUMBER_POW_FLAGS  (NUMBER_POW | NUMBER_POW_FINISH)
#define NUMBER_OF_OK      0x400000
#define NUMBER_OF_FINISH  0x800000
#define NUMBER_OF_FLAGS   (NUMBER_OF_OK | NUMBER_OF_FINISH)
 
DLL_EXPORT int __stdcall IsNumericA (char *pStr) { return pStr ? IsNumericEx(pStr, *((int*)(pStr - 0x4)), 1): 0; }
DLL_EXPORT int __stdcall IsNumericW (char *pStr) { return pStr ? IsNumericEx(pStr, *((int*)(pStr - 0x4)), 2): 0; }
 
int IsNumericEx (char *pStr, size_t uiLn, int iStep) {
unsigned int i       = 0x0,  //  For()
             iData   = 0x0;  //  Xor, Switcher, Contador (QWord).
 
    if (!pStr || !uiLn)
        return 0;
 
    for (i = 0; i < uiLn; i += iStep) {
        if ((iData & NUMBER_HEX) == NUMBER_HEX) {
            if (((*pStr >= 0x30) && (*pStr <= 0x39)) ||
               ((*pStr >= 0x61) && (*pStr <= 0x66)) ||
               ((*pStr >= 0x41) && (*pStr <= 0x46))) {  //  Numeros Hexadecimales
                if ((iData & NUMBER_OF_FLAGS) == 0x0)   //  Ceros a la izquierda
                    iData |= (*pStr == 0x30) ? NUMBER_HEX_ZERO : NUMBER_OF_OK;
 
                switch (iData & NUMBER_OF_FLAGS) {
                    case NUMBER_OF_OK:
                        iData++;
                        if ((iData & 0xFF) == 0x11)
                            return 0;   //  QWord (Max Double)
                        iData |= NUMBER_OF_OK;
                        if ((iData | NUMBER_HEX_FLAGS) == NUMBER_HEX_FLAGS)
                            iData ^= NUMBER_HEX_ZERO;
                        break;
 
                    case NUMBER_OF_FINISH:
                    case NUMBER_OF_FLAGS:
                        return 0;
                        break;
               }
            } else {
                switch (*pStr) {
                    case 0x9:
                    case 0xA:
                    case 0xB:
                    case 0xC:
                    case 0xD:
                    case 0x24:
                    case 0x20:
                    case 0xA0:  //   Espacios en Blanco
                        if ((iData | NUMBER_HEX_FLAGS) == NUMBER_HEX_FLAGS)
                            iData = ((iData ^ NUMBER_HEX_ZERO) | NUMBER_OF_OK);
                        if ((iData & NUMBER_OF_FLAGS) == NUMBER_OF_OK)
                            iData |= NUMBER_OF_FINISH;
                        break;
 
                    case 0x0:    //  NULL Indica que se termina la cadena.
                        if ((iData & NUMBER_OF_FLAGS) == NUMBER_OF_FINISH)
                            return 0;
                        i = uiLn; //  Exit For.
                        break;
 
                    default:
                        return 0;
                        break;
                }
            }
        } else {
            if ((*pStr >= 0x30) && (*pStr <= 0x39)) {
                iData |= NUMBER_OF_OK;
                if ((iData & NUMBER_OF_FINISH) == NUMBER_OF_FINISH)
                    return 0;
                if ((iData & NUMBER_POW_FLAGS) == NUMBER_POW)
                    iData |= NUMBER_POW_FINISH;
 
            } else {
                switch ((int)*pStr) {
                    case 0x0:    //  NULL Indica que se termina la cadena.
                        if ((iData & NUMBER_POW_FLAGS) == NUMBER_POW)
                            return 0;
                        i = uiLn;    //  Exit For.
                        break;
 
                    case 0x2E:   //  "."  Solo 1
                        if (((iData & NUMBER_POW_FLAGS) == NUMBER_POW) ||
                           ((iData & NUMBER_OF_FINISH) == NUMBER_OF_FINISH) ||
                           ((iData & PUNTO_DECIMAL) == PUNTO_DECIMAL))
                            return 0;
                        iData |= PUNTO_DECIMAL;
                        break;
 
                    case 0x2B:
                    case 0x2D: //  "+|-" Solo 1
                        if ((iData & NUMBER_POW_FLAGS) == NUMBER_POW)
                            iData |= NUMBER_POW_FINISH;
 
                        else
                            if (((iData & NUMBER_OF_OK) == NUMBER_OF_OK) ||
                               ((iData & PUNTO_DECIMAL) == PUNTO_DECIMAL) ||
                               ((iData & SIGNO_SRC) == SIGNO_SRC))
                            return 0;
 
                        if ((iData & NUMBER_OF_FINISH) == NUMBER_OF_FINISH)
                            return 0;
 
                        iData |= SIGNO_SRC;
                        break;
 
                    case 0x2C:
                        if ( !((iData & NUMBER_OF_OK) == NUMBER_OF_OK) ||
                              ((iData & NUMBER_POW_FLAGS) == NUMBER_POW))
                            return 0;
                        break;
 
                    case 0x9:
                    case 0xA:
                    case 0xB:
                    case 0xC:
                    case 0xD:
                    case 0x24:  //  Solo se permiten al inicio de un Numero (Espacios en Blanco).
                        if (((iData & PUNTO_DECIMAL) == PUNTO_DECIMAL) ||
                           ((iData & NUMBER_OF_FINISH) == NUMBER_OF_FINISH) ||
                           ((iData & NUMBER_OF_OK) == NUMBER_OF_OK) ||
                           ((iData & NUMBER_POW_FLAGS) == NUMBER_POW))
                            return 0;
                        break;
 
                    case 0xA0:
                    case 0x20: //  Se permiten al Inicio/final de un numero.
                        if ((iData & NUMBER_OF_OK) == NUMBER_OF_OK)
                            iData |= NUMBER_OF_FINISH;
                        else
                            if (((iData & PUNTO_DECIMAL) == PUNTO_DECIMAL) ||
                               ((iData & NUMBER_POW_FLAGS) == NUMBER_POW))
                                return 0;
                        break;
 
                    case 0x26:   //  Es un Numero Hexadecimal
                        if (((iData & NUMBER_OF_FINISH) == NUMBER_OF_FINISH) ||
                           ((iData & NUMBER_OF_OK) == NUMBER_OF_OK) ||
                           ((iData & SIGNO_SRC) == SIGNO_SRC) ||
                           ((iData & PUNTO_DECIMAL) == PUNTO_DECIMAL) ||
                           ((iData & NUMBER_POW_FLAGS) == NUMBER_POW))
                            return 0;
 
                        pStr += iStep;
 
                        if ((*pStr == 0x48) || (*pStr == 0x68)) {
                            iData |= NUMBER_HEX;
                            iData ^= 0xFF000000;
                            i += iStep;
                        } else {
                            pStr -= iStep;
                        }
                        break;
 
                    case 0x44:
                    case 0x45:
                    case 0x64:
                    case 0x65:     //  Numeros en Formato ###e-###, ###e+###
                        if (((iData & NUMBER_OF_FINISH) == NUMBER_OF_FINISH) ||
                           ((iData & NUMBER_POW) == NUMBER_POW))
                            return 0;
                        if ((iData & NUMBER_OF_OK) == NUMBER_OF_OK) {
                            iData |= NUMBER_POW;
                            if ((iData & SIGNO_SRC) == SIGNO_SRC)
                                iData ^= SIGNO_SRC; //  Permitimos nuevamente los signos "+" y "-".
                        } else {
                            return 0;
                        }
                        break;
 
                    default:
                        return 0;
                        break;
 
                }   //  switch()
            }   //  if()
        }   //  if()
        pStr += iStep;
    }   //  For()
 
    switch (iData & NUMBER_OF_FLAGS) {
        case NUMBER_OF_OK:
        case NUMBER_OF_FLAGS:
            return 1;
            break;
 
        default:
            switch (iData & NUMBER_HEX_FLAGS) {
                case NUMBER_HEX_FLAGS:
                    return 1;
                    break;
            }
    }
 
    return 0;
}
 
 

 
#ifndef __MAIN_H__
#define __MAIN_H__
 
#include <windows.h>
 
#ifdef BUILD_DLL
    #define DLL_EXPORT __declspec(dllexport)
#else
    #define DLL_EXPORT __declspec(dllimport)
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
DLL_EXPORT int __stdcall IsNumericA (char*);
DLL_EXPORT int __stdcall IsNumericW (char*);
int IsNumericEx (char *pStr, size_t uiLn, int iStep);
 
#ifdef __cplusplus
}
#endif
 
#endif // __MAIN_H__
 
 

 
#include <windows.h>
#include "include/OpenGL/CGL.h"
 
// Posicion de la luz X, Y, Y, {el 4to elemento indica si es en una posicion infinita 1=NO, 0=SI}
float fposition[4] = {0.0f, 0.0f, 1.0f, 1.0};
 
void drawZones()
{
    ::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // Borramos la pantalla y el buffer de profundidad
 
    ::glLoadIdentity();
    //  Camara.
    ::gluLookAt( 0, 0, 5,               //  Posicon X, Y, Z.
                 0, 0, -1,              //  Hacia donde vemos X, Y, Z.
                 0.0f, 1.0f, 0.0f );    // Cielo X, Y, Z.
 
    GLfloat fDirection[] = {0.0,0.0,-1.0}; // Dirrecion hacia adonde apuntamos.
    //Configuramos nuestra Luz.
    ::glEnable ( GL_LIGHT0 );
    ::glLightfv ( GL_LIGHT0, GL_POSITION, fposition );
    ::glLightfv ( GL_LIGHT0, GL_SPOT_DIRECTION, fDirection);
    ::glLightf ( GL_LIGHT0, GL_SPOT_CUTOFF, 5 );
 
    ::glutSolidSphere(100, 4000, 4000); // Esfero que nos representara las paredes.
 
    //  Las siguiente son las esferas donde esta la luz.
    //  Posicion del emisor de luz.
    ::glPushMatrix ();
        ::glColor3f ( 1.0f , 0.0f , 0.0f );
        ::glTranslatef ( fposition[0],fposition[1],fposition[2] );
        ::glutWireSphere ( 0.2, 50 , 50 );
    ::glPopMatrix ();
 
    //  Posicion Destino hacia donde se emite la luz.
    ::glPushMatrix();
        ::glColor3f( 0.0f , 0.0f , 1.0f );
        ::glTranslatef( fDirection[0],fDirection[1],fDirection[2] );
        ::glutSolidSphere( 0.2, 50 , 50 );
    ::glPopMatrix();
    //  Mostramos.
    ::glutSwapBuffers();
}
 
void keyBoardSFunc(int key, int x, int y)
{
    if (key == GLUT_KEY_LEFT)
        fposition[0] -= 0.1;
    if (key == GLUT_KEY_RIGHT)
        fposition[0] += 0.1;
    if (key == GLUT_KEY_UP)
        fposition[1] -= 0.1;;
    if (key == GLUT_KEY_DOWN)
        fposition[1] += 0.1;
}
void timer( int val ) {
    ::glutTimerFunc       ( 10 , timer,  0);
    ::glutPostRedisplay   (  );
}
 
int main()
{
    CGL oWindow;
 
    oWindow.creaVentanaGL ( "Hola Mundo desde OpenGL" , 1024 , 726 , 0 , 0 , false );
    ::glutDisplayFunc ( drawZones );
    ::glutSpecialFunc ( keyBoardSFunc );
    ::glutTimerFunc ( 10, timer, 0 );
    ::glutMainLoop ();
 
    return EXIT_SUCCESS;
}
 
 

 
 
#include "OpenGL/cgl.h"
 
//---------------------------------------------------------------
// Nombre: Constructor
// Descripcion: Constructor de la clase. Inicializa las variables
// Parametros: Ninguno
//---------------------------------------------------------------
CGL::CGL()
{
    int_Win = 0;
}
 
//---------------------------------------------------------------
// Nombre: Destructor
// Descripcion: Destructor de la clase
// Parametros: Ninguno
//---------------------------------------------------------------
CGL::~CGL()
{
    eliminaVentanaGL();
}
 
//---------------------------------------------------------------
// Nombre: inicializaEscenaGL
// Descripcion: Inicializa los parametros iniciales de la escena
// Parametros:
//        Glsizei ancho: Ancho de la escena
//        Glsizei alto: Alto de la escena
//---------------------------------------------------------------
void CGL::inicializaEscenaGL(GLsizei ancho, GLsizei alto)
{
    if ( alto <= 0 )                                                                    // Previene de la división entre 0
    {
        alto=1;                                                                         // Establece la altura = 1
    }
    ::glViewport            ( 0 , 0 , ancho , alto );                                   // Resetea el actual puerto de visión (ViewPort)
    ::glMatrixMode          ( GL_PROJECTION );                                          // Selecciona la matriz de proyección
    ::glLoadIdentity        (  );                                                       // Resetea la matriz de proyección
 
    ::gluPerspective        ( 45.0f , (GLfloat)ancho/(GLfloat)alto , 1.0f , 300000.0f );  // Calcula el Aspect Ratio de la ventana
 
    ::glMatrixMode          ( GL_MODELVIEW );                                           // Selecciona la matriz de modelado
    ::glLoadIdentity        (  );                                                       // Resetea la matriz de modelado
}
 
//---------------------------------------------------------------
// Nombre: iniGL
// Descripcion: Inicializa los valores iniciales de OGL
// Parametros: Ninguno
//---------------------------------------------------------------
bool CGL::iniGL(void)
{
    GLfloat ambientLight[]  = { 0.1f, 0.1f, 0.1f, 1.0f };
    ::glShadeModel          ( GL_SMOOTH );                                  // Activa sombreado suave (Smooth Shading)
    ::glClearDepth          ( 1.0f );                                       // Depth Buffer Setup
    ::glEnable              ( GL_DEPTH_TEST );                              // Activa Z-Buffer
    ::glDepthFunc           ( GL_LEQUAL );                                  // El tipo de Depth Testing que se va a realizar
    ::glHint                ( GL_PERSPECTIVE_CORRECTION_HINT , GL_NICEST ); // Muy buena correción de perspectiva
    ::glEnable              ( GL_TEXTURE_2D );                              // Activa mapeado de texturas
    ::glColorMaterial       ( GL_FRONT , GL_AMBIENT_AND_DIFFUSE );
    ::glClearColor          ( 0.0f , 0.0f , 0.0f , 1.0f );
 
    ::glLightModeli         ( GL_LIGHT_MODEL_TWO_SIDE , 1 );                // habilita ambas caras (FRONT-iluminada & BACK-oscurecida) de los poligonos
    ::glLightModelfv        ( GL_LIGHT_MODEL_AMBIENT , ambientLight );      // luz ambiental de toda la escena
    ::glEnable              ( GL_COLOR_MATERIAL);                           // habilita el color para los materiales (poligonos rellenos)
    ::glEnable              ( GL_LIGHTING );
 
    return true;
}
 
//---------------------------------------------------------------
// Nombre: eliminaVentanaGL
// Descripcion: Destruye toda la información sobre la ventana GL
// Parametros: Ninguno
//---------------------------------------------------------------
void CGL::eliminaVentanaGL(void)
{
    ::glutDestroyWindow(  this->int_Win );
    this->int_Win = 0;
}
 
//---------------------------------------------------------------
// Nombre: CrearVentanaGL
// Descripcion: Crea una ventana OGL
// Parametros:
//            char* Titulo: Titulo de la ventana
//            int ancho: Ancho de la ventana o en modo pantalla completa
//            int alto: Alto de la ventana o en modo pantalla completa
//            bool fullscreen: Usar pantalla completa (TRUE) o ventana (FALSE)
//---------------------------------------------------------------
bool CGL::creaVentanaGL(const char* Titulo, GLsizei ancho, GLsizei alto, GLsizei x, GLsizei y, bool fullscreen)
{
    if ( x < 0 ) { x=0; }
    if ( y < 0 ) { y=0; }
 
    ::glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGBA );
    ::glutInitWindowPosition ( x , y );
    ::glutInitWindowSize ( ancho , alto );
 
    this->int_Win = ::glutCreateWindow( Titulo );
 
    ::glutSetWindow( this->int_Win );
 
    if ( fullscreen == true )
        ::glutFullScreen();
 
    inicializaEscenaGL ( ancho , alto );        // Inicializamos la escena en perspectiva GL
 
    if ( !iniGL() ) {
        eliminaVentanaGL();
        return false;
    }
 
    return true;
}
 
 

 
#ifndef _cGL_H_
#define _cGL_H_
 
// INCLUDES //////////////////////////////////////
#include <windows.h>            // Archivo cabecera para Windows
#include <GL/glut.h>
 
class CGL
{
    public:
        CGL                                         ();
        virtual         ~CGL                        ();
        bool            creaVentanaGL               (const char* Titulo, GLsizei ancho, GLsizei alto, GLsizei x, GLsizei y, bool fullscreen);
        void            inicializaEscenaGL          (GLsizei ancho, GLsizei alto);      // Cambia de tamaño e inicializa la ventana GL
        void            eliminaVentanaGL            (void);                           // Elimina la ventana
        int             int_Win;
        void            inilight                    (GLfloat ligt[]);
    private:
        bool            iniGL                       (void);                        // Todas la inicializaciónes de OpenGl vienen aqui
};
 
#endif
 
 

 
var k=function(){
    var l=$("#dtmain_outer, #hatdoiwas_outer");
    if(l.length>0){
    l.remove();
    C.utils.third_party_addon_detected()
}
setTimeout(k,1000)
 
 

 
#include <stdio.h>
#include <string.h>
 
void** RedimPreserve( void** __pp_vector , size_t _szt_now, size_t _szt_new )
{
    void            **__pp_back     = __pp_vector;
    void            **__new_ptr     = NULL;
 
    if (_szt_now==_szt_new )
        return __pp_vector;
 
    if ( _szt_new>0 ) {
        __new_ptr       = new void*[_szt_new];
        if ( _szt_now>0 && __new_ptr!=NULL && __pp_back!=NULL  )
            memcpy          ( __new_ptr , __pp_back , _szt_now*sizeof(void*) );
    } else
        __new_ptr       = NULL;
 
    if ( __pp_back!=NULL )
        delete[]        __pp_back;
 
    return __new_ptr;
}
 
 
 
int main () {
    char **_msg = NULL;
 
    _msg    = (char**)RedimPreserve( (void**)_msg , 00 , 10 );
    _msg    = (char**)RedimPreserve( (void**)_msg , 10 , 11 );
    _msg    = (char**)RedimPreserve( (void**)_msg , 11 , 10 );
    _msg    = (char**)RedimPreserve( (void**)_msg , 10 , 00 );
    _msg    = (char**)RedimPreserve( (void**)_msg , 00 , 13 );
    _msg    = (char**)RedimPreserve( (void**)_msg , 13 , 20 );
    delete[] _msg;
    return 0;
}