CCamera::CCamera() : forward(1.0f, 0.0f, 0.0f), rot(0.0f, 0.0f, 0.0f), pos(2000.0f, 70.0f, 1800.0f), posOffset(0.0f, 0.0f, 0.0f), tiltOffset(0.0f, 0.0f, 0.0f), lppScale(0.0f)
{
// stuff that wont change can be initialised here, it doesn't need to be reinitialised every update
modelview[ 3] = 0.0f;
modelview[ 7] = 0.0f;
modelview[11] = 0.0f;
modelview[15] = 1.0f;
projection[ 1] = 0.0f;
projection[ 2] = 0.0f;
projection[ 3] = 0.0f;
projection[ 4] = 0.0f;
projection[ 6] = 0.0f;
projection[ 7] = 0.0f;
projection[12] = 0.0f;
projection[13] = 0.0f;
projection[15] = 0.0f;
billboard[3] = billboard[7] = billboard[11] = 0.0;
billboard[12] = billboard[13] = billboard[14] = 0.0;
billboard[15] = 1.0;
SetFov(45.0f);
up = UpVector;
if (billboardList == 0) {
billboardList = glGenLists(1);
}
}
CCamera::CCamera()
: pos(2000.0f, 70.0f, 1800.0f)
, rot(0.0f, 0.0f, 0.0f)
, forward(1.0f, 0.0f, 0.0f)
, posOffset(0.0f, 0.0f, 0.0f)
, tiltOffset(0.0f, 0.0f, 0.0f)
, lppScale(0.0f)
, fov(0.0f)
, halfFov(0.0f)
, tanHalfFov(0.0f)
{
memset(viewport, 0, 4*sizeof(int));
memset(viewMat, 0, 16*sizeof(double));
memset(viewMatInv, 0, 16*sizeof(double));
memset(projMat, 0, 16*sizeof(double));
memset(bboardMat, 0, 16*sizeof(double));
// stuff that will not change can be initialised here,
// so it does not need to be reinitialised every update
viewMat[15] = 1.0;
bboardMat[15] = 1.0;
SetFov(45.0f);
up = UpVector;
if (billboardList == 0) {
billboardList = glGenLists(1);
}
}
CCamera::CCamera()
: rot(ZeroVector)
, forward(RgtVector)
, up(UpVector)
, posOffset(ZeroVector)
, tiltOffset(ZeroVector)
, pos(ZeroVector)
, fov(0.0f)
, halfFov(0.0f)
, tanHalfFov(0.0f)
, lppScale(0.0f)
{
if (gs) {
// center map
pos = float3(gs->mapx * 0.5f * SQUARE_SIZE, 1000.f, gs->mapy * 0.5f * SQUARE_SIZE);
}
memset(viewport, 0, 4 * sizeof(int));
memset(movState, 0, sizeof(movState));
memset(rotState, 0, sizeof(rotState));
// stuff that will not change can be initialised here,
// so it does not need to be reinitialised every update
projectionMatrix[15] = 0.0f;
billboardMatrix[15] = 1.0f;
SetFov(45.0f);
}
Rasterizer::Rasterizer(const unsigned width, const unsigned height, const float degrees)
{
int w = width;
int h = height;
SetFov(degrees);
_leftUBounds = new float[h];
_rightUBounds = new float[h];
_leftVBounds = new float[h];
_rightVBounds = new float[h];
_leftColor = new Color[h];
_rightColor = new Color[h];
_leftZBounds = new float[h];
_rightZBounds = new float[h];
_leftBounds = new int[h];
_rightBounds = new int[h];
_leftWBounds = new float[h];
_rightWBounds = new float[h];
_pixels.resize(width * height);
_width = w;
_height = h;
ResetBounds();
_nearPlane = 2;
_farPlane = 100;
_zBuff.resize(width * height);
SetUpMatrices();
ResetZBuff();
_basisOrigin = Vertex(0.0f, 0.0f, 0.0f);
_basisP = Vertex(Color(1.0f, 0.0f, 0.0f), 1.0f, 0.0f, 0.0f);
_basisQ = Vertex(Color(0.0f, 1.0f, 0.0f), 0.0f, 1.0f, 0.0f);
_basisR = Vertex(Color(0.0f, 0.0f, 1.0f), 0.0f, 0.0f, 1.0f);
}
void Camera::AddFov(float fov)
{
float oldFov = m_viewPort->GetFov();
if(oldFov >= 1.0f && oldFov <= 45.0f)
{
float newFov = oldFov + fov;
SetFov(newFov);
}
else if(oldFov < 1.0)
{
SetFov(1.0);
}
else
{
SetFov(45.0f);
}
}
//----------------------------------------------------------------------------------------------------------
// Camera
//----------------------------------------------------------------------------------------------------------
//Camera::Camera(char *Nom, Ufloat sx, Ufloat sy )
Camera::Camera(LPCSTR Nom) {
nom = Nom;
SetPos(PosParDefaut);
SetTarg(TargParDefaut);
SetRoll(.0f);
SetFov(75.f);
CalcVue();
// SetClipFenetre( sx, sy );
Viewport viewport; // viewport de la camera
UpdateProjectMatrix();
UpdateTransMatrix();
UpdatePlans();
Spos = NULL;
Starg = NULL;
Sroll = NULL;
Sfov = NULL;
callbackAnim = NULL;
}
int main(int argc, char* argv[])
{
try
{
std::cout << "HadesMem ESO Mod [" << HADESMEM_VERSION_STRING << "]\n";
TCLAP::CmdLine cmd{"ESO Mod", ' ', HADESMEM_VERSION_STRING};
TCLAP::ValueArg<DWORD> pid_arg{"",
"pid",
"Process ID (for multiple ESO instances)",
false,
0,
"DWORD",
cmd};
// This should probably have some value constraints set, but it's more
// entertaining to leave it open so people can set it to silly values.
TCLAP::ValueArg<float> fov_arg{
"",
"fov",
"Set vertical field of view (in degrees) (default "
"50.0) for both perspectives",
false,
50.0f,
"float",
cmd};
TCLAP::ValueArg<float> fov_3p_arg{
"",
"fov-3p",
"Set vertical field of view (in degrees) (default 50.0) for 3rd person",
false,
50.0f,
"float",
cmd};
TCLAP::ValueArg<float> fov_1p_arg{
"",
"fov-1p",
"Set vertical field of view (in degrees) (default 50.0) for 1st person",
false,
50.0f,
"float",
cmd};
TCLAP::ValueArg<float> max_camera_distance_arg{
"",
"max-camera-dist",
"Set max camera zoom distance (default 10.0)",
false,
10.0f,
"float",
cmd};
TCLAP::ValueArg<float> time_arg{"",
"time",
"Set time (to change day/night/etc) (range "
"of [0, 24), e.g. 13.5 for 1330)",
false,
12.0f,
"float",
cmd};
// Values above 5 seem to be invalid, but leave it open in case that changes
// in the future (that way if the patterns don't need updating I don't need
// to do anything).
TCLAP::ValueArg<std::uint32_t> tone_mapping_arg{
"",
"tone-mapping",
"Set tone mapping type (a.k.a shader filters) (range of [0, 5])",
false,
0,
"uint32_t",
cmd};
TCLAP::ValueArg<float> min_view_distance_arg{
"",
"min-view-dist",
"Set minimum view distance. (default 0.4)",
false,
0.40000001f,
"float",
cmd};
TCLAP::ValueArg<float> max_view_distance_arg{
"",
"max-view-dist",
"Set maximum view distance (default 2.0)",
false,
2.0f,
"float",
cmd};
TCLAP::ValueArg<float> cur_view_distance_arg{
"",
"view-dist",
"Set current view distance (range of [min-view-dist, max-view-dist])",
false,
2.0f,
"float",
cmd};
TCLAP::SwitchArg fog_arg{"", "fog", "Toggle fog (default on)", cmd};
TCLAP::SwitchArg anaglyph_arg{
"", "3d", "Toggle anaglyph 3D (default off)", cmd};
TCLAP::SwitchArg fader_arg{
"",
"fader",
"Toggle fader (turn off to force high quality models) (default on)",
cmd};
cmd.parse(argc, argv);
try
{
hadesmem::GetSeDebugPrivilege();
std::wcout << "\nAcquired SeDebugPrivilege.\n";
}
catch (std::exception const& /*e*/)
{
std::wcout << "\nFailed to acquire SeDebugPrivilege.\n";
}
std::unique_ptr<hadesmem::Process> process;
if (pid_arg.isSet())
{
DWORD const pid = pid_arg.getValue();
process = std::make_unique<hadesmem::Process>(pid);
}
else
{
std::wstring const kProcName = L"eso.exe";
process = std::make_unique<hadesmem::Process>(
hadesmem::GetProcessByName(kProcName, false));
}
bool const set_fov_both = fov_arg.isSet();
bool const set_fov_3p = fov_3p_arg.isSet();
bool const set_fov_1p = fov_1p_arg.isSet();
if (set_fov_both)
{
if (set_fov_3p || set_fov_1p)
{
HADESMEM_DETAIL_THROW_EXCEPTION(
hadesmem::Error{} << hadesmem::ErrorString{
"Please set the FoV using either the perspective-specific flags or "
"the general flag, but not both."});
}
float* fov_both = &fov_arg.getValue();
SetFov(*process, fov_both, fov_both);
}
else if (set_fov_3p || set_fov_1p)
{
float* fov_3p = set_fov_3p ? &fov_3p_arg.getValue() : nullptr;
float* fov_1p = set_fov_1p ? &fov_1p_arg.getValue() : nullptr;
SetFov(*process, fov_3p, fov_1p);
}
if (max_camera_distance_arg.isSet())
{
SetMaxCameraDistance(*process, max_camera_distance_arg.getValue());
}
if (time_arg.isSet())
{
SetTime(*process, time_arg.getValue());
}
if (tone_mapping_arg.isSet())
{
SetToneMappingType(*process, tone_mapping_arg.getValue());
}
bool const set_min_view_distance = min_view_distance_arg.isSet();
bool const set_max_view_distance = max_view_distance_arg.isSet();
bool const set_cur_view_distance = cur_view_distance_arg.isSet();
if (set_min_view_distance || set_max_view_distance || set_cur_view_distance)
{
auto const min_view_distance =
set_min_view_distance ? &min_view_distance_arg.getValue() : nullptr;
auto const max_view_distance =
set_max_view_distance ? &max_view_distance_arg.getValue() : nullptr;
auto const cur_view_distance =
set_cur_view_distance ? &cur_view_distance_arg.getValue() : nullptr;
SetViewDistances(
*process, min_view_distance, max_view_distance, cur_view_distance);
}
if (fog_arg.isSet())
{
ToggleFog(*process);
}
if (anaglyph_arg.isSet())
{
Toggle3D(*process);
}
if (fader_arg.isSet())
{
ToggleFader(*process);
}
std::cout << "\nFinished.\n";
return 0;
}
catch (...)
{
std::cerr << "\nError!\n";
std::cerr << boost::current_exception_diagnostic_information() << '\n';
return 1;
}
}
