1036 lines
29 KiB
Ucode
1036 lines
29 KiB
Ucode
/**
|
|
* MobilePlayerInput
|
|
*
|
|
* This is the base class for processing input for mobile devices while in the game
|
|
*
|
|
* Copyright 1998-2013 Epic Games, Inc. All Rights Reserved.
|
|
*/
|
|
|
|
class MobilePlayerInput extends PlayerInput within GamePlayerController
|
|
native
|
|
DependsOn(MobileInputZone)
|
|
config(Game);
|
|
|
|
/**
|
|
* This structure contains data for individual touch events queued for a specific touch handle
|
|
*/
|
|
|
|
struct native TouchDataEvent
|
|
{
|
|
/** Holds the type of event */
|
|
var ETouchType EventType;
|
|
|
|
/** What touchpad this came from */
|
|
var byte TouchpadIndex;
|
|
|
|
/** Holds the current location of the touch */
|
|
var vector2D Location;
|
|
|
|
/** Holds the device timestamp of when this event occurred */
|
|
var double DeviceTime;
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* the MPI keeps track of all touches coming from a device. When the status of a touch changes, it tracks it and then passes it along to
|
|
* the associated MobileInputZone.
|
|
*/
|
|
|
|
struct native TouchData
|
|
{
|
|
/** Holds the ID of the current touch */
|
|
var int Handle;
|
|
|
|
/** What touchpad this came from */
|
|
var byte TouchpadIndex;
|
|
|
|
/** Holds the current location of the touch */
|
|
var vector2D Location;
|
|
|
|
/** Total distance that the finger moved since it initially touched down */
|
|
var float TotalMoveDistance;
|
|
|
|
/** Holds the device timestamp of when the original touch occurred */
|
|
var double InitialDeviceTime;
|
|
|
|
/** How long this touch has been active */
|
|
var float TouchDuration;
|
|
|
|
/** Device timestamp of most recent event */
|
|
var double MoveEventDeviceTime;
|
|
|
|
/** Time delta between the movement events the last time this touch moved */
|
|
var float MoveDeltaTime;
|
|
|
|
/** If true, this touch entry is in use, otherwise feel free to use it for touches */
|
|
var bool bInUse;
|
|
|
|
/** Holds the zone that is currently processing this touch */
|
|
var MobileInputZone Zone;
|
|
|
|
/** Holds the current state of the touch */
|
|
var ETouchType State;
|
|
|
|
/** Events queued up for this touch. Because we may receive several touch movement events per tick,
|
|
we store a list of events and process them in order when we can. */
|
|
var array<TouchDataEvent> Events;
|
|
|
|
/** Holds the last active time (via TimeSeconds()) that will be used to timeout a zone */
|
|
var float LastActiveTime;
|
|
};
|
|
|
|
/**
|
|
* This enum contains the orientations of the interface (not the device)
|
|
* The order of this currently matches the IPhone and changing it will break that device unless you fix those references
|
|
*/
|
|
enum EUIOrientation
|
|
{
|
|
UI_Unknown,
|
|
UI_Portait,
|
|
UI_PortaitUpsideDown,
|
|
UI_LandscapeRight,
|
|
UI_LandscapeLeft,
|
|
};
|
|
|
|
/** Keeps track of all of the touches currently active on a device */
|
|
const NumTouchDataEntries = 5;
|
|
var (Input) TouchData Touches[NumTouchDataEntries];
|
|
|
|
/**
|
|
* The object that the user is currently interacting with.
|
|
* e.g. When a user presses on the button, this button is the
|
|
* interactive object until the user raises her finger and causes
|
|
* an UnTouch event.
|
|
*/
|
|
var MobileMenuObject InteractiveObject;
|
|
|
|
/** Last time interactive object process input */
|
|
var double InteractiveObjectLastTime;
|
|
|
|
/** Defines a mobile input group */
|
|
struct native MobileInputGroup
|
|
{
|
|
/** The name of this group */
|
|
var string GroupName;
|
|
|
|
/** The List of zones associated with this group */
|
|
var editinline array<MobileInputZone> AssociatedZones;
|
|
};
|
|
|
|
/** Holds a list of available groups */
|
|
var (Input) EditInline array<MobileInputGroup> MobileInputGroups;
|
|
|
|
/** Holds the index of the current group */
|
|
var (Input) int CurrentMobileGroup;
|
|
|
|
/** Holds a list of mobile input zones. */
|
|
var (Input) editinline array<MobileInputZone> MobileInputZones;
|
|
|
|
/** Record of each MobileInputZone class (and subclasses) instances */
|
|
struct native MobileInputZoneClassMap
|
|
{
|
|
/* Name of the instance */
|
|
var string Name;
|
|
|
|
/* Class type of the instance */
|
|
var class<MobileInputZone> ClassType;
|
|
};
|
|
|
|
/** Classes that inherit from MobileInputZone - filled in by NativeInitializeInputSystem() */
|
|
var array<MobileInputZoneClassMap> MobileInputZoneClasses;
|
|
|
|
/** Holds the current Tilt value for mobile devices */
|
|
var (Input) float MobilePitch;
|
|
|
|
/** Holds the center value for the pitch. */
|
|
var (Input) float MobilePitchCenter;
|
|
|
|
/** Pitch sensitivity */
|
|
var (Input) float MobilePitchMultiplier;
|
|
|
|
/** Holds the current Yaw value for mobile devices */
|
|
var (Input) float MobileYaw;
|
|
|
|
/** Holds the center value for the Yaw. */
|
|
var (Input) float MobileYawCenter;
|
|
|
|
/** Pitch sensitivity */
|
|
var (Input) float MobileYawMultiplier;
|
|
|
|
/** How much of a dead zone should the pitch have */
|
|
var (input) config float MobilePitchDeadzoneSize;
|
|
|
|
/** How much of a dead zone should the yaw have */
|
|
var (input) config float MobileYawDeadzoneSize;
|
|
|
|
/** Used to determine if a touch is a double tap */
|
|
var (input) config float MobileDoubleTapTime;
|
|
|
|
/** You have to hold down a tap at least this long to register it as a tap */
|
|
var (input) config float MobileMinHoldForTap;
|
|
|
|
/** Used to determine how quickly to send repeat events for touch+held */
|
|
var (input) config float MobileTapRepeatTime;
|
|
|
|
/** If true, we want to allow input to occur during a cinematic */
|
|
var (input) bool bAllowTouchesInCinematic;
|
|
/** If set to true, then touches will be ignored */
|
|
var (input) bool bDisableTouchInput;
|
|
/** if set pass absolute touch locations instead of relative to the viewport location
|
|
* (i.e. if this is true don't subtract MobileViewportOffset from touch locations)
|
|
*/
|
|
var (input) config bool bAbsoluteTouchLocations;
|
|
/** Holds the amount of time that a zone can go without input before being consider timed out */
|
|
var (input) config float ZoneTimeout;
|
|
/** If true this will collapse similar mobile inputs so that they won't get processed */
|
|
var (input) config bool bCollapseTouchInput;
|
|
|
|
// **********************************************************************************
|
|
// The MobilePlayerInput is also the hub for the mobile menu system.
|
|
// **********************************************************************************
|
|
|
|
/** This is the menu stack. */
|
|
var (menus) array<MobileMenuScene> MobileMenuStack;
|
|
|
|
/** Used for debugging native code */
|
|
var (debug) string NativeDebugString;
|
|
|
|
/** This will be set in NativeInitializeInputZones if -SimMobile is on the command line. */
|
|
var (debug) bool bFakeMobileTouches;
|
|
|
|
// Holds the amount of time the view port has been inactive
|
|
var (Current) float MobileInactiveTime;
|
|
|
|
// Ability to disable rendering of scenes.
|
|
var (debug) bool bDisableSceneRender;
|
|
|
|
// **********************************************************************************
|
|
// Motion support
|
|
// **********************************************************************************
|
|
|
|
/**
|
|
* A General note about the DeviceMotion* variables. The engine will attempt to use any motion sensing system
|
|
* built in to the device to fill out these values. For values not supported by the device, we will attempt to generate
|
|
* values given the capibilites. but so values may not be available / reliable
|
|
*/
|
|
|
|
|
|
|
|
/** Holds a list of handlers looking to listen in on Motion events */
|
|
var (Current) array<SeqEvent_MobileBase> MobileSeqEventHandlers;
|
|
|
|
/** Holds a list of handlers looking to listen in on raw touch events */
|
|
var (Current) array<SeqEvent_MobileRawInput> MobileRawInputSeqEventHandlers;
|
|
|
|
|
|
// @DEBUG - Remove if you wish to see all touch events
|
|
//var array<string> TouchDebug;
|
|
|
|
/** Store the current adjusted viewport size so we can adjust mobile input zones */
|
|
var vector2D MobileViewportOffset;
|
|
var vector2D MobileViewportSize;
|
|
|
|
/**
|
|
* Process Mobile Input, handles mobile user input
|
|
* Should be called regardless of game state.
|
|
*/
|
|
native function ProcessMobileInput( float DeltaTime );
|
|
|
|
/**
|
|
* Function to cancel all mobile input before a Scaleform movie confuses the state
|
|
*/
|
|
native function CancelMobileInput();
|
|
|
|
/**
|
|
* Overload the super PlayerInput event
|
|
*/
|
|
event PlayerInput( float DeltaTime )
|
|
{
|
|
// Process the mobile input, this method is explicitly called regardless
|
|
// of whether the game is paused so as to allow the mobile touch info
|
|
// to be updated even when paused.
|
|
ProcessMobileInput( DeltaTime );
|
|
|
|
// update any other player input info.
|
|
Super.PlayerInput( DeltaTime );
|
|
}
|
|
|
|
cpptext
|
|
{
|
|
/**
|
|
* Takes a touch and looks up the InputZone that would handle it.
|
|
*
|
|
* @param TouchLocation Where the touch occurred
|
|
* @param TouchpadIndex The index of the touchpad this touch came from
|
|
* @returns the zone that will be managing this touch
|
|
*/
|
|
UMobileInputZone* HitTest(FVector2D TouchLocation, UINT TouchpadIndex);
|
|
|
|
/**
|
|
* Process an input key event received from the viewport.
|
|
*
|
|
* @param Viewport the viewport the input event was received from
|
|
* @param ControllerId gamepad/controller that generated this input event
|
|
* @param Key the name of the key which an event occured for (KEY_Up, KEY_Down, etc.)
|
|
* @param EventType the type of event which occured (pressed, released, etc.)
|
|
* @param AmountDepressed (analog keys only) the depression percent.
|
|
* @param bGamepad - input came from gamepad (ie xbox controller)
|
|
*
|
|
* @return TRUE to consume the key event, FALSE to pass it on.
|
|
*/
|
|
virtual UBOOL InputKey(INT ControllerId,FName Key,EInputEvent Event,FLOAT AmountDepressed=1.f,UBOOL bGamepad=FALSE);
|
|
|
|
/**
|
|
* Process an input axis (joystick, thumbstick, or mouse) event received from the viewport.
|
|
*
|
|
* @param Viewport the viewport the input event was received from
|
|
* @param ControllerId the controller that generated this input axis event
|
|
* @param Key the name of the axis that moved (KEY_MouseX, KEY_XboxTypeS_LeftX, etc.)
|
|
* @param Delta the movement delta for the axis
|
|
* @param DeltaTime the time (in seconds) since the last axis update.
|
|
*
|
|
* @return TRUE to consume the axis event, FALSE to pass it on.
|
|
*/
|
|
virtual UBOOL InputAxis(INT ControllerId,FName Key,FLOAT Delta,FLOAT DeltaTime, UBOOL bGamepad=FALSE);
|
|
|
|
/**
|
|
* Handle a touch event coming from the device.
|
|
*
|
|
* NOTE: no processing of the touch happens here. This just tracks the touch in the Touches stack. Processing
|
|
* happens each tick
|
|
*
|
|
* @param Handle the id of the touch
|
|
* @param Type What type of event is this
|
|
* @param TouchLocation Where the touch occurred
|
|
* @param DeviceTimestamp Input event timestamp from the device
|
|
* @param TouchpadIndex The index of the touchpad this touch came from
|
|
*/
|
|
virtual UBOOL InputTouch(INT ControllerId, UINT Handle, ETouchType Type, FVector2D TouchLocation, DOUBLE DeviceTimestamp, UINT TouchpadIndex=0);
|
|
|
|
/**
|
|
* Update active touches, etc
|
|
*
|
|
* @param DeltaTime Much time has elapsed since the last processing
|
|
*/
|
|
virtual void Tick(FLOAT DeltaTime);
|
|
|
|
/**
|
|
* When input comes in to the player input, the first thing we need to do is process it for
|
|
* the menus.
|
|
*
|
|
* @param TouchHandle A unique id for the touch
|
|
* @param TouchpadIndex The index of the touchpad this touch came from
|
|
* @param EventType What type of event is this
|
|
* @param TouchLocation Where the touch occurred
|
|
* @param DeviceTimestamp Time this event happened.
|
|
*
|
|
* @returns true if the menu system swallowed the input
|
|
*/
|
|
UBOOL ProcessMenuInput(UINT TouchHandle, UINT TouchpadIndex, ETouchType EventType, FVector2D TouchLocation, DOUBLE DeviceTimestamp);
|
|
|
|
|
|
/**
|
|
* This function will iterate over the MobileSeqEventHandles array and cause them to be updated.
|
|
* It get's called once per frame.
|
|
*/
|
|
void UpdateListeners();
|
|
|
|
/**
|
|
* Returns the Global Scaling values
|
|
*
|
|
* @return a FVector2 containing the global scale values
|
|
*/
|
|
FVector2D GetGlobalScale();
|
|
|
|
|
|
/**
|
|
* Swap around components of a vector (with rotational values) based on an orientation.
|
|
* This will swap pitch and roll when a mobile device is rotated 90 degrees, etc
|
|
*
|
|
* @param Vec [in/out] Vector to modify
|
|
* @param Orientation Orientation for which the values were generated in
|
|
* @param bIsRotation TRUE if the vector represents rotation, not a directional vector
|
|
*/
|
|
static void ModifyVectorByOrientation(FVector& Vec, EUIOrientation Orientation, UBOOL bIsRotation)
|
|
{
|
|
switch (Orientation)
|
|
{
|
|
case UI_Portait:
|
|
// this is the base orientation, so nothing to do
|
|
break;
|
|
|
|
case UI_PortaitUpsideDown:
|
|
if (bIsRotation)
|
|
{
|
|
// negate roll and pitch
|
|
Vec.X = -Vec.X;
|
|
Vec.Z = -Vec.Z;
|
|
}
|
|
else
|
|
{
|
|
// negate x/y
|
|
Vec.X = -Vec.X;
|
|
Vec.Y = -Vec.Y;
|
|
}
|
|
break;
|
|
|
|
case UI_LandscapeRight:
|
|
if (bIsRotation)
|
|
{
|
|
// swap and negate (as needed) roll and pitch
|
|
FLOAT Temp = Vec.X;
|
|
Vec.X = -Vec.Z;
|
|
Vec.Z = Temp;
|
|
}
|
|
else
|
|
{
|
|
// swap and negate (as needed) x and y
|
|
FLOAT Temp = Vec.X;
|
|
Vec.X = -Vec.Y;
|
|
Vec.Y = Temp;
|
|
}
|
|
break;
|
|
|
|
case UI_LandscapeLeft:
|
|
if (bIsRotation)
|
|
{
|
|
// swap and negate (as needed) roll and pitch
|
|
FLOAT Temp = Vec.X;
|
|
Vec.X = Vec.Z;
|
|
Vec.Z = -Temp;
|
|
}
|
|
else
|
|
{
|
|
// swap and negate (as needed) x and y
|
|
FLOAT Temp = Vec.X;
|
|
Vec.X = Vec.Y;
|
|
Vec.Y = -Temp;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public:
|
|
/**
|
|
* Determine the size of the current interactive canvas
|
|
*
|
|
* @param ViewportSize Size of the canvas
|
|
*/
|
|
void GetInteractiveViewportSize(FVector2D& ViewportSize);
|
|
|
|
/**
|
|
* Initialize, or reinitialize a zone
|
|
*
|
|
* @param Zone The Zone to initialize
|
|
* @param ViewportSize Size of the canvas
|
|
* @param bIsFirstInitialize TRUE if this is the first time the zone is initialized (use FALSE when canvas was resized)
|
|
*/
|
|
void NativeInitializeZone(UMobileInputZone* Zone, const FVector2D& ViewportSize, UBOOL bIsFirstInitialize);
|
|
};
|
|
|
|
/**
|
|
* Invoked when the mobile menus did not process an Touch_Began.
|
|
*/
|
|
delegate OnTouchNotHandledInMenu();
|
|
|
|
/**
|
|
* PreviewTouch X,Y - screenspace coordinates; true/false for handled/not handled.
|
|
*/
|
|
delegate bool OnPreviewTouch(float X, float Y, int TouchpadIndex);
|
|
|
|
/**
|
|
* OnInputTouch is a low level handler for getting the actual touch data
|
|
*/
|
|
delegate OnInputTouch(int Handle, ETouchType Type, Vector2D TouchLocation, float DeviceTimestamp, int TouchpadIndex);
|
|
|
|
/**
|
|
* Perform any native initialization of the subsystem
|
|
*/
|
|
native function NativeInitializeInputSystem();
|
|
|
|
/**
|
|
* Iterates over the zones and pre-calculates the actual bounds based on the current device resolution
|
|
*/
|
|
native function NativeInitializeInputZones(bool bIsFirstInitialize);
|
|
|
|
/**
|
|
* Update the mobile touch zones if the viewport aspect ratio changes
|
|
*/
|
|
native function ConditionalUpdateInputZones(int NewViewportX, int NewViewportY, int NewViewportSizeX, int NewViewportSizeY);
|
|
|
|
/**
|
|
* Allows the game to send a InputKey event though the viewport.
|
|
*
|
|
* @param Key the new of the key we are sending
|
|
* @param Event the Type of event
|
|
* @param AmountDepressed the strength of the event
|
|
*/
|
|
native function SendInputKey(name Key, EInputEvent Event, float AmountDepressed);
|
|
|
|
/**
|
|
* Allows the game to send an InputAxis event through the viewport
|
|
*
|
|
* @param Key the key we are sending
|
|
* @param Delta the movement delta for the axis
|
|
* @param DeltaTime the time (in seconds) since the last axis update.
|
|
*/
|
|
native function SendInputAxis(name Key, FLOAT Delta, FLOAT DeltaTime);
|
|
|
|
/**
|
|
* Handle touch events in the 3D world. To use this assign the OnTapDelegate in a MobileInputZone to this function.
|
|
*
|
|
* @param Zone The mobile Input zone that triggered the delegate
|
|
* @param EventType The type of input event that occurred
|
|
* @param TouchLocation The screen location of the touch event
|
|
*
|
|
* @return true if the world actor swallows the input
|
|
*/
|
|
native function bool ProcessWorldTouch(MobileInputZone Zone, ETouchType EventType, Vector2D TouchLocation);
|
|
|
|
/**
|
|
* The player controller will call this function directly after creating the input system
|
|
*/
|
|
function InitInputSystem()
|
|
{
|
|
super.InitInputSystem();
|
|
InitTouchSystem();
|
|
}
|
|
|
|
/**
|
|
* When the client inits the input system, initialize it's touch system
|
|
*/
|
|
function ClientInitInputSystem()
|
|
{
|
|
super.ClientInitInputSystem();
|
|
InitTouchSystem();
|
|
}
|
|
|
|
function InitTouchSystem()
|
|
{
|
|
NativeInitializeInputSystem();
|
|
|
|
// We only want to initialize the
|
|
if (bFakeMobileTouches || WorldInfo.IsConsoleBuild(CONSOLE_Mobile))
|
|
{
|
|
InitializeInputZones();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initializes the input zones
|
|
*/
|
|
function InitializeInputZones()
|
|
{
|
|
local int i,j;
|
|
local MobileInputZone Zone;
|
|
local class<FrameworkGame> FrameworkGameClass;
|
|
|
|
// In a MP game, this function gets called twice - and that caused the zone
|
|
// to be initialized twice making its pos/size wrong.
|
|
if (MobileInputGroups.Length > 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
FrameworkGameClass = Class<FrameworkGame>(WorldInfo.GRI.GameClass);
|
|
|
|
//`log("Initializing Input zones");
|
|
|
|
if (FrameworkGameClass != none)
|
|
{
|
|
//`log("No of Config Groups:"@FrameworkGameClass.Default.RequiredMobileInputConfigs.Length);
|
|
|
|
// Allocate Space
|
|
MobileInputGroups.Length = FrameworkGameClass.Default.RequiredMobileInputConfigs.Length;
|
|
|
|
for(i=0;i<FrameworkGameClass.Default.RequiredMobileInputConfigs.Length;i++)
|
|
{
|
|
// Add a Group for this config.
|
|
|
|
//`log("Building Group"@FrameworkGameClass.Default.RequiredMobileInputConfigs[i].GroupName);
|
|
|
|
// Attempt to add a game-defined, optional "DebugZone" if not final release script
|
|
// `if(`notdefined(FINAL_RELEASE))
|
|
// Zone = FindOrAddZone("DebugZone");
|
|
// if (Zone != none)
|
|
// {
|
|
// //`log(" Adding special DebugZone");
|
|
// MobileInputGroups[i].AssociatedZones.AddItem(Zone);
|
|
// }
|
|
// `endif
|
|
|
|
MobileInputGroups[i].GroupName = FrameworkGameClass.Default.RequiredMobileInputConfigs[i].GroupName;
|
|
for (j=0;j < FrameworkGameClass.Default.RequiredMobileInputConfigs[i].RequireZoneNames.Length;j++)
|
|
{
|
|
Zone = FindOrAddZone(FrameworkGameClass.Default.RequiredMobileInputConfigs[i].RequireZoneNames[j]);
|
|
MobileInputGroups[i].AssociatedZones.AddItem(Zone);
|
|
}
|
|
}
|
|
|
|
// Initialize the stored viewport size
|
|
LocalPlayer(Outer.Player).ViewportClient.GetViewportSize(MobileViewportSize);
|
|
|
|
// Perform the native initialization for them
|
|
NativeInitializeInputZones(true);
|
|
RefreshKismetLinks();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Search for zone in the list and return it if found
|
|
*
|
|
*/
|
|
function SwapZoneOwners()
|
|
{
|
|
local int i;
|
|
for (i=0;i<MobileInputZones.Length;i++)
|
|
{
|
|
MobileInputZones[i].InputOwner = self;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The SeqEvent's from the level's kismet will have their RegisterEvent function called before the inputzones are
|
|
* configured. So just this once, have all of them try again.
|
|
*/
|
|
event RefreshKismetLinks()
|
|
{
|
|
local array<SequenceObject> MobileInputSeqEvents;
|
|
local Sequence GameSeq;
|
|
local int i;
|
|
|
|
GameSeq = WorldInfo.GetGameSequence();
|
|
if (GameSeq != None)
|
|
{
|
|
// Find all SeqEvent_MobileInput objects anywhere and call RegisterEvent on them
|
|
GameSeq.FindSeqObjectsByClass(class'SeqEvent_MobileBase', TRUE, MobileInputSeqEvents);
|
|
|
|
for (i=0;i< MobileInputSeqEvents.Length; i++)
|
|
{
|
|
SeqEvent_MobileBase(MobileInputSeqEvents[i]).RegisterEvent();
|
|
}
|
|
|
|
// Find all SeqEvent_MobileRawInput objects anywhere and call RegisterEvent on them
|
|
MobileInputSeqEvents.length = 0;
|
|
GameSeq.FindSeqObjectsByClass(class'SeqEvent_MobileRawInput', TRUE, MobileInputSeqEvents);
|
|
|
|
for (i=0;i< MobileInputSeqEvents.Length; i++)
|
|
{
|
|
SeqEvent_MobileRawInput(MobileInputSeqEvents[i]).RegisterEvent();
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds a listen to the mobile handler list.
|
|
*
|
|
* @param Handler the MobileMotion sequence event to add to the handler list
|
|
*/
|
|
function AddKismetEventHandler(SeqEvent_MobileBase NewHandler)
|
|
{
|
|
local int i;
|
|
//`log("Adding Mobile Kismet handler " @ NewHandler.Name);
|
|
|
|
// More sure this event handler isn't already in the array
|
|
|
|
for (i=0;i<MobileSeqEventHandlers.Length;i++)
|
|
{
|
|
if (MobileSeqEventHandlers[i] == NewHandler)
|
|
{
|
|
return; // Already Registered
|
|
}
|
|
}
|
|
|
|
// Look though the array and see if there is an empty sport. These empty sports
|
|
// can occur when a kismet sequence is streamed out.
|
|
|
|
for (i=0;i<MobileSeqEventHandlers.Length;i++)
|
|
{
|
|
if (MobileSeqEventHandlers[i] == none)
|
|
{
|
|
MobileSeqEventHandlers[i] = NewHandler;
|
|
return;
|
|
}
|
|
}
|
|
|
|
MobileSeqEventHandlers.AddItem(NewHandler);
|
|
}
|
|
|
|
/**
|
|
* Adds a raw listen to the mobile handler list.
|
|
*
|
|
* @param Handler the MobileMotion sequence event to add to the handler list
|
|
*/
|
|
function AddKismetRawInputEventHandler(SeqEvent_MobileRawInput NewHandler)
|
|
{
|
|
local int i;
|
|
//`log("ZONE: Adding Mobile Kismet Raw input handler " @ NewHandler.Name);
|
|
|
|
// More sure this event handler isn't already in the array
|
|
|
|
for (i=0;i<MobileRawInputSeqEventHandlers.Length;i++)
|
|
{
|
|
if (MobileRawInputSeqEventHandlers[i] == NewHandler)
|
|
{
|
|
return; // Already Registered
|
|
}
|
|
}
|
|
|
|
// Look though the array and see if there is an empty sport. These empty sports
|
|
// can occur when a kismet sequence is streamed out.
|
|
|
|
for (i=0;i<MobileRawInputSeqEventHandlers.Length;i++)
|
|
{
|
|
if (MobileRawInputSeqEventHandlers[i] == none)
|
|
{
|
|
MobileRawInputSeqEventHandlers[i] = NewHandler;
|
|
return;
|
|
}
|
|
}
|
|
|
|
MobileRawInputSeqEventHandlers.AddItem(NewHandler);
|
|
}
|
|
|
|
/**
|
|
* Search for zone in the list and return it if found
|
|
*
|
|
* @param ZoneName - The name of the Mobile Input Zone we are looking for
|
|
* @returns a zone.
|
|
*/
|
|
function MobileInputzone FindZone(string ZoneName)
|
|
{
|
|
local int i;
|
|
for (i=0;i<MobileInputZones.Length;i++)
|
|
{
|
|
if (MobileInputZones[i].Name == Name(ZoneName))
|
|
{
|
|
return MobileInputZones[i];
|
|
}
|
|
}
|
|
|
|
return none;
|
|
}
|
|
|
|
/**
|
|
* Searchings the zone array for a zone and returns it if found. Otherwise add it and return the new zone
|
|
*
|
|
* @param ZoneName - The name of the Mobile Input Zone we are looking for
|
|
* @returns a zone.
|
|
*/
|
|
function MobileInputZone FindorAddZone(string ZoneName)
|
|
{
|
|
local MobileInputZone Zone;
|
|
local class<MobileInputZone> ClassType;
|
|
local int ClassIndex;
|
|
|
|
Zone = FindZone(ZoneName);
|
|
if (Zone == None)
|
|
{
|
|
ClassType = class'MobileInputZone';
|
|
|
|
// Search for the class type that is associated with ZoneName in the ini file.
|
|
for (ClassIndex = 0; ClassIndex < MobileInputZoneClasses.length; ClassIndex++)
|
|
{
|
|
if (ZoneName == MobileInputZoneClasses[ClassIndex].Name)
|
|
{
|
|
ClassType = MobileInputZoneClasses[ClassIndex].ClassType;
|
|
break;
|
|
}
|
|
}
|
|
Zone = new(none,ZoneName) ClassType;
|
|
Zone.InputOwner = self;
|
|
|
|
MobileInputZones.AddItem(Zone);
|
|
}
|
|
return Zone;
|
|
}
|
|
|
|
function bool HasZones()
|
|
{
|
|
return (MobileInputGroups.Length>0 && CurrentMobileGroup < MobileInputGroups.Length);
|
|
}
|
|
|
|
function array<MobileInputZone> GetCurrentZones()
|
|
{
|
|
return MobileInputGroups[CurrentMobileGroup].AssociatedZones;
|
|
}
|
|
|
|
exec function ActivateInputGroup(string GroupName)
|
|
{
|
|
local int i;
|
|
for (i=0;i<MobileInputGroups.Length;i++)
|
|
{
|
|
if (MobileInputGroups[i].GroupName == GroupName)
|
|
{
|
|
CurrentMobileGroup = i;
|
|
return;
|
|
}
|
|
}
|
|
|
|
`log("Attempted to activate a mobile input group" @ GroupName @ "that did not exist.");
|
|
}
|
|
|
|
/**
|
|
* Switch to the input config with the specified group name
|
|
*/
|
|
exec function SetMobileInputConfig(string GroupName)
|
|
{
|
|
local int NewConfig;
|
|
for( NewConfig=0; NewConfig<MobileInputGroups.Length; NewConfig++ )
|
|
{
|
|
if( MobileInputGroups[NewConfig].GroupName ~= GroupName )
|
|
break;
|
|
}
|
|
if( NewConfig < MobileInputGroups.Length )
|
|
{
|
|
CurrentMobileGroup = NewConfig;
|
|
//`Log("MobileInputConfig="$CurrentMobileGroup);
|
|
}
|
|
else
|
|
{
|
|
`Warn("Could not find a MobileInputGroup called" @ GroupName);
|
|
}
|
|
}
|
|
|
|
// **********************************************************************************
|
|
// Menu System
|
|
// **********************************************************************************
|
|
|
|
/**
|
|
* Call this function to open a menu scene.
|
|
*
|
|
* @param SceneClass - The class of the menu scene to open.
|
|
* @param Mode - Optional string that lets the opener pass extra information to the scene
|
|
*/
|
|
event MobileMenuScene OpenMenuScene(class<MobileMenuScene> SceneClass, optional string Mode)
|
|
{
|
|
|
|
local MobileMenuScene Scene;
|
|
local Vector2D ViewportSize;
|
|
|
|
if (SceneClass != none)
|
|
{
|
|
// We have the menu scene, create it.
|
|
|
|
Scene = new(outer) SceneClass;
|
|
if (Scene != none)
|
|
{
|
|
//`log("### OpenMenuScene "@SceneClass);
|
|
LocalPlayer(Outer.Player).ViewportClient.GetViewportSize(ViewportSize);
|
|
Scene.InitMenuScene(self, ViewportSize.X, ViewportSize.Y,true);
|
|
MobileMenuStack.InsertItem(0,Scene);
|
|
Scene.Opened(Mode);
|
|
Scene.MadeTopMenu();
|
|
return Scene;
|
|
}
|
|
else
|
|
{
|
|
`log("Could not create menu scene " $ SceneClass);
|
|
}
|
|
}
|
|
|
|
return none;
|
|
|
|
}
|
|
|
|
/**
|
|
* Call this function to close a menu scene. Remove it from the stack and notify the scene/etc.
|
|
*
|
|
* @param SceneToClose - The actual scene to close.
|
|
*/
|
|
event CloseMenuScene(MobileMenuScene SceneToClose)
|
|
{
|
|
local int i,idx;
|
|
local bool bClosedTopMenu;
|
|
|
|
// Check to make sure the Scene wants to let itself close
|
|
if (SceneToClose.Closing())
|
|
{
|
|
idx = -1;
|
|
// Find the scene in the stack
|
|
for (i=0;i<MobileMenuStack.Length;i++)
|
|
{
|
|
if (MobileMenuStack[i] == SceneToClose)
|
|
{
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (idx>=0)
|
|
{
|
|
// did we just remove the top menu?
|
|
bClosedTopMenu = (idx == 0);
|
|
MobileMenuStack.Remove(idx,1);
|
|
SceneToClose.Closed();
|
|
|
|
// if we closed the top menu, send a MadeTopMenu to the new top menu
|
|
if (bClosedTopMenu)
|
|
{
|
|
if (MobileMenuStack.length > 0)
|
|
{
|
|
MobileMenuStack[0].MadeTopMenu();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call this function to close all menus, used to "restart" the stack
|
|
*/
|
|
event CloseAllMenus()
|
|
{
|
|
while (MobileMenuStack.length > 0)
|
|
{
|
|
CloseMenuScene(MobileMenuStack[MobileMenuStack.length -1]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start the rendering chain for the UI Scenes
|
|
*
|
|
* @param Canvas - The canvas for drawing
|
|
*/
|
|
event RenderMenus(Canvas Canvas,float RenderDelta)
|
|
{
|
|
local int i;
|
|
Canvas.Reset();
|
|
|
|
if (bDisableSceneRender)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (i = MobileMenuStack.Length-1; i >= 0; i--)
|
|
{
|
|
MobileMenuStack[i].RenderScene(Canvas,RenderDelta);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* We need a PreClientTravel to clean up the menu system.
|
|
*/
|
|
function PreClientTravel( string PendingURL, ETravelType TravelType, bool bIsSeamlessTravel)
|
|
{
|
|
local int i;
|
|
Super.PreClientTravel(PendingURL, TravelType, bIsSeamlessTravel);
|
|
for (i = MobileMenuStack.Length-1; i >= 0; i--)
|
|
{
|
|
MobileMenuStack[i].Closed();
|
|
}
|
|
}
|
|
|
|
exec function SceneRenderToggle()
|
|
{
|
|
bDisableSceneRender = !bDisableSceneRender;
|
|
}
|
|
|
|
exec function MobileMenuCommand(string MenuCommand)
|
|
{
|
|
local int i;
|
|
for (i = 0; i < MobileMenuStack.Length; i++)
|
|
{
|
|
if (MobileMenuStack[i].MobileMenuCommand(MenuCommand))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Opens a menu by class
|
|
*
|
|
* @Param MenuClassName - the name of the class to open
|
|
*/
|
|
exec function MobileMenuScene OpenMobileMenu(string MenuClassName)
|
|
{
|
|
local class<MobileMenuScene> MenuClass;
|
|
|
|
MenuClass = class<MobileMenuScene>(DynamicLoadObject(MenuClassName,class'class'));
|
|
if (MenuClass != none)
|
|
{
|
|
return OpenMenuScene(MenuClass);
|
|
}
|
|
return none;
|
|
}
|
|
|
|
/**
|
|
* Opens a menu by class and passes extra info to the scene
|
|
*
|
|
* @Param MenuClassName - the name of the class to open - REQUIRES QUOTES!
|
|
* @Param Mode - the extra mode information to pass to the scene (two strings in OpenMobileMenu above breaks a.b for class names!)
|
|
*/
|
|
exec function MobileMenuScene OpenMobileMenuMode(string MenuClassName, string Mode)
|
|
{
|
|
local class<MobileMenuScene> MenuClass;
|
|
|
|
MenuClass = class<MobileMenuScene>(DynamicLoadObject(MenuClassName,class'class'));
|
|
if (MenuClass != none)
|
|
{
|
|
return OpenMenuScene(MenuClass, Mode);
|
|
}
|
|
return none;
|
|
}
|
|
|
|
// @DEBUG - Remove if you wish to see all touch events
|
|
/*
|
|
event AddTouchDebug(int Handle, TouchDataEvent Event)
|
|
{
|
|
local string s;
|
|
|
|
if (Event.EventType == Touch_Ended && Event.Location.Y > 400)
|
|
{
|
|
TouchDebug.Remove(0,TouchDebug.Length);
|
|
return;
|
|
}
|
|
|
|
if (Event.EventType == Touch_Moved)
|
|
{
|
|
return;
|
|
|
|
}
|
|
s = "TOUCH: Hander="@Handle @ "Event=" @ Event.EventType @ Event.Location.X @ Event.Location.Y;
|
|
AddTouchDebugMsg(s);
|
|
}
|
|
|
|
event AddTouchDebugMsg(string s)
|
|
{
|
|
local int i;
|
|
i = TouchDebug.Length;
|
|
TouchDebug.Length = i+1;
|
|
TouchDebug[i] = s;
|
|
|
|
if (TouchDebug.Length>20)
|
|
{
|
|
TouchDebug.Remove(0,1);
|
|
}
|
|
}
|
|
|
|
function DrawTouchDebug(canvas Canvas)
|
|
{
|
|
local int i;
|
|
local int y;
|
|
|
|
y = 80;
|
|
for (i=0;i<TouchDebug.Length;i++)
|
|
{
|
|
DrawDebugString(Canvas, TouchDebug[i],y);
|
|
y+=18;
|
|
}
|
|
}
|
|
|
|
function DrawDebugString(Canvas Canvas, string Msg, float y)
|
|
{
|
|
Canvas.SetPos(0,Y);
|
|
Canvas.SetDrawColor(0,0,0,255);
|
|
Canvas.DrawText(Msg);
|
|
Canvas.SetPos(1,Y+1);
|
|
Canvas.SetDrawColor(255,255,255,255);
|
|
Canvas.DrawText(Msg);
|
|
}
|
|
*/
|