[GUIA] Fixeando Camara 3D a un MAIN + Dll

Encontre un TUTORIAL en el cual dice como fixear/Agregar la camara 3D a cualquiera MAIN , tambien dice como crear la DLL para el mismo
Esta traducido con el traductor de Babylon

este es mi pequeña guía para encontrar todas las indemnizaciones necesarias, en cualquier versión de los principales (excepto old school) para hacer una cámara 3D. Todo lo que necesitamos: Main.exe , ollydbg (1.10) .

Ahora, vamos a empezar! Abierto main.exe través ollydbg. Usted debe ver un poco como esto:


Vamos a trabajar sólo con el desalojo


Haga clic derecho sobre cualquier byte y seleccione "Float" -> "float de 32 bits."


Para realizar una cámara completa 3D que va a necesitar estos valores (nombre / valor por defecto / comentario):
Para fazer uma completa 3D câmera você vai precisar destes valores (nome / valor padrão / comentário): Para realizar una cámara completa en 3D tendrá que estos valores (nombre / valor por defecto / comentario):
Camera_Zoom = 35 - zooming in/out Camera_Zoom = 35 - zoom in / out
Camera_Zoom = 35 - zoom in / out Camera_Zoom = 35 - zoom in / out
Camera_RotY = -48.5 - rotate up/down Camera_RotY = -48,5 - gire hacia arriba / abajo
Camera_RotY = -48,5 - rodar para cima / baixo Camera_RotY = -48,5 - gire hacia arriba / abajo
Camera_RotZ = -45 - rotate left/right Camera_RotZ = -45 - girar a la izquierda / derecha
Camera_RotZ = -45 - roda esquerda / direita Camera_RotZ = -45 - rueda izquierda / derecha
Camera_PosZ = 150 - additional value for corrent Y rotating Camera_PosZ = 150 - un valor adicional para la rotación de corrent Y
Camera_PosZ = 150 - valor adicional para CORRENT Y rotativa Camera_PosZ = 150 - valor añadido para los rotativos Y corrent
Camera_ClipX = 1190 - area filled with textures, x value Camera_ClipX = 1190 - zona llena de texturas, el valor x
Camera_ClipX = 1190 - área cheia com texturas, x valor Camera_ClipX = 1190 - una zona llena de texturas, el valor x
Camera_ClipY = 2400 - area filled with textures, y value Camera_ClipY = 2400 - zona llena de texturas, valor y
Camera_ClipY = 2400 - área cheia com texturas, y valor Camera_ClipY = 2400 - una zona llena de texturas, valor y
Right click again on any value in Dump and select "Search for" -> "Float", Haga clic de nuevo en cualquier valor en Dump y seleccione "Búsqueda" -> "Float"
Clique novamente em qualquer valor em despejo e selecione "Procurar" -> "Float", Haga clic de nuevo en cualquier valor en quitar y seleccione "Buscar" -> "Float"


Ahora, en la ventana abierta, ponga el valor por defecto de desplazamiento necesario (por ejemplo ClipX):


y haga clic en Aceptar.
Lo encontramos!
es el valor de desviación en la columna izquierda de la fila con el valor buscado:


Haga lo mismo con otros valores, y usted encontrará a todos
Si algunos valores en OllyDbg Valor dice que no se encontró o no compensar el trabajo, cambio de intervalo de búsqueda.
Presione CTRL + G y el tipo en cualquier otra ventana en offset, por ejemplo, si la corriente se compensa 0x6AXXXX tipo 0x50XXXX
Créditos:
HelloMoto.- & J0StrikE
Tutorial Foi Tirado da HelloMoto.-

AHORA VAMOS A CREAR LA DLL

3DCamera.h

#pragma once
#include "stdafx.h"

#pragma data_seg(".SHAREDDATA")
static HHOOK KeyboardHook = NULL;
static HHOOK MouseHook = NULL;
#pragma data_seg()
#pragma comment(linker, "/SECTION:.SHAREDDATA,RWS")

static HINSTANCE hInstance;
bool MoveCamera = false;
bool InitCamera = true;
int MouseX, MouseY;

// ver.1.02f Main.exe Offsets
float *Camera_Zoom = (float*) 0x632CB1;
float *Camera_RotY = (float*) 0x6AB72C;
float *Camera_RotZ = (float*) 0x7D26120;
float *Camera_PosZ = (float*) 0x6A971C;
float *Camera_ClipX = (float*) 0x6AB638;
float *Camera_ClipY = (float*) 0x6AB640;
float *Camera_GlClip = (float*) 0x6A6B80;

struct CameraStruct {
float Zoom;
float RotY;
float RotZ;
float PosZ;
float ClipX;
float ClipY;
float GlClip;
} Camera;

LRESULT CALLBACK KeyboardProc(int, WPARAM, LPARAM);
LRESULT CALLBACK MouseProc(int, WPARAM, LPARAM);
BOOL MouseSetHook(BOOL);
BOOL KeyboardSetHook(BOOL);
Resource.h

//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by Window.rc
//

// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 1000
#define _APS_NEXT_COMMAND_VALUE 32771
#define _APS_NEXT_CONTROL_VALUE 1000
#define _APS_NEXT_SYMED_VALUE 1000
#endif
#endif
3DCamera.cpp

#include "stdafx.h"
#include "3DCamera.h"

int APIENTRY DllMain (HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved){
switch(dwReason){
case DLL_PROCESS_ATTACH:
hInstance = hInst;
KeyboardSetHook(true);
MouseSetHook(true);
break;
case DLL_PROCESS_DETACH:
KeyboardSetHook(false);
MouseSetHook(false);
break;
}
return true;
}

BOOL KeyboardSetHook(BOOL set_or_remove){
if(set_or_remove == TRUE){
if(KeyboardHook == NULL){
KeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC)KeyboardProc, hInstance, GetCurrentThreadId());
if(!KeyboardHook){ return FALSE; }
}
} else {
return UnhookWindowsHookEx(KeyboardHook);
KeyboardHook = NULL;
}
return TRUE;
}

BOOL MouseSetHook(BOOL set_or_remove){
if(set_or_remove == TRUE){
if(MouseHook == NULL){
MouseHook = SetWindowsHookEx(WH_MOUSE, MouseProc, hInstance, GetCurrentThreadId());
if(!MouseHook){ return FALSE; }
}
} else { return UnhookWindowsHookEx(MouseHook); }
return TRUE;
}

LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam){
if(((lParam>>31)&1) && (nCode == HC_ACTION)){
if(wParam == VK_F10){
*Camera_RotY = Camera.RotY;
*Camera_RotZ = -45;
*Camera_PosZ = Camera.PosZ;
*Camera_ClipX = Camera.ClipX;
*Camera_ClipY = Camera.ClipY;
*Camera_GlClip = Camera.GlClip;
*Camera_Zoom = Camera.Zoom;
}
}
return CallNextHookEx(KeyboardHook, nCode, wParam, lParam);
}

LRESULT CALLBACK MouseProc(int code, WPARAM wParam, LPARAM lParam){
MOUSEHOOKSTRUCTEX* mhs = (MOUSEHOOKSTRUCTEX*)lParam;
HWND MuWnd = FindWindow("MU", NULL);
if(GetForegroundWindow() == MuWnd){
if(InitCamera){
Camera.ClipX = *Camera_ClipX;
Camera.ClipY = *Camera_ClipY;
Camera.GlClip = *Camera_GlClip;
Camera.PosZ = *Camera_PosZ;
Camera.RotY = *Camera_RotY;
Camera.RotZ = *Camera_RotZ;
Camera.Zoom = *Camera_Zoom;
InitCamera = false;
}
if(wParam == WM_MOUSEWHEEL){
int direction = mhs->mouseData;
if(direction > 0){
if(*Camera_Zoom < 60){ *Camera_Zoom += 2; }
}
else if(direction < 0){
if(*Camera_Zoom > 12){ *Camera_Zoom -= 2; }
}
*Camera_ClipX = 1190 + (abs(*Camera_PosZ - 150) * 3) + 3000;
*Camera_ClipY = 2400 + (abs(*Camera_PosZ - 150) * 3) + 3000;
*Camera_GlClip = 3000 + (abs(*Camera_PosZ - 150) * 3) + 1500;
}
else if(wParam == WM_MBUTTONDOWN){
MouseX = mhs->pt.x;
MouseY = mhs->pt.y;
MoveCamera = true;
}
else if(wParam == WM_MBUTTONUP){
MoveCamera = false;
}
else if(wParam == WM_MOUSEMOVE){
if(MoveCamera){
if(MouseX < mhs->pt.x){
*Camera_RotZ += 8;
if (*Camera_RotZ > 315) *Camera_RotZ = -45;
}
else if(MouseX > mhs->pt.x){
*Camera_RotZ -= 8;
if (*Camera_RotZ < -405) *Camera_RotZ = -45;
}
if(MouseY < mhs->pt.y){
if(*Camera_RotY < -45){
*Camera_PosZ -= 44;
*Camera_RotY += (float)2.42;
}
}
else if(MouseY > mhs->pt.y){
if(*Camera_RotY > -90){
*Camera_PosZ += 44;
*Camera_RotY -= (float)2.42;
}
}

MouseX = mhs->pt.x;
MouseY = mhs->pt.y;

*Camera_ClipX = 1190 + (abs(*Camera_PosZ - 150) * 3) + 3000;
*Camera_ClipY = 2400 + (abs(*Camera_PosZ - 150) * 3) + 3000;
*Camera_GlClip = 3000 + (abs(*Camera_PosZ - 150) * 3) + 1500;
}
}
}
return CallNextHookEx(MouseHook, code, wParam, lParam);
}
3DCamera.def

LIBRARY "3DCamera"

EXPORTS
stdafx.h

#pragma once
#ifndef VC_EXTRALEAN
#define VC_EXTRALEAN
#endif
#ifndef WINVER
#define WINVER 0x0501
#endif
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
#ifndef _WIN32_WINDOWS
#define _WIN32_WINDOWS 0x0410
#endif
#ifndef _WIN32_IE
#define _WIN32_IE 0x0600
#endif
#include
#include
#pragma comment(lib, "User32.lib")
#pragma warning (disable : 4311 )
#pragma warning (disable : 4800 )
stdafx.cpp

#include "stdafx.h"
NOTA: Se adapta a cualquier versión que sólo necesita el desplazamiento de