i3Function SDK

g_pCameraManager 0x4CBD00
CFramework      0x4CBCC4
CViewer 0x4CBCC8
CGameNode 0x4CBCD0
CPhysixInfoDataBase 0x4CBCF8
g_pGameContext  0x4CBD08
DefaultCamera   0x4CCEB4
g_pCommunity    0x4D0544
CStageBattle    0x4AF1D8
CWeaponInfoDatabase    0x4CBCEC
CGameWeaponManager    0x4CBCD8

///////////////////////////////////////////////////////////////////////////////////////
enum  I3G_IMAGE_FORMAT
{
    //FALTA DEFINIR
};

class CGfxPerformanceReport //i3GfxPerformanceReport
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////
class CRenderTarget
{
    char                unk1[304];            //00000000 field_0         db 304 dup(?)
    DWORD                f130;                //00000130 f_130           dd ?
    DWORD                f134;                //00000134 field_134       db 284 dup(?)
    UINT                uiWidth;            //00000250 f_250           dd ?
    UINT                uiHeight;            //00000254 f_254           dd ?
    I3G_IMAGE_FORMAT    m_ImageFormat;        //00000258 f_258           dd ?
    I3G_IMAGE_FORMAT    m_ImageDepthFormat;    //0000025C f_25C           dd ?
    DWORD                dwLockable;            //00000260 f_260           dd ?
    DWORD                dwLocked;            //00000264 f_264           dd ?
    DWORD                f268;                //00000268 f_268           dd ?
    IDirect3DSurface9*    m_pColorSurface;    //0000026C m_pColorSurface dd ?
    IDirect3DSurface9*    m_pDepthSurface;    //00000270 f_270           dd ?

public:

    UINT GetWidth(void)
    {
        if (uiWidth) return uiWidth;

        return 0;

    }
};
///////////////////////////////////////////////////////////////////////////////////////
struct CRenderContext
{
  long                        pRenderData;
  char                        unknown1[16];
  long                        pTimer;
  char                        field_18[12];
  long                        pVertexArray;
  long                        pIndexArray;
  long                        bWindowed;
  long                        bReady;
  long                        dwSkipBlendModeAttr;
  long                        bPresentState;
  long                        pGfxOption;
  char                        field_40[852];
  long                        WorldViewTranspose[60];
  unsigned short            field_398[628];
  long                        uiClearFlag;
  long                        pClearColor;
  char                        field_888[36];
  CRenderTarget*            pRenderTarget[16];            //0x8AC    class i3RenderTarget * VERIFICAR O TAMANHO DESSA ESTRUTURA, COLOQUEI 16 PQ NAO SEI
  char                        field_8B0[136];
  long                        fClearZValue;
  long                        ucClearStencilValue;
  unsigned short            iVertexBlendWeightCount;
  char                        field_942[6];
  CGfxPerformanceReport*    pPerformanceReport;
  char                        field_94C[16];
  long                        fDeltaSec;
  long                        pViewMatrix;
  char                        field_964[60];
  long                        pProjectMatrix;
  char                        field_9A4[60];
  long                        pWorldMatrix;
  char                        field_9E4[60];
  long                        pVertexBlendMatrixArray;
  char                        field_A24[16380];
  unsigned short            iVertexBlendMatrixCount;
  char                        field_4A22[98];
  long                        pColor;
  char                        field_4A88[12];
  long                        pAmbient;
  char                        field_4A98[12];
  long                        pMaterialDiffuse;
  char                        field_4AA8[12];
  long                        pMaterialSpecular;
  char                        field_4AB8[12];
  long                        pMaterialEmissive;
  char                        field_4AC8[12];
  long                        fMaterialShininess;
  long                        pSecondaryColor;
  char                        field_4ADC[12];
  long                        pTetraColor;
  char                        field_4AEC[12];
  long                        bFresnelEnable;
  long                        fFresnelIndexOfReflect;
  long                        pFresnelColor;
  char                        field_4B04[12];
  long                        bInstancingEnable;
  char                        field_4B14[1884];
  long                        pCurrentShader;
  char                        field_5274[264];
  long                        pVideoInfo;
  char                        field_5380[20];
  long                        iWindowWidth;
  long                        iWindowHeight;
  long                        enumWindowColorFormat;
  char                        field_53A0[8];
  long                        enumWindowDepthFormat;
  char                        field_53AC[168];
  long                        bAdjustWindowPosState;
  char                        field_5458[8];
  long                        pDevice;
  char                        field_5464[4];
  long                        dwDirect3DSurface9_1;
  long                        dwDirect3DSurface9_2;
  long                        DefaultD3DSurface;
  long                        DefaultD3DDeapthSurface;
  long                        used_unknown2;
  char                        field_547C[72];
  long                        used_0x54C4;
  char                        field_54C8[64];
  long                        used_0x5508;
  long                        used_0x550C;
  long                        bShaderEnable;
  long                        used_0x5514;
  long                        ContextRivieved;
  long                        used_0x551C;
  long                        used_0x5520;
  long                        used_0x5524;
  char                        field_5528[112];
  long                        DialogBoxMode;

  CRenderTarget* GetRenderTarget(int iTarget)
  {
        /*
        __asm
        {
            mov eax, [ecx + 0x8AC]
            mov ecx, iTarget
            mov eax, [eax + ecx * 4]
        }
        */
        if (pRenderTarget)
        {
            return pRenderTarget[iTarget];
        }

        return 0;
  }
};
///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////
class CMatrixArray //i3MatrixArray
{
public:
    char             unk1[20];                //0x0
    D3DXMATRIX*        pMatrix;                //0x14    union _tagi3Matrix *
    int                iCount;                    //0x18
};
///////////////////////////////////////////////////////////////////////////////////////
class CMatrixStack
{
public:
    char            unk1[16];
    DWORD            MatrixStack_0x10;        //0x10    
    DWORD            MatrixStack_0x14;        //0x14    
    char            unk2[156];
    DWORD            m_Index;                //0xB4    
    DWORD            MatrixStack_0xB8;        //0xB8   

    /**********************************************************************************/
    void Reset(void) 
    {
        //MatrixStack_0x10 = &I3_IDENTITYMATRIX; 
        m_Index             = 0;
        MatrixStack_0xB8 = -1;
        MatrixStack_0x10 = 1;
    }
    /**********************************************************************************/
};
///////////////////////////////////////////////////////////////////////////////////////
class CAnimation
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////
class CMatrixObject
{
public:
    char        unk1[52];
    D3DXMATRIX    d3dxmatrix;    //0x34 D3DXMATRIX
};
///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////
class CProjectMatrixAttr
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////
class CViewMatrixAttr
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////
class CCamera //i3Camera
{
    char                        unk1[480];                //00000000 field_0         db 480 dup(?)
    float                        m_FOV;                    //000001E0 m_FOV           dd ?
    float                        m_Near;                    //000001E4 m_Near          dd ?
    float                        m_Far;                    //000001E8 m_Far           dd ?
    float                        m_WindowWidth;            //000001EC m_WindowWidth   dd ?
    float                        m_WindowHeight;            //000001F0 m_WindowHeight  dd ?
    
    enum I3_CAMERA_MODE
    {
        m_eCamera                                        //000001F4 m_eCamera       dd ?                    ; enum I3_CAMERA_MODE
    };

    UINT                        m_Enable;                //000001F8 dwEnable        dd ?
    UINT                        m_Style;                //000001FC m_Style         dd ?
    UINT                        m_UpdateInterval;        //00000200 m_UpdateInterval dd ?
    CProjectMatrixAttr*            m_pi3ProjectMatrixAttr;    //00000204 m_pi3ProjectMatrixAttr dd ?             ; i3ProjectMatrixAttr *
    CViewMatrixAttr*            m_pi3ViewMatrixAttr;    //00000208 m_pi3ViewMatrixAttr dd ?                ; i3ViewMatrixAttr *

public:

    void __thiscall SetNearFar(float Far, float Near)
    {
        m_Near = Near;
        m_Far = Far;
        UpdateProjecti********();
    }

    static class i3ClassMeta * __cdecl GetClassMeta(void)
    {
        //mov     eax, ?s_pClassMetai3Camera@i3Camera@@2PAVi3ClassMeta@@A ; i3ClassMeta * i3Camera::s_pClassMetai3Camera
        //retn
    }

    static enum  I3_TRACE_RESULT __cdecl CallTraceProc(class i3Node *, class i3SceneTracer *)
    {
        //jmp     TraceProci3Camera@i3Camera@@SA?AW4I3_TRACE_RESULT@@pavi3Node@@pavi3SceneTracer@@@Z ; i3Camera::TraceProci3Camera(i3Node *,i3SceneTracer *)
    }
    
    enum  I3_CAMERA_MODE __thiscall GetMode(void)
    {
        return m_eCamera;
    }
    
    void __thiscall SetMode(enum  I3_CAMERA_MODE arg_0)
    {
        I3_CAMERA_MODE m_eCamera = arg_0;
        UpdateProjecti********();
    }
    
    unsigned int __thiscall getStyle(void)
    {
        return m_Style;
    }
    
    void __thiscall setStyle(unsigned int arg_0)
    {
        m_Style = arg_0;
    }
    
    void __thiscall addStyle(unsigned int arg_0)
    {
        /*++
        _asm
        {
        mov     eax, arg_0
        or      unknown_style, eax
        retn    4
        }
        --*/
    }
    
    void __thiscall removeStyle(unsigned int arg_0)
    {
        /*++
        _asm
        {
        mov     eax, arg_0
        not     eax
        and     unknown_style, eax
        retn    4
        }
        --*/
    }
    
    union _tagi3Matrix * __thiscall GetProjecti********(void)
    {
        return (_tagi3Matrix *)m_pi3ViewMatrixAttr;//->20h;
    }
    
    class CProjectMatrixAttr * __thiscall GetProjectMatrixAttr(void)
    {
        return (CProjectMatrixAttr *)m_pi3ViewMatrixAttr;
    }
    
    class CViewMatrixAttr * __thiscall GetViewMatrixAttr(void)
    {
        return m_pi3ViewMatrixAttr;
    }
    
    void __thiscall SetFOV(float arg_0)
    {
        m_FOV = arg_0;
        UpdateProjecti********();

    }
    
    float __thiscall GetFOV(void)
    {
        return m_FOV;//0x1E0h
    }
    
    void __thiscall setUpdateInterval(float)
    {
    }
    
    float __thiscall getUpdateInterval(void)
    {
    }
    
    void __thiscall SetNear(float arg_0)
    {
        m_Near = arg_0;
        SetNearFar(m_Far, m_Near);
    }
    
    void __thiscall SetFar(float arg_0)
    { 
        m_Far = arg_0;
        SetNearFar(m_Far, m_Near);
    }
    
    float __thiscall GetNear(void)
    {
        return m_Near;
    }
    
    float __thiscall GetFar(void)
    {
        return m_Far;
    }
    
    int __thiscall GetEnable(void)
    {
        return m_Enable;
    }
    
    float __thiscall GetWindowWidth(void)
    {
        return m_WindowWidth;
    }
    
    float __thiscall GetWindowHeight(void)
    {
        return m_WindowHeight;
    }

    //void __thiscall SwapRT(void)
    //{
    //    m_RT = !m_RT;
    //}

    __thiscall CCamera::CCamera(class i3Camera const &arg_0)
    {
        /*
        push    esi
        push    edi
        mov     edi, [esp+arg_0]
        push    edi
        mov     esi, ecx
        call    ??0i3Transform@@QAE@ABV0@@Z ; i3Transform::i3Transform(i3Transform const &)
        mov     dword ptr [esi], offset const i3Camera::vftable
        fld     dword ptr [edi+1E0h]
        fstp    dword ptr [esi+1E0h]
        fld     dword ptr [edi+1E4h]
        fstp    dword ptr [esi+1E4h]
        fld     dword ptr [edi+1E8h]
        fstp    dword ptr [esi+1E8h]
        fld     dword ptr [edi+1ECh]
        fstp    dword ptr [esi+1ECh]
        fld     dword ptr [edi+1F0h]
        fstp    dword ptr [esi+1F0h]
        mov     eax, [edi+1F4h]
        mov     [esi+1F4h], eax
        mov     ecx, [edi+1F8h]
        mov     [esi+1F8h], ecx
        mov     edx, [edi+1FCh]
        mov     [esi+1FCh], edx
        fld     dword ptr [edi+200h]
        fstp    dword ptr [esi+200h]
        mov     eax, [edi+204h]
        mov     [esi+204h], eax
        mov     ecx, [edi+208h]
        mov     [esi+208h], ecx
        mov     edx, [edi+20Ch]
        mov     [esi+20Ch], edx
        mov     eax, [edi+210h]
        mov     [esi+210h], eax
        mov     ecx, [edi+214h]
        mov     [esi+214h], ecx
        mov     edx, [edi+218h]
        mov     [esi+218h], edx
        mov     eax, [edi+21Ch]
        mov     [esi+21Ch], eax
        pop     edi
        mov     eax, esi
        pop     esi
        retn    4
        */

    }
    void __thiscall SetPerspective(float arg_0, float arg_1, float arg_2, float arg_3, float arg_4)
    {
    }//14140
    void __thiscall SetOrthogonal(float, float, float, float)
    {
    }//14220
    protected:
        void __thiscall CCamera::UpdateProjecti********(void)
        {
            if(m_eCamera)
            {
                SetPerspective(m_FOV, m_WindowWidth, m_WindowHeight, m_Far, m_Near);
            }
            else
            {
                SetOrthogonal(m_WindowWidth, m_WindowHeight, m_Far, m_Near);
            }
        }
};
///////////////////////////////////////////////////////////////////////////////////////
class CAttrStackManager
{
public:

};
///////////////////////////////////////////////////////////////////////////////////////
class CSceneTracer
{
public:
    char                unk1[24];
    CAttrStackManager*    pAttrStackManager;        //0x18    class i3AttrStackManager *    
    char                unk2[12];
    CMatrixStack*        pModelViewMatrixStack;    //0x28    class i3MatrixStack *
    char                unk3[112];
    DWORD*                pMatrixEnvironment;        //0x9C    struct _tagMatrixEnvironmentInfo * 
    char                unk4[48];
    float                fTime;                    //0xD0                
    CCamera*            pCurrentCamera;            //0xD4    class i3Camera *
    char                unk5[8];
    DWORD*                pViewMatrix;            //0xE0    
    char                unk6[60];
    D3DXMATRIX*            pInverseViewMatrix;        //0x120    union _tagi3Matrix *
    char                unk7[60];
    D3DXMATRIX*            pProjecti********;        //0x160
    char                unk8[60];
    D3DXMATRIX*            pViewProjecti********;    //0x1A0    union _tagi3Matrix *
    char                unk9[60];
    DWORD*                pFrustumCullEnable;        //0x1E0    
    char                unk10[192];
    UINT                uiPlaneMask;            //0x2A4
    UINT                uiFrameID;                //0x2A8
    BYTE                bCulledState;            //0x2AC    

    /**********************************************************************************/
    CMatrixStack* GetModelViewMatrixStack(void) 
    {
        return pModelViewMatrixStack;
    }
    /**********************************************************************************/
    void SetTime(float f) //funcao da SDK
    {
        fTime = f;
    }
    /**********************************************************************************/
    float GetTime(void) //funcao da SDK
    {
        return fTime;
    }
    /**********************************************************************************/
};
///////////////////////////////////////////////////////////////////////////////////////
class CBody
{
public:
    
};
///////////////////////////////////////////////////////////////////////////////////////
class CNode
{
public:

};
///////////////////////////////////////////////////////////////////////////////////////
class CSceneObject
{
public:
    char                unk1[484];
    CBinList*            pBinList;                //0x1E4 definido em i3BaseDx.dll (class i3BinList *)
    CBody*                pBody;                    //0x1E8 (class i3Body *)
    CNode*                pWorldSpace;            //0x1EC (class i3Node*)
    CAnimation*            pAnimation;                //0x1F0 definido em i3MathDx.dll (class i3Animation*)
};
///////////////////////////////////////////////////////////////////////////////////////
class CTransform
{
public:
    char                unk1[400];
    D3DXMATRIX*            pCacheMatrix;            //0x190    union _tagi3Matrix *
    char                unk2[60];
    CMatrixObject*        pMatrixObject;            //0x1D0 i3MatrixObject *
    UINT                uiUpdateFrameID;        //0x1D4
    bool                bAnimated;                //0x1D8
};
///////////////////////////////////////////////////////////////////////////////////////
class CSceneGraphInfo
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////
class CUIRenderer
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////

class CList //i3List
{
public:
    char             unk1[20];                //0x0
    DWORD            iCount;                    //0x14 
    char             unk2[10];                //0x16
    int                iOnceMode;                //0x20
    char            unk3[2];                //0x22
    DWORD*             pItemListArray[];        //0x24 
};
///////////////////////////////////////////////////////////////////////////////////////
class CBinList
{
public:

};
///////////////////////////////////////////////////////////////////////////////////////

class CViewer 
{
public:
  char                field_0[16];            
  UINT                m_uiState;                    //0x10    unsigned int
  DWORD*            m_pPhysixContext;            //0x14    class i3PhysixContext *
  CRenderContext*    m_pRenderContext;            //0x18    i3RenderContext*
  CSceneTracer*        m_pSceneTracer;                //0x1C    i3SceneTracer*
  char                field_20[12];
  DWORD*            m_pInputDeviceManager;        //0x2C    i3InputDeviceManager*
  DWORD*            m_pTimer;                    //0x30    class i3Timer *
  float                m_fUserTime;                //0x34    float
  float                m_fTimeScale;                //0x38    float
  float                m_fDeltaTime;                //0x3C    float
  DWORD*            m_pFramework;                //0x40    class i3Framework *
  DWORD*            m_pWindowHandle;            //0x44    HWND*
  char                field_48[16];
  bool                m_bFixedResolution;            //0x58    bool

    CRenderContext* GetRenderContext(void)
    {
        if (m_pRenderContext)
        {
            return m_pRenderContext;
        }

        return 0;
    }

};
///////////////////////////////////////////////////////////////////////////////////////
class CResourceManager
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////
class CObject //i3Object
{
public:
    char            unk1[532];
    float            fCurrentHP;                //0x214 float
};
///////////////////////////////////////////////////////////////////////////////////////
class CStage //i3Stage
{
public:
    char            unk1[320];
    CList*            m_pObjectList;                //0x140 i3List*
    char            unk2[16];
    CList*            m_pGameSceneInfo;            //0x154 i3List*
};
///////////////////////////////////////////////////////////////////////////////////////
class CFramework //dword_104CBCC4
{
public:
    char                unk1[564];
    CViewer*            m_pViewer;                //0x234 class i3Viewer*
    CResourceManager*    m_pResourceManager;        //0x238 class i3ResourceManager*
    char                unk2[4];                //0x23C
    CStage*                m_pCurrentStage;        //0x240 class i3Stage*
    char                unk3[48];                //0x244
    CCamera*            m_pDefaultCamera;        //0x274 class i3Camera*
    char                unk4[308];                //0x278
    CUIRenderer*        m_pUIRenderer;            //0x3AC class i3UIRenderer*
};
///////////////////////////////////////////////////////////////////////////////////////
class CGameObj    //i3GameObj
{
public:
    char            unk1[464];
    CTransform*        pTransform;            //0x1D0

    //teste
    D3DXMATRIX GetMatrix1(void)
    {
        if (pTransform && pTransform->pMatrixObject)
        {
            return pTransform->pMatrixObject->d3dxmatrix;
        }
    }

};
///////////////////////////////////////////////////////////////////////////////////////
class CGameNode
{
public:
    char            unk1[276];
    UINT            uiGNodeStyle;        //0x114
    UINT            uiGNodeState;        //0x118
    CGameNode*        pParent;            //0x11C
    float            fUpdateInterval;    //0x120
    float            fLifeTime;            //0x124
    char            unk2[12];
    CGameNode*        pFirstChild;        //0x134
    float            fElapsedTime;        //0x138
};
///////////////////////////////////////////////////////////////////////////////////////
class CWorldSectionTable
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////
class CMapSectorTable
{
public:
};
///////////////////////////////////////////////////////////////////////////////////////
class CWorld
{
public:
    char                unk1[552];
    CSceneGraphInfo*    pSky;                    //0x228
    CSceneGraphInfo*    pWorldCollision;        //0x22C
    CSceneGraphInfo*    pHitCollision;            //0x230
    CSceneGraphInfo*    pLightVolumeCollision;    //0x234
    CWorldSectionTable*    pWorldSectionTable;        //0x238
    CMapSectorTable*    pMapSectorTable;        //0x23C

};
///////////////////////////////////////////////////////////////////////////////////////

class CStageBattle 
{
public:
    char        unk728[728];        //
    float        fExitTime;            //    0x2D8    
    float        fMessageTime;        //    0x2DC   
    float        fMembro_2E0;        //    0x2E0    
    float        fMembro_2E4;        //    0x2E4    
};    CStageBattle *StageBattle;

class CInputMouse //em i3InputDx.dll
{
public:
    char        unk22[22];
    float        m_fDeltaX;        //    0x2C
    float        m_fDeltaY;        //    0x30
    float        m_fDeltaZ;        //    0x34
};

class pCFramework    // 0x4CBCC4
{
public:
    char            unk1092[1092];
    CInputMouse*    m_pInputMouse;        //    0x444
};    pCFramework*    Framework;

//////
//Define it
Framework        = *(pCFramework**)(uBase_PB + 0x4CBCC4);
/////

    if (Framework)
    {
        if (Framework->m_pInputMouse)
        {
            char strInputMouse[50];
            sprintf(strInputMouse, "InputMouse: %.2f (%.2f) %.2f", Framework->m_pInputMouse->m_fDeltaX, Framework->m_pInputMouse->m_fDeltaY, Framework->m_pInputMouse->m_fDeltaZ);
            if (g_font) D3DDrawText(strInputMouse, (int)ScreenCenterX - 200, 220 , 30, 30,255,0,0);
        }
    }