khanat-opennel-code/code/ryzom/client/src/camera_recorder.cpp
2010-05-06 02:08:41 +02:00

303 lines
7 KiB
C++

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#include "nel/misc/time_nl.h"
#include "nel/misc/path.h"
#include "nel/misc/command.h"
#include "nel/misc/file.h"
#include "nel/3d/u_camera.h"
#include "interface_v3/action_handler.h"
#include "client_cfg.h"
#include "view.h"
//
#include <algorithm>
using namespace NLMISC;
using namespace NL3D;
// TODO nico : that stuff was coded in a hurry, but could be good to add it to NL3D with a better packaging later...
//extern UCamera MainCam;
extern CView View;
// state ofthe recorder
enum TState
{
Idle,
Recording,
PlayBack
};
// camera sample
class CSample
{
public:
TTime Date;
CVector Pos;
CVector Heading;
//CVMatrix Matrix;
public:
void serial(NLMISC::IStream &f) throw(EStream)
{
f.serial(Date);
f.serial(Pos);
f.serial(Heading);
//f.serial(Matrix);
}
};
bool operator<(const CSample &lhs, const CSample &rhs)
{
return lhs.Date < rhs.Date;
}
typedef std::vector<CSample> TTrack;
// recorder
static TState State = Idle; // current state of the camera recorder
static TTime TimeOrigin = 0; // time origin for record or playback
static TTrack Track;
bool isRecordingCamera()
{
return State == Recording;
}
void updateCameraRecorder()
{
switch(State)
{
case Idle:
// no-op
break;
case Recording:
{
CSample sample;
sample.Date = CTime::getLocalTime() - TimeOrigin;
//sample.Matrix = MainCam.getMatrix();
sample.Pos = View.viewPos();
sample.Heading = View.view();
if (Track.empty())
{
// push first sample
Track.push_back(sample);
}
else if (sample.Date > Track.back().Date)
{
// push a new sample only if more recent
Track.push_back(sample);
}
}
break;
case PlayBack:
{
if (Track.empty())
{
State = Idle;
break;
}
TTime date = CTime::getLocalTime() - TimeOrigin;
CSample compVal;
compVal.Date = date;
TTrack::const_iterator it = std::lower_bound(Track.begin(), Track.end(), compVal);
if (it == Track.end())
{
//MainCam.setMatrix(Track.back().Matrix);
View.viewPos(Track.back().Pos);
View.view(Track.back().Heading);
State = Idle;
break;
}
if (it == Track.begin())
{
//MainCam.setMatrix(Track.back().Matrix);
View.viewPos(Track.front().Pos);
View.view(Track.front().Heading);
break;
}
const CSample &s0 = *(it - 1);
const CSample &s1 = *it;
float lambda = float(date - s0.Date) / float(s1.Date - s0.Date);
//
CVector pos;
CVector heading;
//
if (ClientCfg.CameraRecorderBlend)
{
pos = lambda * s1.Pos + (1.f - lambda) * s0.Pos;
heading = (lambda * s1.Heading + (1.f - lambda) * s0.Heading).normed();
}
else
{
pos = s0.Pos;
heading = s0.Heading;
}
View.viewPos(pos);
View.view(heading);
/*
CVector pos = lambda * s1.Matrix.getPos() + (1.f - lambda) * s0.Matrix.getPos();
CVector I = lambda * s1.Matrix.getI() + (1.f - lambda) * s0.Matrix.getI();
I.normalize();
CVector J = lambda * s1.Matrix.getJ() + (1.f - lambda) * s0.Matrix.getJ();
J = (J - (J * I) * I).normed();
CVector K = I ^ J;
CMatrix mat;
mat.setPos(pos);
mat.setRot(I, J, K);
UTransform::TTransformMode oldMode = MainCam.getTransformMode();
MainCam.setTransformMode(UTransformable::DirectMatrix);
MainCam.setMatrix(mat);
MainCam.setTransformMode(oldMode);
*/
}
break;
}
};
// ***************************************************************************
class CAHToggleCameraRecorder : public IActionHandler
{
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
{
if (State == Recording)
{
State = Idle;
return;
}
State = Recording;
TimeOrigin = CTime::getLocalTime();
Track.clear();
}
};
// ***************************************************************************
REGISTER_ACTION_HANDLER (CAHToggleCameraRecorder, "toggle_camera_recorder");
// ***************************************************************************
class CAHCameraRecorderPlayback : public IActionHandler
{
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
{
if (State == PlayBack)
{
State = Idle;
return;
}
State = PlayBack;
TimeOrigin = CTime::getLocalTime();
}
};
// ***************************************************************************
REGISTER_ACTION_HANDLER (CAHCameraRecorderPlayback, "camera_recorder_playback");
// ***************************************************************************
class CAHSaveCameraRecord : public IActionHandler
{
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
{
try
{
std::string filename = ClientCfg.CameraRecorderPrefix + ".cr";
if (!ClientCfg.CameraRecorderPath.empty())
{
filename = ClientCfg.CameraRecorderPath + "/" + filename;
}
filename = CFile::findNewFile(filename);
if (!filename.empty())
{
COFile f(filename);
f.serialVersion(0);
f.serialCont(Track);
}
else
{
nlwarning("Couldn't compute camera recorder next filename");
}
}
catch(EStream &e)
{
nlwarning(e.what());
}
}
};
// ***************************************************************************
REGISTER_ACTION_HANDLER (CAHSaveCameraRecord, "save_camera_record");
// ***************************************************************************
NLMISC_COMMAND(loadCamRec, "Load a camera path record file (.cr)", "<filename>")
{
if(args.empty())
return false;
std::string filename = args[0];
string::size_type pos = args[0].find_last_of ('.');
if (pos == string::npos)
{
filename += ".cr";
}
std::string path;
std::string searchFilename = filename;
if (!ClientCfg.CameraRecorderPath.empty())
{
searchFilename = ClientCfg.CameraRecorderPath + "/" + searchFilename;
}
if (CFile::fileExists(searchFilename))
{
path = searchFilename;
}
else
{
path = CPath::lookup(filename, false, true);
}
if (!path.empty())
{
try
{
CIFile f(path);
f.serialVersion(0);
f.serialCont(Track);
State = Idle;
}
catch(EStream &e)
{
nlwarning(e.what());
}
}
return true;
}