/*virtual*/ void EldritchFramework::RefreshDisplay( const bool Fullscreen, const uint DisplayWidth, const uint DisplayHeight )
{
PRINTF( "EldritchFramework::RefreshDisplay\n" );
Framework3D::RefreshDisplay( Fullscreen, DisplayWidth, DisplayHeight );
m_TargetManager->CreateTargets( DisplayWidth, DisplayHeight );
UpdateViews();
ASSERT( m_Game );
m_Game->RefreshRTDependentSystems();
CreateBuckets();
}
/*virtual*/ void EldritchFramework::SetResolution(const uint DisplayWidth,
const uint DisplayHeight) {
PRINTF("EldritchFramework::SetResolution\n");
m_DisplayWidth = DisplayWidth;
m_DisplayHeight = DisplayHeight;
Framework3D::SetResolution(DisplayWidth, DisplayHeight);
m_TargetManager->CreateTargets(DisplayWidth, DisplayHeight);
UpdateViews();
ASSERT(m_Game);
m_Game->RefreshRTDependentSystems();
CreateBuckets();
}
int BucketElimination::BEworkspace::GenerateRandomBayesianNetworkStructure(int N, int K, int P, int C, int ProblemCharacteristic)
{
if (NULL == _Problem)
return 1 ;
_Problem->Destroy() ;
if (0 != _Problem->GenerateRandomUniformBayesianNetworkStructure(N, K, P, C, ProblemCharacteristic))
{ return 1 ; }
if (0 != _Problem->ComputeGraph())
{ return 1 ; }
int nComponents = _Problem->nConnectedComponents() ;
if (nComponents > 1)
{ return 1 ; }
if (0 != _Problem->ComputeMinDegreeOrdering())
{ return 1 ; }
int width = _Problem->MinDegreeOrdering_InducedWidth() ;
// if (width < MinWidth || width > MaxWidth)
// { return 1 ; }
if (0 != _Problem->TestVariableOrdering(_Problem->MinDegreeOrdering_VarList(), _Problem->MinDegreeOrdering_VarPos()))
{ return 1 ; }
if (0 != CreateBuckets(_Problem->N(), _Problem->MinDegreeOrdering_VarList(), true))
{ return 1 ; }
__int64 spaceO = _Problem->ComputeFunctionSpace() ;
__int64 spaceN = ComputeNewFunctionSpace() ;
__int64 space = spaceO + spaceN ;
// if (space < MinMemory || space > MaxMemory)
// { return 1 ; }
return 0 ;
}
int BucketElimination::BEworkspace::Initialize(ARE::ARP & Problem, const int *VarOrderingAsVarList)
{
if (! _IsValid || 0 != ARE::Workspace::Initialize(Problem))
return 1 ;
int i ;
if (VAR_ELIMINATION_TYPE_SUM_MAX == _FnCombination_VarElimination_Type)
_AnswerFactor = 0.0 ;
else
_AnswerFactor = 1.0 ;
if (_Problem ? _Problem->N() > 0 : false) {
_VarOrder = new int[_Problem->N()] ;
for (i = 0 ; i < _Problem->N() ; i++) {
_VarOrder[i] = -1 ;
}
// if ordering is not given, use one from the problem
if (NULL == VarOrderingAsVarList) {
if (NULL == _Problem->MinDegreeOrdering_VarList()) {
if (0 != _Problem->ComputeMinDegreeOrdering())
return 1 ;
if (0 != _Problem->TestVariableOrdering(_Problem->MinDegreeOrdering_VarList(), _Problem->MinDegreeOrdering_VarPos()))
return 1 ;
}
if (NULL == _Problem->MinFillOrdering_VarList()) {
if (0 != _Problem->ComputeMinFillOrdering(1, -1))
return 1 ;
if (0 != _Problem->TestVariableOrdering(_Problem->MinFillOrdering_VarList(), _Problem->MinFillOrdering_VarPos()))
return 1 ;
}
int minDegreeWidth = _Problem->MinDegreeOrdering_InducedWidth() ;
if (minDegreeWidth < 0) minDegreeWidth = 999999 ;
int minFillWidth = _Problem->MinFillOrdering_InducedWidth() ;
if (minFillWidth < 0) minFillWidth = 999999 ;
if (minDegreeWidth <= minFillWidth)
VarOrderingAsVarList = _Problem->MinDegreeOrdering_VarList() ;
else
VarOrderingAsVarList = _Problem->MinFillOrdering_VarList() ;
}
if (0 != CreateBuckets(_Problem->N(), VarOrderingAsVarList, true))
return 1 ;
// verify integrity of functions
for (i = 0 ; i < _Problem->nFunctions() ; i++) {
ARE::Function *f = _Problem->getFunction(i) ;
if (0 != f->CheckIntegrity())
return 1 ;
}
for (i = 0 ; i < _nBuckets ; i++) {
BucketElimination::Bucket *b = _Buckets[i] ;
ARE::Function & f = b->OutputFunction() ;
if (0 != f.CheckIntegrity())
return 1 ;
}
}
return 0 ;
}
/*virtual*/ void EldritchFramework::Initialize() {
XTRACE_FUNCTION;
XTRACE_BEGIN(PreFramework3D);
ReverseHash::Initialize();
PackStream::StaticAddPackageFile("eldritch-base.cpk");
FrameworkUtil::MinimalLoadConfigFiles("Config/default.ccf");
InitializePackages();
InitializeDLC();
// Load prefs over anything in the defaults.
LoadPrefsConfig();
LOADPRINTLEVELS;
STATICHASH(Version);
STATICHASH(ContentSyncer);
SimpleString LocalVersion =
ConfigManager::GetString(sVersion, "", sContentSyncer);
PRINTF("Version: %s\n", LocalVersion.CStr());
XTRACE_BEGIN(InitializeFactories);
PRINTF("Initializing factories...\n");
PRINTF("Initializing SDP factories.\n");
SDPFactory::InitializeBaseFactories();
#define ADDSDPFACTORY(type) \
SDPFactory::RegisterSDPFactory(#type, SDP##type::Factory);
#include "eldritchsdps.h"
#undef ADDSDPFACTORY
PRINTF("Initializing UI factories.\n");
UIFactory::InitializeBaseFactories();
#define ADDUISCREENFACTORY(type) \
UIFactory::RegisterUIScreenFactory(#type, UIScreen##type::Factory);
#include "eldritchuiscreens.h"
#undef ADDUISCREENFACTORY
PRINTF("Initializing anim event factories.\n");
#define ADDANIMEVENTFACTORY(type) \
AnimEventFactory::GetInstance()->Register(#type, AnimEvent##type::Factory);
#include "eldritchanimevents.h"
#undef ADDANIMEVENTFACTORY
PRINTF("Initializing PE factories.\n");
WBParamEvaluatorFactory::InitializeBaseFactories();
#define ADDWBPEFACTORY(type) \
WBParamEvaluatorFactory::RegisterFactory(#type, WBPE##type::Factory);
#include "rodinwbpes.h"
#include "eldritchwbpes.h"
#undef ADDWBPEFACTORY
PRINTF("Initializing action factories.\n");
WBActionFactory::InitializeBaseFactories();
#define ADDWBACTIONFACTORY(type) \
WBActionFactory::RegisterFactory(#type, WBAction##type::Factory);
#include "uiwbactions.h"
#include "rodinwbactions.h"
#include "eldritchwbactions.h"
#undef ADDWBPEFACTORY
PRINTF("Initializing BT factories.\n");
RodinBTNodeFactory::InitializeBaseFactories();
#define ADDRODINBTNODEFACTORY(type) \
RodinBTNodeFactory::RegisterFactory(#type, RodinBTNode##type::Factory);
#include "eldritchrodinbtnodes.h"
#undef ADDRODINBTNODEFACTORY
// Initialize core and Eldritch Workbench component factories.
PRINTF("Initializing component factories.\n");
WBComponent::InitializeBaseFactories();
#define ADDWBCOMPONENT(type) \
WBComponent::RegisterWBCompFactory(#type, WBComp##type::Factory);
#include "rodinwbcomponents.h"
#include "eldritchwbcomponents.h"
#undef ADDWBCOMPONENT
XTRACE_END;
PRINTF("Factories initialized.\n");
// Create input system before framework so it will exist for UI. But don't
// attach devices yet, as they don't exist.
PRINTF("Initializing input system.\n");
m_InputSystem = new InputSystem;
m_InputSystem->Initialize("EldritchInput");
XTRACE_END;
Framework3D::Initialize();
STATICHASH(DisplayWidth);
STATICHASH(DisplayHeight);
m_DisplayWidth = ConfigManager::GetInt(sDisplayWidth);
m_DisplayHeight = ConfigManager::GetInt(sDisplayHeight);
#if BUILD_WINDOWS
m_CheckForUpdates = new CheckForUpdates(m_UIManager);
#endif
m_Controller = new XInputController;
m_TargetManager = new EldritchTargetManager(m_Renderer);
m_TargetManager->CreateTargets(m_Display->m_Width, m_Display->m_Height);
m_Audio3DListener = new EldritchSound3DListener;
m_Audio3DListener->Initialize();
ASSERT(m_AudioSystem);
m_AudioSystem->Set3DListener(m_Audio3DListener);
STATICHASH(FOV);
const float FOV = ConfigManager::GetFloat(sFOV, 90.0f);
STATICHASH(ForegroundFOV);
const float FGFOV = ConfigManager::GetFloat(sForegroundFOV, 60.0f);
STATICHASH(NearClip);
const float NearClip = ConfigManager::GetFloat(sNearClip, 0.1f);
STATICHASH(FarClip);
const float FarClip = ConfigManager::GetFloat(sFarClip, 0.1f);
const float fDisplayWidth = static_cast<float>(m_DisplayWidth);
const float fDisplayHeight = static_cast<float>(m_DisplayHeight);
const float AspectRatio = fDisplayWidth / fDisplayHeight;
m_MainView =
new View(Vector(), Angles(), FOV, AspectRatio, NearClip, FarClip);
m_FGView =
new View(Vector(), Angles(), FGFOV, AspectRatio, NearClip, FarClip);
CreateHUDView();
CreateMirrorView();
CreateMinimapView();
CreateBuckets();
m_InputSystem->SetKeyboard(m_Keyboard);
m_InputSystem->SetMouse(m_Mouse);
m_InputSystem->SetController(m_Controller);
m_InputSystem->SetClock(m_Clock);
WBActionStack::Initialize();
PRINTF("Initializing Eldritch.\n");
InitializeWorld(HashedString(), false);
m_Game = new EldritchGame;
m_Game->RefreshRTDependentSystems();
m_Game->Initialize();
// Initialize config stuff
{
STATICHASH(InvertY);
const bool InvertY = ConfigManager::GetBool(sInvertY);
STATIC_HASHED_STRING(TurnY);
m_InputSystem->SetMouseInvert(sTurnY, InvertY);
m_InputSystem->SetControllerInvert(sTurnY, InvertY);
STATICHASH(ControllerPower);
const float ControllerPower = ConfigManager::GetFloat(sControllerPower);
STATIC_HASHED_STRING(MoveX);
m_InputSystem->SetControllerPower(sMoveX, ControllerPower);
STATIC_HASHED_STRING(MoveY);
m_InputSystem->SetControllerPower(sMoveY, ControllerPower);
STATIC_HASHED_STRING(TurnX);
m_InputSystem->SetControllerPower(sTurnX, ControllerPower);
m_InputSystem->SetControllerPower(sTurnY, ControllerPower);
}
// Initialize UI sliders. This could be neater.
// This also pushes the initial values to their respective systems, which is
// pret-ty terrible design.
{
WBEventManager* pEventManager = WBWorld::GetInstance()->GetEventManager();
{
STATICHASH(MouseSpeed);
const float MouseSpeed = ConfigManager::GetFloat(sMouseSpeed, 1.0f);
STATIC_HASHED_STRING(ControlsOptionsScreen);
STATIC_HASHED_STRING(MouseSpeedSlider);
WB_MAKE_EVENT(SetUISliderValue, NULL);
WB_SET_AUTO(SetUISliderValue, Hash, Screen, sControlsOptionsScreen);
WB_SET_AUTO(SetUISliderValue, Hash, Widget, sMouseSpeedSlider);
WB_SET_AUTO(SetUISliderValue, Float, SliderValue,
GetSliderValueFromMouseSpeed(MouseSpeed));
WB_DISPATCH_EVENT(pEventManager, SetUISliderValue, NULL);
}
{
STATICHASH(ControllerSpeed);
const float ControllerSpeed =
ConfigManager::GetFloat(sControllerSpeed, 1.0f);
STATIC_HASHED_STRING(ControlsOptionsScreen);
STATIC_HASHED_STRING(ControllerSpeedSlider);
WB_MAKE_EVENT(SetUISliderValue, NULL);
WB_SET_AUTO(SetUISliderValue, Hash, Screen, sControlsOptionsScreen);
WB_SET_AUTO(SetUISliderValue, Hash, Widget, sControllerSpeedSlider);
WB_SET_AUTO(SetUISliderValue, Float, SliderValue,
GetSliderValueFromControllerSpeed(ControllerSpeed));
WB_DISPATCH_EVENT(pEventManager, SetUISliderValue, NULL);
}
{
STATICHASH(Brightness);
const float Brightness = ConfigManager::GetFloat(sBrightness, 1.0f);
STATIC_HASHED_STRING(BrightnessScreen);
STATIC_HASHED_STRING(BrightnessSlider);
WB_MAKE_EVENT(SetUISliderValue, NULL);
WB_SET_AUTO(SetUISliderValue, Hash, Screen, sBrightnessScreen);
WB_SET_AUTO(SetUISliderValue, Hash, Widget, sBrightnessSlider);
WB_SET_AUTO(SetUISliderValue, Float, SliderValue,
GetSliderValueFromBrightness(Brightness));
WB_DISPATCH_EVENT(pEventManager, SetUISliderValue, NULL);
}
{
STATIC_HASHED_STRING(DisplayOptionsScreen);
STATIC_HASHED_STRING(FOVSlider);
WB_MAKE_EVENT(SetUISliderValue, NULL);
WB_SET_AUTO(SetUISliderValue, Hash, Screen, sDisplayOptionsScreen);
WB_SET_AUTO(SetUISliderValue, Hash, Widget, sFOVSlider);
WB_SET_AUTO(SetUISliderValue, Float, SliderValue,
GetSliderValueFromFOV(FOV));
WB_DISPATCH_EVENT(pEventManager, SetUISliderValue, NULL);
}
{
STATICHASH(MasterVolume);
const float MasterVolume = ConfigManager::GetFloat(sMasterVolume);
STATIC_HASHED_STRING(AudioOptionsScreen);
STATIC_HASHED_STRING(VolumeSlider);
WB_MAKE_EVENT(SetUISliderValue, NULL);
WB_SET_AUTO(SetUISliderValue, Hash, Screen, sAudioOptionsScreen);
WB_SET_AUTO(SetUISliderValue, Hash, Widget, sVolumeSlider);
WB_SET_AUTO(SetUISliderValue, Float, SliderValue, MasterVolume);
WB_DISPATCH_EVENT(pEventManager, SetUISliderValue, NULL);
}
{
STATICHASH(MusicVolume);
const float MusicVolume = ConfigManager::GetFloat(sMusicVolume);
STATIC_HASHED_STRING(AudioOptionsScreen);
STATIC_HASHED_STRING(MusicVolumeSlider);
WB_MAKE_EVENT(SetUISliderValue, NULL);
WB_SET_AUTO(SetUISliderValue, Hash, Screen, sAudioOptionsScreen);
WB_SET_AUTO(SetUISliderValue, Hash, Widget, sMusicVolumeSlider);
WB_SET_AUTO(SetUISliderValue, Float, SliderValue, MusicVolume);
WB_DISPATCH_EVENT(pEventManager, SetUISliderValue, NULL);
}
}
// Initialize UI callbacks
{
UIScreenEldSetRes* pSetRes =
m_UIManager->GetScreen<UIScreenEldSetRes>("SetResScreen");
pSetRes->SetUICallback(SUICallback(EldritchFramework::OnSetRes, nullptr));
UIScreenFade* pFade = m_UIManager->GetScreen<UIScreenFade>("Fade");
pFade->SetFadeCallback(
SUICallback(EldritchFramework::OnFadeFinished, nullptr));
}
WB_MAKE_EVENT(ResetToInitialScreens, NULL);
WB_DISPATCH_EVENT(WBWorld::GetInstance()->GetEventManager(),
ResetToInitialScreens, NULL);
{
// HACK: Too content aware
STATIC_HASHED_STRING(MKGLogoScreen);
WB_MAKE_EVENT(PushUIScreen, NULL);
WB_SET_AUTO(PushUIScreen, Hash, Screen, sMKGLogoScreen);
WB_DISPATCH_EVENT(WBWorld::GetInstance()->GetEventManager(), PushUIScreen,
NULL);
}
// Tick world once to pump the event queue. Fixes title screen bugs.
m_World->Tick(0.0f);
// All done, show the window finally.
SafeDelete(m_SplashWindow);
#if BUILD_WINDOWS_NO_SDL
m_Window->Show(m_CmdShow);
#elif BUILD_SDL
m_Window->Show();
#endif
// Reattach GL context if needed.
m_Renderer->Refresh();
PRINTF("Eldritch initialization complete.\n");
}
