814 lines
31 KiB
C++
814 lines
31 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// FILE : ScaleformMgr.h
|
|
// PURPOSE : manages the processing of Scaleform movies in the game
|
|
// AUTHOR : Derek Payne
|
|
// STARTED : 02/10/2009
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef _SCALEFORMMGR_H_
|
|
#define _SCALEFORMMGR_H_
|
|
|
|
// Rage headers
|
|
#include "Scaleform/scaleform.h"
|
|
#include "Streaming/streamingmodule.h"
|
|
#include "streaming/streamingrequest.h"
|
|
#include "system/criticalsection.h"
|
|
#include "text/TextFile.h"
|
|
#include "vector/vector3.h"
|
|
#include "atl/array.h"
|
|
#include "atl/vector.h"
|
|
#include "grcore/effect.h"
|
|
#include "grcore/stateblock.h"
|
|
#include "templates/dblBuf.h"
|
|
#include "fwtl/LinkList.h"
|
|
#include "atl/inlist.h"
|
|
|
|
// game headers
|
|
#include "frontend/Scaleform/ScaleFormComplexObjectMgr.h"
|
|
|
|
|
|
namespace rage {
|
|
class parTreeNode;
|
|
};
|
|
|
|
|
|
typedef s32 COMPLEX_OBJECT_ID;
|
|
|
|
#define MAX_CHARS_FOR_TEXT_STRING (2176) // WAS 1024, but with Adam's permission, we're bumping it up to accommodate some incredibly magniloquent electronic missives.
|
|
|
|
#define MAX_SCALEFORM_MOVIES (50)
|
|
|
|
#define SF_INVALID_MOVIE (-1)
|
|
#define SF_SCALEFORM_INACTIVE (-2)
|
|
|
|
#define TRACK_STALE_REFERENCES (0)
|
|
|
|
// problems abound with FlipBuffers being called multiple times per 'frame'
|
|
// this will help us track them down
|
|
#define TRACK_FLIP_BUFFERS ( 0 && !__NO_OUTPUT && !__FINAL )
|
|
|
|
// some CS are still required in rare cases where its easiest to lock rather than do lots of double buffering
|
|
// also we need to force an invoke instantly when we shutdown or initialise movies so this ensures we dont
|
|
// conflict on the rare occursions when this happens
|
|
#define __SCALEFORM_CRITICAL_SECTIONS (1)
|
|
|
|
#if __SCALEFORM_CRITICAL_SECTIONS
|
|
extern atRangeArray<sysCriticalSectionToken,MAX_SCALEFORM_MOVIES> gs_ScaleformMovieCS;
|
|
#endif // __SCALEFORM_CRITICAL_SECTIONS
|
|
|
|
|
|
#define MAX_CHARS_IN_SCALEFORM_METHOD_NAME (50)
|
|
#define MAX_CHARS_IN_SCALEFORM_UNIQUE_STRINGS (100) // JeffK needs 100 chars
|
|
#define MAX_CHARS_IN_SCALEFORM_METHOD_CALL_STRING (2000)
|
|
#define MAX_NUM_PARAMS_IN_SCALEFORM_METHOD (22)
|
|
#define MAX_ADDITIONAL_TXDS (13) // max we know about is 13 seperate TXDs used in the pausemenu Gallery screen
|
|
|
|
#define MAX_STORED_RETURN_VALUES (20)
|
|
#define FRAMES_FOR_RETURNED_VALUE_TO_STAY_VALID (20)
|
|
|
|
#define SCALEFORM_PREALLOC_XML_FILENAME "common:/data/ScaleformPreallocation.xml"
|
|
|
|
// all movies in V have been set up to use this aspect ratio, nothing to do with game resolution
|
|
#define ACTIONSCRIPT_STAGE_SIZE_X (1280)
|
|
#define ACTIONSCRIPT_STAGE_SIZE_Y (720)
|
|
|
|
#if __XENON
|
|
#define SCALEFORM_MOVIE_PLATFORM_SUFFIX "_360
|
|
#elif RSG_DURANGO
|
|
#define SCALEFORM_MOVIE_PLATFORM_SUFFIX "_xboxone"
|
|
#elif __PS3
|
|
#define SCALEFORM_MOVIE_PLATFORM_SUFFIX "_ps3"
|
|
#elif RSG_ORBIS
|
|
#define SCALEFORM_MOVIE_PLATFORM_SUFFIX "_ps4"
|
|
#elif RSG_PC
|
|
#define SCALEFORM_MOVIE_PLATFORM_SUFFIX "_pc"
|
|
#endif
|
|
|
|
enum eSCALEFORM_BASE_CLASS
|
|
{
|
|
SF_BASE_CLASS_GENERIC = 0,
|
|
SF_BASE_CLASS_SCRIPT,
|
|
SF_BASE_CLASS_HUD,
|
|
SF_BASE_CLASS_MINIMAP,
|
|
SF_BASE_CLASS_WEB,
|
|
SF_BASE_CLASS_CUTSCENE,
|
|
SF_BASE_CLASS_PAUSEMENU,
|
|
SF_BASE_CLASS_STORE,
|
|
SF_BASE_CLASS_GAMESTREAM,
|
|
SF_BASE_CLASS_VIDEO_EDITOR,
|
|
SF_BASE_CLASS_MOUSE,
|
|
SF_BASE_CLASS_TEXT_INPUT,
|
|
SF_MAX_BASE_CLASSES
|
|
};
|
|
|
|
enum eState
|
|
{
|
|
SF_MOVIE_STATE_INACTIVE = 0, // completely off/unused/deleted etc
|
|
SF_MOVIE_STATE_FLAGGED_FOR_USE, // not set up yet, but flagged to be used
|
|
SF_MOVIE_STATE_STREAMING_MOVIE, // loading and waiting on movie itself to stream
|
|
SF_MOVIE_STATE_ACTIVE, // active & considered in use
|
|
SF_MOVIE_STATE_RESTARTING,
|
|
SF_MOVIE_STATE_SET_TO_DELETE_PENDING_FINAL_UPDATE, // movie is going to get set to be deleted via the RT but can still update and invoke/callback
|
|
SF_MOVIE_STATE_SET_TO_REMOVE_STAGE_1, // movie is going to get set to be deleted via the RT and can no longer update/callback
|
|
SF_MOVIE_STATE_SET_TO_REMOVE_STAGE_2, // movie is going to get set to be deleted without any further checks
|
|
SF_MOVIE_STATE_SET_TO_REMOVE_NO_REF_CHECK // goes into this state after ref check so we can retry on the assert and get others
|
|
};
|
|
|
|
struct ScaleformMovieTxd
|
|
{
|
|
char cTxdName[MAX_CHARS_IN_SCALEFORM_METHOD_NAME];
|
|
char cUniqueRefString[MAX_CHARS_IN_SCALEFORM_UNIQUE_STRINGS];
|
|
bool bReportSuccessToActionScript;
|
|
strLocalIndex iTxdId;
|
|
strRequest streamingRequest;
|
|
#if !__NO_OUTPUT
|
|
s32 iSpamCounter;
|
|
#endif
|
|
|
|
// Call this instead of streamingRequest.HasLoaded, because that one and the downloadable texture manager don't play nice together.
|
|
bool AlreadyLoaded();
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
METHOD_BUILD_BUFFER_UPDATE_THREAD = 0,
|
|
METHOD_BUILD_BUFFER_RENDER_THREAD,
|
|
METHOD_BUILD_BUFFER_EXTERNAL_INTERFACE_UT = METHOD_BUILD_BUFFER_RENDER_THREAD + NUMBER_OF_RENDER_THREADS,
|
|
METHOD_BUILD_BUFFER_EXTERNAL_INTERFACE_RT,
|
|
|
|
MAX_METHOD_BUILD_BUFFERS = METHOD_BUILD_BUFFER_EXTERNAL_INTERFACE_RT + NUMBER_OF_RENDER_THREADS
|
|
};
|
|
|
|
|
|
enum eMovieOwnerTags
|
|
{
|
|
SF_MOVIE_TAGGED_BY_NONE = 0,
|
|
SF_MOVIE_TAGGED_BY_CODE = 1 << 1,
|
|
SF_MOVIE_TAGGED_BY_SCRIPT = 1 << 2,
|
|
};
|
|
|
|
struct ScaleformMovieStruct
|
|
{
|
|
// vars accessed and changed on both threads (so these are double buffered)
|
|
CDblBuf<bool> bPerformGarbageCollection;
|
|
CDblBuf<bool> bChangeMovieParams;
|
|
CDblBuf<Vector3> vPos;
|
|
CDblBuf<Vector3> vOriginalPos;
|
|
CDblBuf<Vector3> vRot;
|
|
CDblBuf<Vector2> vSize;
|
|
CDblBuf<Vector2> vOriginalSize;
|
|
CDblBuf<GFxMovieView::ScaleModeType> eScaleMode;
|
|
CDblBuf<Vector2> vWorldSize;
|
|
CDblBuf<bool> bRender3DSolid;
|
|
CDblBuf<bool> bRender3D;
|
|
CDblBuf<bool> bIgnoreSuperWidescreenScaling;
|
|
CDblBuf<u8> iBrightness;
|
|
|
|
// vars accessed on both threads but access is managed by state (so threadsafe) and not changed once state is set to active or only set in certain threadsafe situations
|
|
s32 iMovieId; // never changed once set up in a threadsafe manner
|
|
s32 iParentMovie;
|
|
char cFilename[RAGE_MAX_PATH]; // never changed once set up in a threadsafe manner
|
|
eState iState;
|
|
bool bUpdateMovie;
|
|
u8 iRendered;
|
|
bool bDontRenderWhilePaused;
|
|
bool bForceRemoval;
|
|
|
|
// vars only accessed on UpdateThread:
|
|
atVector<ScaleformMovieTxd> requestedTxds;
|
|
bool bRemovableAtInit;
|
|
u8 movieOwnerTag;
|
|
|
|
#if __DEV
|
|
s32 iNumRefs;
|
|
#endif // __DEV
|
|
#if __SF_STATS
|
|
atArray<s32> allRequestedTxds; // A list of all the txds requested by this movie (so we can display info about them)
|
|
#endif
|
|
|
|
// vars only accessed on RenderThread:
|
|
float fCurrentTimestep;
|
|
s32 iDependentMovie; // id of a movie that this movie may share its assets with
|
|
bool bNeedsToUpdateThisFrame;
|
|
|
|
ScaleformMovieTxd& CreateNewTxdRequest(strLocalIndex iTxdId, const char* pTxdString, const char* uniqueRef, bool reportSuccessToAS);
|
|
};
|
|
|
|
enum eParamType
|
|
{
|
|
PARAM_TYPE_INVALID = 0,
|
|
PARAM_TYPE_NUMBER,
|
|
PARAM_TYPE_BOOL,
|
|
PARAM_TYPE_STRING,
|
|
PARAM_TYPE_EXTERNAL_STRING,
|
|
PARAM_TYPE_GFXVALUE
|
|
};
|
|
|
|
struct ScaleformMethodStruct
|
|
{
|
|
struct ParamStruct
|
|
{
|
|
union
|
|
{
|
|
atString *pParamString;
|
|
Double ParamNumber; // double as thats what Scaleform uses :(
|
|
bool bParamBool;
|
|
GFxValue *pParamGfxValue;
|
|
|
|
char *pExternalString; // used by wrapper
|
|
};
|
|
|
|
eParamType param_type;
|
|
};
|
|
|
|
s8 iMovieId;
|
|
s8 iMovieIdThisInvokeIsLinkedTo;
|
|
char cMethodName[MAX_CHARS_IN_SCALEFORM_METHOD_NAME];
|
|
|
|
ParamStruct params[MAX_NUM_PARAMS_IN_SCALEFORM_METHOD];
|
|
u8 iParamCount;
|
|
eSCALEFORM_BASE_CLASS iBaseClass;
|
|
COMPLEX_OBJECT_ID ComplexObjectIdToInvoke;
|
|
|
|
s32 iReturnId;
|
|
};
|
|
|
|
|
|
struct ScaleformMethodReturnStruct
|
|
{
|
|
s32 iUniqueId;
|
|
GFxValue gfxvalue_return_value;
|
|
u8 iFramesToStayValid;
|
|
atString stringData;
|
|
};
|
|
|
|
#if __SF_STATS
|
|
struct ScaleformMemoryStats
|
|
{
|
|
size_t m_MovieDefTotal, m_MovieDefUsed;
|
|
size_t m_MovieViewTotal, m_MovieViewUsed;
|
|
size_t m_PreallocTotal, m_PreallocUsed, m_PreallocPeak, m_Overalloc;
|
|
size_t m_PeakAllowed;
|
|
bool m_MPSpecific;
|
|
|
|
ScaleformMemoryStats();
|
|
};
|
|
#endif
|
|
|
|
enum
|
|
{
|
|
INVALID_MOVIE_ID = -1
|
|
};
|
|
|
|
class CScaleformMgr
|
|
{
|
|
public:
|
|
class CreateMovieParams
|
|
{
|
|
public:
|
|
CreateMovieParams(const char* cMovieFilename) :
|
|
cFilename(cMovieFilename),
|
|
vRot(0.0f, 0.0f, 0.0f),
|
|
iParentMovie(-1),
|
|
iDependentMovie(-1),
|
|
eScaleMode(GFxMovieView::SM_ExactFit),
|
|
bStream(false),
|
|
bForceLoad(false),
|
|
bRemovable(true),
|
|
bRequiresMovieView(true),
|
|
movieOwnerTag(SF_MOVIE_TAGGED_BY_CODE),
|
|
bInitiallyLocked(false),
|
|
bDontRenderWhilePaused(false),
|
|
bIgnoreSuperWidescreenScaling(false)
|
|
{
|
|
|
|
}
|
|
|
|
const char* cFilename;
|
|
Vector3 vPos;
|
|
Vector3 vRot;
|
|
Vector2 vSize;
|
|
s32 iParentMovie;
|
|
s32 iDependentMovie;
|
|
GFxMovieView::ScaleModeType eScaleMode;
|
|
bool bStream;
|
|
bool bForceLoad;
|
|
bool bRemovable;
|
|
bool bRequiresMovieView;
|
|
bool bIgnoreSuperWidescreenScaling;
|
|
eMovieOwnerTags movieOwnerTag;
|
|
bool bInitiallyLocked;
|
|
bool bDontRenderWhilePaused;
|
|
};
|
|
|
|
static bool IsFunctionAvailable(s32 iIndex, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName);
|
|
|
|
static void AddCallbackMethodToBuffer(s32 iMovieCalledFrom, const char *pFunctionName, const GFxValue *pArgs, s32 iNumberOfParams);
|
|
static void ExecuteCallbackMethod(s32 iMovieCalledFrom, const char* methodName, const GFxValue* args, s32 iArgCount);
|
|
|
|
//
|
|
// General code functions - other code systems can call these methods
|
|
//
|
|
static s32 CreateMovie(const char *cFilename, Vector2 vPos, Vector2 vSize, bool bRemovable = true, s32 iParentMovie = -1, s32 iDependentMovie = -1, bool bRequiresMovieView = true, eMovieOwnerTags calledBy = SF_MOVIE_TAGGED_BY_CODE, bool bDontRenderWhilePaused = false, bool bIgnoreSuperWidescreenAdjustment = false);
|
|
static s32 CreateMovie(const char *cFilename, const Vector3& vPos, const Vector3& vRot, Vector2 vSize, bool bRemovable = true, s32 iParentMovie = -1, s32 iDependentMovie = -1, bool bRequiresMovieView = true, eMovieOwnerTags calledBy = SF_MOVIE_TAGGED_BY_CODE, bool bDontRenderWhilePaused = false);
|
|
static s32 CreateMovie(CreateMovieParams& params);
|
|
|
|
static s32 CreateMovieAndWaitForLoad(const char *cFilename, Vector2 vPos, Vector2 vSize, bool bRemovable = true, s32 iParentMovie = -1, s32 iDependentMovie = -1, bool bRequiresMovieView = true, eMovieOwnerTags calledBy = SF_MOVIE_TAGGED_BY_CODE, bool bDontRenderWhilePaused = false, bool bIgnoreSuperWidescreenAdjustment = false);
|
|
static s32 CreateMovieAndWaitForLoad(const char *cFilename, const Vector3& vPos, const Vector3& vRot, Vector2 vSize, bool bRemovable = true, s32 iParentMovie = -1, s32 iDependentMovie = -1, bool bRequiresMovieView = true, eMovieOwnerTags calledBy = SF_MOVIE_TAGGED_BY_CODE, bool bDontRenderWhilePaused = false);
|
|
static s32 CreateMovieAndWaitForLoad(CreateMovieParams& params);
|
|
|
|
static bool RequestRemoveMovie(s32 iIndex, eMovieOwnerTags calledBy = SF_MOVIE_TAGGED_BY_CODE);
|
|
static void SetScriptRequired(s32 iIndex, bool bScriptRequired);
|
|
|
|
static inline bool IsMovieIdInRange(s32 iIndex) { return (iIndex >= 0 && iIndex < sm_ScaleformArray.size() && iIndex < MAX_SCALEFORM_MOVIES); }
|
|
|
|
#if RSG_PC
|
|
static void DeviceLost();
|
|
static void DeviceReset();
|
|
|
|
static bool GetMovieShouldIgnoreSuperWidescreen(s32 iIndex);
|
|
#endif
|
|
|
|
static void PrepareUpdateAllMoviesOnRT();
|
|
static void EnsureAllMoviesUpdatedOnRT();
|
|
static void CleanupMoviesOnRT();
|
|
|
|
static void OverrideOriginalMoviePosition(int iMovieID, Vector2 &vPos);
|
|
|
|
static void UpdateMovieOnly(s32 iIndex, float fTimeStep = 0.0f);
|
|
static void DoNotUpdateThisFrame(s32 iIndex);
|
|
static void RenderMovie(s32 iIndex, float fTimeStep = 0.0f, bool bUpdateWhenPaused = false, bool bForceUpdateBeforeRender = false, float fAlpha = 1.0f);
|
|
static void RequestRenderMovie3D(s32 iIndex, bool bRenderSolid);
|
|
|
|
|
|
enum class SDC : u8 {
|
|
Default = 0,
|
|
ForceWidescreen = BIT(0),
|
|
UseFakeSafeZoneOnBootup = BIT(1), // ONLY APPLIED ON DURANGO
|
|
UseUnAdjustedSafeZone = BIT(2)
|
|
};
|
|
|
|
|
|
static void SetMovie3DBrightness(s32 iIndex, s32 iBrightness);
|
|
static bool SetMovieDisplayConfig(s32 iIndex, eSCALEFORM_BASE_CLASS iBaseClass, SDC flags = SDC::Default);
|
|
static void SetComplexObjectDisplayConfig(s32 objectId, eSCALEFORM_BASE_CLASS iBaseClass);
|
|
|
|
static Vector3 GetMoviePos(s32 iIndex);
|
|
static Vector2 GetMovieSize(s32 iIndex);
|
|
static char const *GetMovieFilename(s32 const iIndex);
|
|
|
|
static const Vector2& GetScreenSize() { return ms_vScreenSize; }
|
|
|
|
static void RenderWorldSpace();
|
|
static void RenderWorldSpaceSolid();
|
|
|
|
static bool IsMovieRendering(s32 iIndex);
|
|
static bool IsMovieActive(s32 iIndex);
|
|
static bool IsMovieUpdateable(s32 iIndex);
|
|
static bool IsMovieShuttingDown(s32 iIndex);
|
|
static bool HasMovieGotAnyState(s32 iIndex);
|
|
static bool CanMovieBeRemovedByScript(s32 iIndex);
|
|
|
|
static s32 GetNoofMoviesActiveOrLoading();
|
|
|
|
static bool DoesMovieExistInImage(char *pFilename);
|
|
|
|
static s32 FindMovieByFilename(const char *pFilename, bool findStreamingMovies = false );
|
|
|
|
static void ScalePosAndSize(Vector2& vPos, Vector2& vSize, float fScalar);
|
|
static void AffectRenderSizeOnly(s32 iIndex, float fScalar);
|
|
static void UpdateMovieParams(s32 iIndex);
|
|
static void UpdateMovieParams(s32 iIndex, GFxMovieView::ScaleModeType eScaleMode);
|
|
static void UpdateMovieParams(s32 iIndex, const Vector2& vPos, const Vector2& vSize);
|
|
static void ChangeMovieParams(s32 iIndex, const Vector2& vPos, const Vector2& vSize, GFxMovieView::ScaleModeType eScaleMode, int CurrentRenderID = -1, bool bOverrideSWScaling = false, u8 iLargeRt = 0);
|
|
static void ChangeMovieParams(s32 iIndex, const Vector3& vPos, const Vector2& vScale, const Vector2& vWorldSize, const Vector3& vRot, GFxMovieView::ScaleModeType eScaleMode, int CurrentRenderID = -1, bool bOverrideSWScaling = false, u8 iLargeRt = 0);
|
|
|
|
|
|
static bool RestartMovie(s32 iIndex, bool bForce, bool bQuick);
|
|
static void CheckIncomingFunctions(atHashWithStringBank methodName, const GFxValue* args);
|
|
|
|
#define SF_INVALID_PARAM (-9999)
|
|
#define SF_INVALID_PARAM_SCRIPT (-1)
|
|
|
|
static void CallMethod(s32 iIndex, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName, bool bCallInstantly = false);
|
|
static void CallMethodFromScript(s32 iIndex, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName, s32 iOptionalIndex = -1, float fParam1 = SF_INVALID_PARAM, float fParam2 = SF_INVALID_PARAM, float fParam3 = SF_INVALID_PARAM, float fParam4 = SF_INVALID_PARAM, float fParam5 = SF_INVALID_PARAM, const char *pParam1 = NULL, const char *pParam2 = NULL, const char *pParam3 = NULL, const char *pParam4 = NULL, const char *pParam5 = NULL, bool bTextLookUp = false);
|
|
|
|
static bool BeginMethod(s32 iIndex, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName);
|
|
static bool BeginMethod(s32 iIndex, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName, s32 iOptionalIndex);
|
|
static bool BeginMethodOnComplexObject(COMPLEX_OBJECT_ID ComplexObjectId, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName);
|
|
|
|
static s32 EndMethodReturnValue(const s32 iExistingReturnValue = 0);
|
|
static void EndMethod(bool bCallInstantly = false); // DO NOT PASS IN TRUE TO THIS UNLESS THE MOVIE YOU ARE CALLING IT ON IS NOT ACTIVE AT ALL (IE DURING INITS ETC)
|
|
static s32 EndMethodInt(bool bCallInstantly = true); // DO NOT PASS IN TRUE TO THIS UNLESS THE MOVIE YOU ARE CALLING IT ON IS NOT ACTIVE AT ALL (IE DURING INITS ETC)
|
|
static float EndMethodFloat(bool bCallInstantly = true); // DO NOT PASS IN TRUE TO THIS UNLESS THE MOVIE YOU ARE CALLING IT ON IS NOT ACTIVE AT ALL (IE DURING INITS ETC)
|
|
static bool EndMethodBool(bool bCallInstantly = true); // DO NOT PASS IN TRUE TO THIS UNLESS THE MOVIE YOU ARE CALLING IT ON IS NOT ACTIVE AT ALL (IE DURING INITS ETC)
|
|
static GFxValue EndMethodGfxValue(bool bCallInstantly = true); // DO NOT PASS IN TRUE TO THIS UNLESS THE MOVIE YOU ARE CALLING IT ON IS NOT ACTIVE AT ALL (IE DURING INITS ETC)
|
|
|
|
static void AddParamInt(s32 iParam);
|
|
static void AddParamInt64(s64 iParam);
|
|
static void AddParamFormattedInt(s64 iParam, const char* pPrefix = "%s");
|
|
static void AddParamFloat(Double fParam);
|
|
static void AddParamBool(bool bParam);
|
|
static void AddParamString(const char *pParam, bool bConvertToHtml = true);
|
|
static void AddParamString(const char *pParam, s32 iBufferLen, bool bConvertToHtml = true);
|
|
static void AddParamLocString(const char* pParam, bool bConvertToHtml = true);
|
|
static void AddParamLocString(u32 hash, bool bConvertToHtml = true);
|
|
static void AddParamGfxValue(GFxValue param);
|
|
|
|
static bool ClearReturnValue(s32 iReturnId);
|
|
static bool IsReturnValueSet(s32 iReturnId);
|
|
|
|
static s32 GetReturnValueInt(s32 iReturnId);
|
|
static float GetReturnValueFloat(s32 iReturnId);
|
|
static bool GetReturnValueBool(s32 iReturnId);
|
|
static const char *GetReturnValueString(s32 iReturnId);
|
|
|
|
static void ForceCollectGarbage(s32 iIndex);
|
|
static bool DoesMovieHaveInvokesOrCallbacksPending(s32 iIndex);
|
|
|
|
// PURPOSE: RAII class for locking
|
|
struct AutoLock
|
|
{
|
|
explicit AutoLock(s32 iIndex) : m_Index(iIndex) { LockMovie(iIndex); }
|
|
~AutoLock() { UnlockMovie(m_Index); }
|
|
s32 m_Index;
|
|
};
|
|
|
|
static void LockMovie(s32 iIndex); // Used only to temporarily lock a movie during initialization. Should never be used during gameplay
|
|
static void UnlockMovie(s32 iIndex);
|
|
|
|
static sysCriticalSectionToken& GetRealSafeZoneToken() { return sm_RealSafeZoneToken; }
|
|
|
|
//
|
|
// end of general code functions - public methods below here are to be called only by Scaleform setup/store code
|
|
//
|
|
|
|
static void Init(unsigned initMode);
|
|
static void Shutdown(unsigned shutdownMode);
|
|
|
|
static void KillAllMovies();
|
|
|
|
static void UpdateAtEndOfFrame( bool bCalledDuringRegularUpdate ); // we need to know if we're calling this during a loading screen's KeepAlive Function
|
|
static void UpdateMoviesUntilReadyForDeletion();
|
|
|
|
|
|
static void RemoveInvokesForComplexObject(COMPLEX_OBJECT_ID const c_objectId);
|
|
static void FlushInvokeList();
|
|
static void FlushCallbackList();
|
|
|
|
#if __DEV
|
|
static void PreallocTest(unsigned initMode);
|
|
#endif
|
|
|
|
static inline void BeginFrame()
|
|
{
|
|
Assert(!ms_bFrameBegun);
|
|
#if TRACK_FLIP_BUFFERS
|
|
++sm_BeginFrameCount; // in lieu of using SystemFrameCount (which may not be incremented), this lets us track extra pumps
|
|
#endif
|
|
|
|
if(m_staticMovieMgr)
|
|
{
|
|
ms_bFrameBegun = true;
|
|
m_staticMovieMgr->BeginFrame();
|
|
|
|
CleanupMoviesOnRT(); // cleanup any movies (ie garbage collection, resize etc)
|
|
CScaleformComplexObjectMgr::PerformAllOutstandingActionsOnRT(); // update any complex objects before we invoke (since we need to set up these items)
|
|
FlushInvokeList(); // flush any buffered invokes
|
|
CScaleformComplexObjectMgr::ReleaseAnyFlaggedObjects(); // release any complex objects
|
|
PrepareUpdateAllMoviesOnRT(); // update the movie at the end
|
|
}
|
|
}
|
|
|
|
static void EndFrame()
|
|
{
|
|
if(m_staticMovieMgr && ms_bFrameBegun)
|
|
{
|
|
EnsureAllMoviesUpdatedOnRT();
|
|
m_staticMovieMgr->EndFrame();
|
|
}
|
|
ms_bFrameBegun = false;
|
|
}
|
|
|
|
static inline void ResetMeshCache()
|
|
{
|
|
if(m_staticMovieMgr)
|
|
m_staticMovieMgr->ResetMeshCache();
|
|
}
|
|
|
|
static void FlipBuffers( bool bCalledDuringRegularUpdate ); // we need to know if we're calling this during a loading screen's KeepAlive Function
|
|
|
|
static void ForceMovieUpdateInstantly(s32 iIndex, bool bUpdate);
|
|
static s32 CreateFontMovie();
|
|
static void RemoveFontMovie();
|
|
static void AddGlobalFontsToLib(GFxFontLib* lib);
|
|
static bool GetMappedFontName( char const * const unmappedName, GString& out_mappedName );
|
|
static bool DoFontsShareMapping( char const * const unmappedNameA, char const * const unmappedNameB );
|
|
static GFxValue GetActionScriptObjectFromRoot(s32 iId);
|
|
static GFxMovieView *GetMovieView(s32 iId);
|
|
static bool VerifyVarType(GFxValue& var, GFxValue::ValueType requiredType, const char* ASSERT_ONLY(varName), GFxValue& ASSERT_ONLY(movieClip));
|
|
|
|
static bool TranslateWindowCoordinateToScaleformMovieCoordinate( float const rawX, float const rawY, s32 const movieId, float& out_x, float& out_y );
|
|
|
|
#if __BANK
|
|
static void InitWidgets();
|
|
|
|
static s32 GetMemoryUsage(const s32 iIndex);
|
|
static void DisplayPerformanceInfo();
|
|
static void PrintPreallocInfo( s32 iIndex, int& linesPrinted );
|
|
|
|
static void GatherPerformanceInfo();
|
|
static void UpdateWatchedMovie();
|
|
static strLocalIndex GetMovieStreamingIndex(s32 iIndex);
|
|
#endif // __BANK
|
|
#if __SF_STATS
|
|
static void GatherMemoryStats(s32 iIndex, ScaleformMemoryStats& stats);
|
|
static void DebugPrintMemoryStats(s32 iIndex);
|
|
#endif
|
|
|
|
static void LoadDLCData(const char* pFileName);
|
|
static void UnloadDLCData(const char* pFileName);
|
|
static void FixupScaleformAllocation(parTreeNode* pNodeMovie, const char* movieName);
|
|
|
|
static void LoadPreallocationInfo(const char* pFileName);
|
|
static void HandleNewTextureDependencies();
|
|
|
|
static sfScaleformManager* GetMovieMgr() { return m_staticMovieMgr; }
|
|
static void AddTxdRef(s32 iIndex, const char *pTxdString, const char *pUniqueString, bool bGetTxd, bool bAddPendingRefToLoaded);
|
|
|
|
static void CallAddTxdRefResponse( s32 iIndex, const char * pTxdString, const char * pUniqueString, bool success );
|
|
|
|
static void RemoveTxdRef(s32 iIndex, const char *pTxdString, bool bFromActionScript);
|
|
|
|
static void SetForceShutdown(s32 iIndex);
|
|
|
|
static GFxMovieView::ScaleModeType GetRequiredScaleMode(Vector2 const& vPos, Vector2 const& vSize, bool bUseShowAll = false);
|
|
static GFxMovieView::ScaleModeType GetRequiredScaleMode(s32 iIndex, bool bUseShowAll = false);
|
|
static bool ShouldUseWidescreen(s32 iIndex) { return sm_ScaleformArray[iIndex].eScaleMode.GetUpdateBuf() == GFxMovieView::SM_ExactFit; }
|
|
|
|
protected:
|
|
static bool GetTxdAndTextureNameFromText(const char *pText, char *pTxdName, char *pTextureName);
|
|
static char *FindOriginalFilename(const char *pFilename);
|
|
|
|
private:
|
|
static bool ProcessIndividualInvoke(s32 const c_buffer, s32 const c_index);
|
|
static void HandleXML(parTreeNode* pFontMapNode);
|
|
static void AutoRespondIfNeeded(eSCALEFORM_BASE_CLASS iBaseClass, s32 iMovieCalledFrom, const char *pAutoRespondString);
|
|
static void CheckTxdInStringHasRef(s32 iMovieId, const char *pString);
|
|
static bool DoesMovieHaveInvokesPending(s32 iIndex);
|
|
static bool DoesMovieHaveCallbacksPending(s32 iIndex);
|
|
|
|
static s32 CreateMovieInternal(const CreateMovieParams& params);
|
|
static bool BeginMethodInternal(s32 iIndex, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName, s32 iOptionalIndex, COMPLEX_OBJECT_ID ComplexObjectId);
|
|
|
|
static bool IsChildMovie(s32 iIndex);
|
|
static void UpdateMovie(s32 iIndex, float fTimeStep = 0.0f);
|
|
|
|
static void UpdateAllMoviesStateMachines();
|
|
|
|
static s32 GetMethodBuildBufferIndex();
|
|
static bool InitialiseAndSetActive(s32 iIndex);
|
|
static bool DestroyMovieNow(s32 iIndex);
|
|
static void InitTextures(s32 iIndex, const char *cFilename);
|
|
static void InitMovieAssets(s32 iIndex, const char *cFilename, s32 iAssetIndex);
|
|
static s32 LoadTextures(const char *cFilename);
|
|
static void StreamMovie(s32 iIndex, const char *cFilename, bool bStream, bool bForceLoad, s32 iParentMovie, bool bMovieView);
|
|
static void UpdateTxdReferences();
|
|
static void ClearScaleformArraySlot(s32 iIndex);
|
|
|
|
static bool IsAnyMovieRender3D(bool& bNeedEmissivePass);
|
|
static bool IsAnyMovieRender3DSolid();
|
|
|
|
static bool IsFullScreenScaleformMovieBlockingInput();
|
|
|
|
static void RenderWorldSpaceSolidPass();
|
|
static void RenderWorldSpaceDiffusePass();
|
|
static void RenderWorldSpaceEmissivePass();
|
|
static void InitRenderStateBlocks();
|
|
static s32 GetMovieNumRefs(s32 iId);
|
|
|
|
static grcBlendStateHandle ms_defDiffuseBlendState;
|
|
static grcDepthStencilStateHandle ms_defDiffuseDepthStencilState;
|
|
static grcRasterizerStateHandle ms_defDiffuseRasterizerState;
|
|
|
|
static grcBlendStateHandle ms_defEmissiveBlendState;
|
|
static grcDepthStencilStateHandle ms_defEmissiveDepthStencilState;
|
|
static grcRasterizerStateHandle ms_defEmissiveRasterizerState;
|
|
|
|
static grcBlendStateHandle ms_defExitBlendState;
|
|
static grcDepthStencilStateHandle ms_defExitDepthStencilState;
|
|
static grcRasterizerStateHandle ms_defExitRasterizerState;
|
|
|
|
#if TRACK_FLIP_BUFFERS
|
|
static u32 sm_BeginFrameCount;
|
|
#endif
|
|
|
|
#if __BANK
|
|
private:
|
|
static s32 ms_iDebugMovieId;
|
|
static float ms_emissiveLevel;
|
|
static char ms_cDebugMovieName[256];
|
|
static char ms_cDebugMethod[256];
|
|
static char ms_cDebugLoadedMovieName[256];
|
|
static char ms_cDebugIgnoreMethod[256];
|
|
static Vector2 ms_vDebugMoviePos;
|
|
static Vector2 ms_vDebugMovieSize;
|
|
static bool ms_bVerifyActionScriptMethods;
|
|
static bool ms_bPrintDebugInfoLog;
|
|
static bool ms_bShowOutlineFor3DMovie;
|
|
public: // so we can turn it on from a simple helper function
|
|
static bool ms_bShowOutlineFor2DMovie;
|
|
static bool ms_bShowMemberVariables;
|
|
static bool ms_bFullNames;
|
|
static bool ms_bWildcardNameisRecursive;
|
|
static bool ms_bDrawStandardVariables;
|
|
static Vector2 ms_vTextOverride;
|
|
static int ms_iMaxMemberVariableDepth;
|
|
private:
|
|
static atHashWithStringBank ms_OutlineFilter;
|
|
static bool ms_bOverrideEmissiveLevel;
|
|
|
|
static bool ms_bShowPerformanceInfo;
|
|
static bool ms_bShowPreallocationInfo;
|
|
static bool ms_bShowAllPreallocationInfo;
|
|
static bool ms_bShowRefCountInfo;
|
|
static bool ms_bDebugOutputOn;
|
|
static bool ms_bFilterAwayDebugLog;
|
|
|
|
static void ShutdownWidgets();
|
|
static void ShowFontCacheTexture();
|
|
|
|
private:
|
|
static void OutputListOfActiveScaleformMoviesToLog();
|
|
static void ReadjustDebugMovie();
|
|
static void LoadDebugMovie();
|
|
static void UnloadDebugMovie();
|
|
static void UpdateLoadedDebugMovieName();
|
|
static void CallDebugMethod();
|
|
static void DebugTurnOnOffOutputForAllMovies();
|
|
static void DebugTurnOnOffOutput(s32 iIndex, bool bWasJustInitialized = true);
|
|
public:
|
|
static void PassDebugMethodParams(const char *pDebugMethodString);
|
|
static void RenderDebugMovie();
|
|
static bool ms_bShowExtraDebugInfo;
|
|
|
|
static GFxResource* ms_watchedResource;
|
|
static void ScaleformAddRefCB(GFxResource* whichRsc, int oldCount, int newCount);
|
|
static void ScaleformDecRefCB(GFxResource* whichRsc, int oldCount, int newCount);
|
|
|
|
#endif //__BANK
|
|
|
|
private:
|
|
static GFxValue EndMethodInternal(bool bCallInstantly, bool bStoreReturnedValue);
|
|
static GFxValue CallMethodInternal(s32 iIndex, s32 iIndexMovieLinkedTo, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName, const GFxValue *pArgs, s32 iNumberOfParams, bool bCallInstantly, bool bStoreReturnValue, s32 iReturnId, COMPLEX_OBJECT_ID ComplexObjectIdToInvoke);
|
|
static GFxValue AddMethodToBuffer(s32 iIndex, s32 iIndexMovieLinkedTo, eSCALEFORM_BASE_CLASS iBaseClass, const char *pFunctionName, const GFxValue *pArgs, s32 iNumberOfParams, bool bStoreReturnedValue, COMPLEX_OBJECT_ID ComplexObjectIdToInvoke);
|
|
static bool HasExternalInterfaceBeenCalled();
|
|
|
|
static atArray<ScaleformMethodStruct> sm_MethodInvokeInfo[2];
|
|
static atArray<ScaleformMethodStruct> sm_MethodCallbackInfo[2];
|
|
|
|
static ScaleformMethodReturnStruct sm_ReturnValuesFromInvoke[MAX_STORED_RETURN_VALUES];
|
|
static ScaleformMethodReturnStruct sm_ReturnValuesForAccess[MAX_STORED_RETURN_VALUES];
|
|
static s32 sm_iMethodInvokeInfoBufferInUse;
|
|
static bool ms_bExternalInterfaceCalled[3];
|
|
static bool ms_bFrameBegun;
|
|
static bool ms_bfullScreenBlockedInputLastFrame;
|
|
|
|
static sfScaleformManager* m_staticMovieMgr;
|
|
|
|
static Vector2 ms_vScreenSize;
|
|
|
|
static ScaleformMethodStruct sm_ScaleformMethodBuild[MAX_METHOD_BUILD_BUFFERS];
|
|
|
|
static s32 ms_iGlobalReturnCounterUT;
|
|
static s32 ms_iGlobalReturnCounterRT;
|
|
static s32 ms_iReturnValueCount;
|
|
|
|
static s32 ms_iFontMovieId;
|
|
|
|
static sysCriticalSectionToken sm_RealSafeZoneToken;
|
|
static sysCriticalSectionToken sm_InvokeFlushToken;
|
|
|
|
public:
|
|
static atArray<ScaleformMovieStruct> sm_ScaleformArray;
|
|
|
|
static char sm_LastMovieName[255];
|
|
static char sm_LastMethodName[255];
|
|
static char sm_LastMethodParamName[MAX_CHARS_IN_SCALEFORM_METHOD_CALL_STRING];
|
|
static bool sm_bIsInsideActionScript;
|
|
|
|
static char* sm_CurrTextureDictName;
|
|
|
|
private:
|
|
|
|
// helper class to
|
|
class CSorted3DMovie
|
|
{
|
|
|
|
public:
|
|
|
|
CSorted3DMovie() : m_fSqrDist(0.0f), m_iMovieId(INVALID_MOVIE_ID) {}
|
|
|
|
bool operator >(const CSorted3DMovie& op) const { return m_fSqrDist > op.m_fSqrDist; }
|
|
bool operator >=(const CSorted3DMovie& op) const { return m_fSqrDist >= op.m_fSqrDist; }
|
|
|
|
float m_fSqrDist;
|
|
int m_iMovieId;
|
|
|
|
};
|
|
|
|
static fwLinkList<CSorted3DMovie> ms_Sorted3DMovies;
|
|
static Vector3 ms_LastCameraPos;
|
|
typedef fwLink<CSorted3DMovie> CSorted3DMovieNode;
|
|
|
|
};
|
|
|
|
|
|
class CScaleformMovieWrapper
|
|
{
|
|
public:
|
|
|
|
struct Param
|
|
{
|
|
Param() {m_data.param_type = PARAM_TYPE_INVALID;}
|
|
Param(u32 value) {m_data.ParamNumber = (double)value; m_data.param_type = PARAM_TYPE_NUMBER;}
|
|
Param(int value) {m_data.ParamNumber = (double)value; m_data.param_type = PARAM_TYPE_NUMBER;}
|
|
Param(float value) {m_data.ParamNumber = (double)value; m_data.param_type = PARAM_TYPE_NUMBER;}
|
|
Param(double value) {m_data.ParamNumber = value; m_data.param_type = PARAM_TYPE_NUMBER;}
|
|
Param(bool value) {m_data.bParamBool = value; m_data.param_type = PARAM_TYPE_BOOL;}
|
|
Param(const char* value, bool convertToHtml=true) { m_data.pExternalString = const_cast<char*>(value); m_data.param_type = PARAM_TYPE_EXTERNAL_STRING; m_convertToHtml = convertToHtml;}
|
|
Param(const atString& value, bool convertToHtml=true) { m_data.pExternalString = const_cast<char*>(value.c_str()); m_data.param_type = PARAM_TYPE_EXTERNAL_STRING; m_convertToHtml = convertToHtml;}
|
|
Param(GFxValue* value) {m_data.pParamGfxValue = value; m_data.param_type = PARAM_TYPE_GFXVALUE;}
|
|
|
|
void AddParam();
|
|
|
|
private:
|
|
ScaleformMethodStruct::ParamStruct m_data;
|
|
bool m_convertToHtml;
|
|
};
|
|
|
|
CScaleformMovieWrapper(bool bUseSystemTime = true);
|
|
CScaleformMovieWrapper(const char* pFilename, eSCALEFORM_BASE_CLASS iBaseClass = SF_BASE_CLASS_GENERIC, bool bUseSystemTime = true);
|
|
~CScaleformMovieWrapper();
|
|
public:
|
|
|
|
void AffectRenderSize(float fScalar);
|
|
void Render(bool bForceUpdateBeforeRender = false, float fAlpha = 1.0f);
|
|
|
|
void CreateMovie(eSCALEFORM_BASE_CLASS iBaseClass, const char* pFilename, Vector2 vPos = Vector2(0.0f, 0.0f), Vector2 vSize = Vector2(1.0f,1.0f), bool bRemovable = true, s32 iParentMovie = INVALID_MOVIE_ID, s32 iDependentMovie = INVALID_MOVIE_ID, bool bRequiresMovieView = true, eMovieOwnerTags calledBy = SF_MOVIE_TAGGED_BY_CODE, bool bIgnoreSuperWidescreenAdjustment = false);
|
|
void CreateMovieAndWaitForLoad(eSCALEFORM_BASE_CLASS iBaseClass, const char* pFilename, Vector2 vPos = Vector2(0.0f, 0.0f), Vector2 vSize = Vector2(1.0f,1.0f), bool bRemovable = true, s32 iParentMovie = INVALID_MOVIE_ID, s32 iDependentMovie = INVALID_MOVIE_ID, bool bRequiresMovieView = true, eMovieOwnerTags calledBy = SF_MOVIE_TAGGED_BY_CODE, bool bIgnoreSuperWidescreenAdjustment = false);
|
|
void SetUseSystemTime(bool bDoesIt) { m_bUseSystemTime = bDoesIt; }
|
|
void RemoveMovie();
|
|
void Clear();
|
|
|
|
bool CallMethod(const char* method,
|
|
Param param1=Param(), Param param2=Param(), Param param3=Param(), Param param4=Param());
|
|
|
|
bool BeginMethod(const char* method);
|
|
void EndMethod();
|
|
s32 EndMethodReturnValue(const s32 iExistingReturnValue = 0);
|
|
void AddParam(Param param);
|
|
void AddParamString(const char *pParam, bool bConvertToHtml = true);
|
|
void AddParamLocString(const char *pParam, bool bConvertToHtml = true);
|
|
void AddParamLocString(u32 hash, bool bConvertToHtml = true);
|
|
s32 GetMovieID() const { return m_iMovieId; }
|
|
s32* GetMovieIDPtr() { return &m_iMovieId;}
|
|
|
|
void ForceCollectGarbage() {CScaleformMgr::ForceCollectGarbage(m_iMovieId);}
|
|
|
|
bool SetDisplayConfig(CScaleformMgr::SDC flags = CScaleformMgr::SDC::Default);
|
|
|
|
bool IsActive() const;
|
|
bool IsFree() const { return m_iMovieId == INVALID_MOVIE_ID; }
|
|
|
|
static void Shutdown();
|
|
|
|
private:
|
|
s32 m_iMovieId;
|
|
eSCALEFORM_BASE_CLASS m_iBaseClass;
|
|
bool m_bUseSystemTime;
|
|
#if TRACK_STALE_REFERENCES
|
|
public:
|
|
inlist_node<CScaleformMovieWrapper> m_StaleListNode;
|
|
#endif
|
|
};
|
|
|
|
#if TRACK_STALE_REFERENCES
|
|
typedef inlist<CScaleformMovieWrapper, &CScaleformMovieWrapper::m_StaleListNode> SFStaleList;
|
|
#endif
|
|
|
|
class sfCallGameFromFlash : public GFxExternalInterface
|
|
{
|
|
public:
|
|
virtual void Callback(GFxMovieView *pMovieView, const char* methodName, const GFxValue* args, UInt argCount);
|
|
};
|
|
|
|
DEFINE_CLASS_ENUM_FLAG_FUNCTIONS(CScaleformMgr::SDC);
|
|
|
|
#endif // _SCALEFORMMGR_H_
|
|
|
|
// eof
|