SECURITY_STATUS SEC_ENTRY
QuerySecurityPackageInfoW(
LPWSTR pszPackageName, // Name of package
PSecPkgInfoW SEC_FAR * pPackageInfo // Receives package info
)
{
SECURITY_STATUS scRet;
PSecPkg pPackage;
scRet = InitializePackages();
if (!NT_SUCCESS(scRet))
{
return(scRet);
}
pPackage = LocatePackageW(pszPackageName);
if (pPackage == NULL)
{
return(SEC_E_SECPKG_NOT_FOUND);
}
scRet = pPackage->pftTableW->QuerySecurityPackageInfoW(
pszPackageName,
pPackageInfo
);
return(scRet);
}
//+-------------------------------------------------------------------------
//
// Function: InitSecurityInterfaceW
//
// Synopsis:
//
// Effects:
//
// Arguments:
//
// Requires:
//
// Returns:
//
// Notes:
//
//
//--------------------------------------------------------------------------
PSecurityFunctionTableW SEC_ENTRY
InitSecurityInterfaceW(VOID)
{
if (!NT_SUCCESS(InitializePackages()))
{
return(NULL);
}
return(&SecTableW);
}
SECURITY_STATUS SEC_ENTRY
AcquireCredentialsHandleW(
LPWSTR pszPrincipal, // Name of principal
LPWSTR pszPackageName, // Name of package
unsigned long fCredentialUse, // Flags indicating use
void SEC_FAR * pvLogonId, // Pointer to logon ID
void SEC_FAR * pAuthData, // Package specific data
SEC_GET_KEY_FN pGetKeyFn, // Pointer to GetKey() func
void SEC_FAR * pvGetKeyArgument, // Value to pass to GetKey()
PCredHandle phCredential, // (out) Cred Handle
PTimeStamp ptsExpiry // (out) Lifetime (optional)
)
{
SECURITY_STATUS scRet = SEC_E_OK;
PSecPkg pPackage;
scRet = InitializePackages();
if (!NT_SUCCESS(scRet))
{
return(scRet);
}
if (!pszPackageName)
{
return(SEC_E_SECPKG_NOT_FOUND);
}
if ((pPackage = LocatePackageW(pszPackageName)) == NULL)
{
return(SEC_E_SECPKG_NOT_FOUND);
}
scRet = pPackage->pftTableW->AcquireCredentialsHandleW(
pszPrincipal,
pszPackageName,
fCredentialUse,
pvLogonId,
pAuthData,
pGetKeyFn,
pvGetKeyArgument,
phCredential,
ptsExpiry);
//
// Only set the package id if it is not a builtin package.
//
if ((scRet == SEC_E_OK) &&
(pPackage->dwPackageID >= BuiltinPackageCount))
{
phCredential->dwLower = pPackage->dwPackageID;
}
return(scRet);
}
bool DevelopmentResourceDepot::VOpen()
{
//Open assets and read non-hidden stuff
bool success = true;
for (auto it = m_packagePaths.begin(); it != m_packagePaths.end(); it++)
{
success = success && RegisterPackages(*it);
}
if (success)
{
success = InitializePackages();
}
return success;
}
bool ZipResourceDepot::VOpen()
{
bool success = true;
for (auto it = m_packagePaths.begin(); it != m_packagePaths.end(); it++)
{
//Iterates over packages directory and registers each package
success = success && RegisterPackages(*it);
}
if (success)
{
success = InitializePackages();
}
return success;
}
//+-------------------------------------------------------------------------
//
// Function: InitConnMgr
//
// Synopsis: Initializes all this stuff
//
// Effects:
//
// Arguments:
//
// Requires:
//
// Returns:
//
// Notes:
//
//--------------------------------------------------------------------------
BOOLEAN
InitConnMgr(void)
{
if (!KsecInitMemory())
{
return(FALSE);
}
if (!NT_SUCCESS(InitializePackages()))
{
return(FALSE);
}
KeInitializeSpinLock(&ConnectSpinLock);
pClientList = NULL;
fInitialized = TRUE;
return(TRUE);
}
SECURITY_STATUS SEC_ENTRY
EnumerateSecurityPackagesW(
unsigned long SEC_FAR * pcPackages, // Receives num. packages
PSecPkgInfoW SEC_FAR * ppPackageInfo // Receives array of info
)
{
SECURITY_STATUS scRet = SEC_E_OK;
PSecPkgInfoW * ppTempPkgInfo = NULL;
PSecPkgInfoW pFinalPkgInfo = NULL;
ULONG cIndex;
ULONG cTempPackages;
ULONG cbFinalSize = 0;
PBYTE Where;
scRet = InitializePackages();
if (!NT_SUCCESS(scRet))
{
return(scRet);
}
//
// NOTE:
//
// Because the first two packages are actually the same one, we
// use the count of packages - 1 for enumerating. In addition,
// we start at 1 instead of zero for calling Enumerate, and subtact
// 1 for the index into the output buffers.
//
ppTempPkgInfo = (PSecPkgInfoW *) LocalAlloc(LMEM_ZEROINIT,
sizeof(PSecPkgInfoW) * (cPackages-1));
if (ppTempPkgInfo == NULL)
{
return(SEC_E_INSUFFICIENT_MEMORY);
}
//
// Loop through the packages and enumerate packages from each one
//
for ( cIndex = 1; cIndex < cPackages ; cIndex++ )
{
scRet = pspPackages[cIndex].pftTableW->QuerySecurityPackageInfoW(
pspPackages[cIndex].PackageNameW,
&ppTempPkgInfo[cIndex-1]);
//
// We require that each package return only 1 package
//
if (scRet != SEC_E_OK)
{
goto Cleanup;
}
cbFinalSize += sizeof(SecPkgInfoW)
+ (wcslen(ppTempPkgInfo[cIndex-1]->Name) + 1) * sizeof(WCHAR)
+ (wcslen(ppTempPkgInfo[cIndex-1]->Comment) + 1) * sizeof(WCHAR);
}
//
// Copy the data into one buffer, so it can be freed with LocalFree.
//
pFinalPkgInfo = (PSecPkgInfoW) LocalAlloc(0,cbFinalSize);
if (pFinalPkgInfo == NULL)
{
scRet = SEC_E_INSUFFICIENT_MEMORY;
goto Cleanup;
}
Where = (cPackages - 1) * sizeof(SecPkgInfoW) + (PBYTE) pFinalPkgInfo;
for (cIndex = 0; cIndex < cPackages - 1 ; cIndex++ )
{
//
// First copy the whole structure
//
CopyMemory( &pFinalPkgInfo[cIndex],
ppTempPkgInfo[cIndex],
sizeof(SecPkgInfo));
//
// Now marshall the strings
//
pFinalPkgInfo[cIndex].Name = (LPWSTR) Where;
Where += (wcslen(ppTempPkgInfo[cIndex]->Name) + 1) * sizeof(WCHAR);
CopyMemory( pFinalPkgInfo[cIndex].Name,
ppTempPkgInfo[cIndex]->Name,
Where - (PBYTE) pFinalPkgInfo[cIndex].Name );
pFinalPkgInfo[cIndex].Comment = (LPWSTR) Where;
Where += (wcslen(ppTempPkgInfo[cIndex]->Comment) + 1) * sizeof(WCHAR);
CopyMemory( pFinalPkgInfo[cIndex].Comment,
ppTempPkgInfo[cIndex]->Comment,
Where - (PBYTE) pFinalPkgInfo[cIndex].Comment );
}
ASSERT(Where == (PBYTE) pFinalPkgInfo + cbFinalSize);
scRet = SEC_E_OK;
Cleanup:
//
// Clean up the temporary copy
//
if (ppTempPkgInfo != NULL)
{
for (cIndex = 0; cIndex < cPackages - 1 ; cIndex++ )
{
if (ppTempPkgInfo[cIndex] != NULL)
{
FreeContextBuffer(ppTempPkgInfo[cIndex]);
}
}
LocalFree(ppTempPkgInfo);
}
if (!NT_SUCCESS(scRet))
{
if (pFinalPkgInfo != NULL)
{
LocalFree(pFinalPkgInfo);
}
}
else
{
*ppPackageInfo = pFinalPkgInfo;
*pcPackages = cPackages - 1;
}
return(scRet);
}
/*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");
}
