// Get fully qualified path from module name. Assumes base directory is the
// directory of the currently executing binary.
std::tstring Injector::GetPath( const std::tstring& ModuleName )
{
// Get handle to self
HMODULE Self = GetModuleHandle(NULL);
// Get path to loader
std::vector<TCHAR> LoaderPath(MAX_PATH);
if (!GetModuleFileName(Self,&LoaderPath[0],static_cast<DWORD>(LoaderPath.size())) ||
GetLastError() == ERROR_INSUFFICIENT_BUFFER)
throw std::runtime_error("Could not get path to loader.");
// Convert path to loader to path to module
std::tstring ModulePath(&LoaderPath[0]);
ModulePath = ModulePath.substr(0, ModulePath.rfind( _T("\\") ) + 1);
ModulePath.append(ModuleName);
// Check path/file is valid
if (GetFileAttributes(ModulePath.c_str()) == INVALID_FILE_ATTRIBUTES)
{
std::string NewModulePath(ModulePath.begin(),ModulePath.end());
throw std::runtime_error("Could not find module. Path: '" + NewModulePath + "'.");
}
// Return module path
return ModulePath;
}
//-----------------------------------------------------------------------------
inline static dog::IEventTracing* CreateDOGFromLocalDirDLL(HINSTANCE* phDLL)
{
const TCHAR* DOGDLL_FileName = _T("DOG.DLL");
std::basic_string<TCHAR> ModulePath(MAX_PATH, NULL);
::GetModuleFileName(reinterpret_cast<HMODULE>(&__ImageBase), &ModulePath[0], MAX_PATH);
ModulePath.replace(ModulePath.begin() + ModulePath.find_last_of(_T('\\')) + 1, ModulePath.end(), DOGDLL_FileName);
HINSTANCE hDLL = LoadLibrary(ModulePath.c_str());
dog::IEventTracing* pDOG = NULL;
if(hDLL)
{
typedef void* (*LPCreateComponentT)(void);
LPCreateComponentT pCreateComponent = reinterpret_cast<LPCreateComponentT>(GetProcAddress(hDLL, "CreateComponent"));
if(pCreateComponent)
{
pDOG = reinterpret_cast<dog::IEventTracing*>(pCreateComponent());
}
else
{
::FreeLibrary(hDLL);
hDLL = NULL;
}
}
if(phDLL)
{
*phDLL = hDLL;
}
return pDOG;
}
HMODULE WINAPI HookLL::HookLoadLibraryExA(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
{
if (!InputHookManager::Get().GetInputHook().GetState(InputHook::HOOK_LL)) return TrueLoadLibraryExA(lpLibFileName, hFile, dwFlags);
if (SelfCheckA(lpLibFileName))
{
PrintLog("LoadLibraryExA");
InputHookManager::Get().GetInputHook().StartTimeoutThread();
std::string path;
if (ModulePath(&path, InputHookManager::Get().GetInputHook().GetEmulator()))
return TrueLoadLibraryExA(path.c_str(), hFile, dwFlags);
else
return TrueLoadLibraryExA(lpLibFileName, hFile, dwFlags);
}
return TrueLoadLibraryExA(lpLibFileName, hFile, dwFlags);
}
HMODULE WINAPI HookLL::HookLoadLibraryW(LPCWSTR lpLibFileName)
{
if (!InputHookManager::Get().GetInputHook().GetState(InputHook::HOOK_LL)) return TrueLoadLibraryW(lpLibFileName);
if (SelfCheckW(lpLibFileName))
{
PrintLog("LoadLibraryW");
InputHookManager::Get().GetInputHook().StartTimeoutThread();
std::wstring path;
if (ModulePath(&path, InputHookManager::Get().GetInputHook().GetEmulator()))
return TrueLoadLibraryW(path.c_str());
else
return TrueLoadLibraryW(lpLibFileName);
}
return TrueLoadLibraryW(lpLibFileName);
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
TheLuaManager->init();
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
//Setup the Lua Manager
BoostPath ModulePath("./Data/");
std::string PackagePath = std::string("?;")
+ (ModulePath / "?.lua" ).file_string() + ";"
+ (ModulePath / "?" / "init.lua").file_string();
TheLuaManager->setPackagePath(PackagePath);
// Make Torus Node (creates Torus in background of scene)
GeometryRefPtr TorusGeometry = makeTorusGeo(.5, 2, 16, 16);
setName(TorusGeometry,"Torus Geometry");
//calcVertexTangents(TorusGeometry,0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId);
NodeRefPtr TorusGeometryNode = Node::create();
setName(TorusGeometryNode,"Torus Geometry Node");
TorusGeometryNode->setCore(TorusGeometry);
//Torus Transformation Node
TransformRefPtr TheTorusNodeTransform = Transform::create();
NodeRefPtr TheTorusTransfromNode = Node::create();
TheTorusTransfromNode->setCore(TheTorusNodeTransform);
TheTorusTransfromNode->addChild(TorusGeometryNode);
setName(TheTorusTransfromNode,"Torus Transform Node");
// Make Main Scene Node and add the Torus
NodeRefPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TheTorusTransfromNode);
setName(scene,"Scene Node");
//Light Beacon Node
TransformRefPtr TheLightBeaconNodeTransform = Transform::create();
NodeRefPtr TheLightBeaconNode = Node::create();
TheLightBeaconNode->setCore(TheLightBeaconNodeTransform);
setName(TheLightBeaconNode,"Light Beacon Node");
//Light Node
DirectionalLightRefPtr TheLightCore = DirectionalLight::create();
TheLightCore->setDirection(Vec3f(1.0,0.0,0.0));
TheLightCore->setAmbient(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setDiffuse(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setSpecular(Color4f(1.0,1.0,1.0,1.0));
TheLightCore->setBeacon(TheLightBeaconNode);
NodeRefPtr TheLightNode = Node::create();
TheLightNode->setCore(TheLightCore);
TheLightNode->addChild(scene);
setName(TheLightNode,"Light Node");
NodeRefPtr RootNode = Node::create();
RootNode->setCore(Group::create());
RootNode->addChild(TheLightNode);
RootNode->addChild(TheLightBeaconNode);
setName(RootNode,"Root Node");
// Create the Graphics
GraphicsRefPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Create the Main interface
LuaDebuggerInterface TheLuaDebuggerInterface;
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
BorderLayoutRefPtr MainInternalWindowLayout = BorderLayout::create();
//Split Panel
BorderLayoutConstraintsRefPtr SplitPanelConstraints = BorderLayoutConstraints::create();
SplitPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_CENTER);
TheLuaDebuggerInterface.getMainSplitPanel()->setConstraints(SplitPanelConstraints);
BorderLayoutConstraintsRefPtr ButtonPanelConstraints = BorderLayoutConstraints::create();
ButtonPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_NORTH);
TheLuaDebuggerInterface.getButtonPanel()->setConstraints(ButtonPanelConstraints);
BorderLayoutConstraintsRefPtr CodeAreaInfoPanelConstraints = BorderLayoutConstraints::create();
CodeAreaInfoPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH);
TheLuaDebuggerInterface.getCodeAreaInfoPanel()->setConstraints(CodeAreaInfoPanelConstraints);
InternalWindowRefPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getButtonPanel());
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getMainSplitPanel());
MainInternalWindow->pushToChildren(TheLuaDebuggerInterface.getCodeAreaInfoPanel());
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setTitle("Lua Debugger");
setName(MainInternalWindow,"Internal Window");
// Create the Drawing Surface
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
//Scene Background
GradientBackgroundRefPtr SceneBackground = GradientBackground::create();
SceneBackground->addLine(Color3f(0.0,0.0,0.0),0.0);
setName(SceneBackground,"Scene Background");
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
sceneManager.setRoot(RootNode);
//sceneManager.setHeadlight(false);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
TutorialViewport->setBackground(SceneBackground);
TutorialWindow->connectKeyTyped(boost::bind(keyTyped,
_1,
&TheLuaDebuggerInterface));
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"03LuaDebugger");
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setPreferredSize(WinSize * 0.85);
//Enter main Loop
TutorialWindow->mainLoop();
TheLuaManager->uninit();
}
osgExit();
return 0;
}
RetCode BOSS_CALL ServiceRegistry::Load(IIStream *stream)
{
if (!stream)
return Status::InvalidArgument;
std::lock_guard<std::recursive_mutex> Lock(Mtx);
try
{
auto Registry = PropertyBagType::Create(RegistryTag);
RetCode Code = Registry->Load(stream);
if (Code != Status::Ok)
return Code;
RefObjPtr<IBase> ServiceEnumProp;
if ((Code = Registry->GetProperty(ServicesTag, ServiceEnumProp.GetPPtr())) != Status::Ok)
return Code;
RefObjQIPtr<IEnum> ServiceEnum(ServiceEnumProp);
if (!ServiceEnum.Get())
return Status::Fail;
ServicePool NewServices;
for (RefObjPtr<IBase> i ; ServiceEnum->Next(i.GetPPtr()) == Status::Ok ; i.Release())
{
RefObjQIPtr<IPropertyBag> ServiceItem(i);
if (!ServiceItem.Get())
return Status::Fail;
RefObjPtr<IBase> EntId;
if ((Code = ServiceItem->GetProperty(ServiceIdTag, EntId.GetPPtr())) != Status::Ok)
return Code;
RefObjQIPtr<IEntityId> EntSrvId(EntId);
if (!EntSrvId.Get())
return Status::Fail;
ServiceId SrvId = 0;
if ((Code = EntSrvId->GetId(&SrvId)) != Status::Ok)
return Code;
RefObjPtr<IBase> ClassIdsEnumProp;
if ((Code = ServiceItem->GetProperty(ClassIdsTag, ClassIdsEnumProp.GetPPtr())) != Status::Ok)
return Code;
RefObjQIPtr<IEnum> ClassIdsEnum(ClassIdsEnumProp);
if (!ClassIdsEnum.Get())
return Status::Fail;
RefObjPtr<IBase> ModulePathProp;
RefObjPtr<IServiceInfo> ServiceInfo;
if (ServiceItem->GetProperty(ModulePathTag, ModulePathProp.GetPPtr()) == Status::Ok)
{
RefObjQIPtr<IString> ModulePath(ModulePathProp);
if (!ModulePath.Get())
return Status::Fail;
auto LocalSrvInfo = Base<LocalServiceInfo>::Create();
LocalSrvInfo->SetServiceId(SrvId);
LocalSrvInfo->AddCoClassIds(ClassIdsEnum);
LocalSrvInfo->SetModulePath(ModulePath);
ServiceInfo = LocalSrvInfo;
}
else
{
RefObjPtr<IBase> RemotePropertiesProp;
if (ServiceItem->GetProperty(RemotePropertiesTag, RemotePropertiesProp.GetPPtr()) == Status::Ok)
{
RefObjQIPtr<IPropertyBag> RemoteProperties(RemotePropertiesProp);
if (!RemoteProperties.Get())
return Status::Fail;
auto RemoteSrvInfo = Base<RemoteServiceInfo>::Create();
RemoteSrvInfo->SetServiceId(SrvId);
RemoteSrvInfo->AddCoClassIds(ClassIdsEnum);
RemoteSrvInfo->SetProps(RemoteProperties);
ServiceInfo = RemoteSrvInfo;
}
else
return Status::Fail;
}
if ((Code = ClassIdsEnum->Reset()) != Status::Ok)
return Code;
for (RefObjPtr<IBase> j ; ClassIdsEnum->Next(j.GetPPtr()) == Status::Ok ; j.Release())
{
RefObjQIPtr<IEntityId> ClsId(j);
if (!ClsId.Get())
return Status::Fail;
ClassId Id = 0;
if ((Code = ClsId->GetId(&Id)) != Status::Ok)
return Code;
NewServices[Id] = ServiceInfo;
}
}
std::swap(Services, NewServices);
return Status::Ok;
}
catch (...)
{
return Status::Fail;
}
return Status::Ok;
}
