< Summary

Class:	DCL.Interface.WebInterfaceControlEvent[T]
Assembly:	WebInterface
File(s):	/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/WebInterface/Interface.cs
Covered lines:	4
Uncovered lines:	0
Coverable lines:	4
Total lines:	1272
Line coverage:	100% (4 of 4)
Covered branches:	0
Total branches:	0

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	NPath complexity	Sequence coverage
ControlEvent(...)	0%	1	1	0	100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/WebInterface/Interface.cs

	#	Line		Line coverage
		1		using System;
		2		using System.Collections.Generic;
		3		using DCL.Helpers;
		4		using DCL.Models;
		5		using UnityEngine;
		6		using Ray = UnityEngine.Ray;
		7
		8		#if UNITY_WEBGL && !UNITY_EDITOR
		9		using System.Runtime.InteropServices;
		10		#endif
		11
		12		namespace DCL.Interface
		13		{
		14		/**
		15		* This class contains the outgoing interface of Decentraland.
		16		* You must call those functions to interact with the WebInterface.
		17		*
		18		* The messages comming from the WebInterface instead, are reported directly to
		19		* the handler GameObject by name.
		20		*/
		21		public static class WebInterface
		22		{
		23		public static bool VERBOSE = false;
		24		public static System.Action<string, string> OnMessageFromEngine;
		25
		26		[System.Serializable]
		27		private class ReportPositionPayload
		28		{
		29		/** Camera position, world space */
		30		public Vector3 position;
		31
		32		/** Camera rotation */
		33		public Quaternion rotation;
		34
		35		/** Camera height, relative to the feet of the avatar or ground */
		36		public float playerHeight;
		37
		38		public Vector3 mousePosition;
		39
		40		public string id;
		41		}
		42
		43		[System.Serializable]
		44		public abstract class ControlEvent
		45		{
		46		public string eventType;
		47		}
		48
		49		public abstract class ControlEvent<T> : ControlEvent
		50		{
		51		public T payload;
		52
	690	53		protected ControlEvent(string eventType, T payload)
		54		{
	690	55		this.eventType = eventType;
	690	56		this.payload = payload;
	690	57		}
		58		}
		59
		60		[System.Serializable]
		61		public class StartStatefulMode : ControlEvent<StartStatefulMode.Payload>
		62		{
		63		[System.Serializable]
		64		public class Payload
		65		{
		66		public string sceneId;
		67		}
		68
		69		public StartStatefulMode(string sceneId) : base("StartStatefulMode", new Payload() { sceneId = sceneId }) {
		70		}
		71
		72		[System.Serializable]
		73		public class StopStatefulMode : ControlEvent<StopStatefulMode.Payload>
		74		{
		75		[System.Serializable]
		76		public class Payload
		77		{
		78		public string sceneId;
		79		}
		80
		81		public StopStatefulMode(string sceneId) : base("StopStatefulMode", new Payload() { sceneId = sceneId }) { }
		82		}
		83
		84		[System.Serializable]
		85		public class SceneReady : ControlEvent<SceneReady.Payload>
		86		{
		87		[System.Serializable]
		88		public class Payload
		89		{
		90		public string sceneId;
		91		}
		92
		93		public SceneReady(string sceneId) : base("SceneReady", new Payload() { sceneId = sceneId }) { }
		94		}
		95
		96		[System.Serializable]
		97		public class ActivateRenderingACK : ControlEvent<object>
		98		{
		99		public ActivateRenderingACK() : base("ActivateRenderingACK", null) { }
		100		}
		101
		102		[System.Serializable]
		103		public class DeactivateRenderingACK : ControlEvent<object>
		104		{
		105		public DeactivateRenderingACK() : base("DeactivateRenderingACK", null) { }
		106		}
		107
		108		[System.Serializable]
		109		public class SceneEvent<T>
		110		{
		111		public string sceneId;
		112		public string eventType;
		113		public T payload;
		114		}
		115
		116		[System.Serializable]
		117		public class AllScenesEvent<T>
		118		{
		119		public string eventType;
		120		public T payload;
		121		}
		122
		123		[System.Serializable]
		124		public class UUIDEvent<TPayload>
		125		where TPayload : class, new()
		126		{
		127		public string uuid;
		128		public TPayload payload = new TPayload();
		129		}
		130
		131		public enum ACTION_BUTTON
		132		{
		133		POINTER,
		134		PRIMARY,
		135		SECONDARY,
		136		ANY
		137		}
		138
		139		[System.Serializable]
		140		public class OnClickEvent : UUIDEvent<OnClickEventPayload> { };
		141
		142		[System.Serializable]
		143		public class CameraModePayload
		144		{
		145		public CameraMode.ModeId cameraMode;
		146		};
		147
		148		[System.Serializable]
		149		public class IdleStateChangedPayload
		150		{
		151		public bool isIdle;
		152		};
		153
		154		[System.Serializable]
		155		public class OnPointerDownEvent : UUIDEvent<OnPointerEventPayload> { };
		156
		157		[System.Serializable]
		158		public class OnGlobalPointerEvent
		159		{
		160		public OnGlobalPointerEventPayload payload = new OnGlobalPointerEventPayload();
		161		};
		162
		163		[System.Serializable]
		164		public class OnPointerUpEvent : UUIDEvent<OnPointerEventPayload> { };
		165
		166		[System.Serializable]
		167		private class OnTextSubmitEvent : UUIDEvent<OnTextSubmitEventPayload> { };
		168
		169		[System.Serializable]
		170		private class OnTextInputChangeEvent : UUIDEvent<OnTextInputChangeEventPayload> { };
		171
		172		[System.Serializable]
		173		private class OnScrollChangeEvent : UUIDEvent<OnScrollChangeEventPayload> { };
		174
		175		[System.Serializable]
		176		private class OnFocusEvent : UUIDEvent<EmptyPayload> { };
		177
		178		[System.Serializable]
		179		private class OnBlurEvent : UUIDEvent<EmptyPayload> { };
		180
		181		[System.Serializable]
		182		public class OnEnterEvent : UUIDEvent<OnEnterEventPayload> { };
		183
		184		[System.Serializable]
		185		public class OnClickEventPayload
		186		{
		187		public ACTION_BUTTON buttonId = ACTION_BUTTON.POINTER;
		188		}
		189
		190		[System.Serializable]
		191		public class SendChatMessageEvent
		192		{
		193		public ChatMessage message;
		194		}
		195
		196		[System.Serializable]
		197		public class RemoveEntityComponentsPayLoad
		198		{
		199		public string entityId;
		200		public string componentId;
		201		};
		202
		203		[System.Serializable]
		204		public class StoreSceneStateEvent
		205		{
		206		public string type = "StoreSceneState";
		207		public string payload = "";
		208		};
		209
		210		[System.Serializable]
		211		public class OnPointerEventPayload
		212		{
		213		[System.Serializable]
		214		public class Hit
		215		{
		216		public Vector3 origin;
		217		public float length;
		218		public Vector3 hitPoint;
		219		public Vector3 normal;
		220		public Vector3 worldNormal;
		221		public string meshName;
		222		public string entityId;
		223		}
		224
		225		public ACTION_BUTTON buttonId;
		226		public Vector3 origin;
		227		public Vector3 direction;
		228		public Hit hit;
		229		}
		230
		231		[System.Serializable]
		232		public class OnGlobalPointerEventPayload : OnPointerEventPayload
		233		{
		234		public enum InputEventType
		235		{
		236		DOWN,
		237		UP
		238		}
		239
		240		public InputEventType type;
		241		}
		242
		243		[System.Serializable]
		244		public class OnTextSubmitEventPayload
		245		{
		246		public string id;
		247		public string text;
		248		}
		249
		250		[System.Serializable]
		251		public class OnTextInputChangeEventPayload
		252		{
		253		public string value;
		254		}
		255
		256		[System.Serializable]
		257		public class OnScrollChangeEventPayload
		258		{
		259		public Vector2 value;
		260		public int pointerId;
		261		}
		262
		263		[System.Serializable]
		264		public class EmptyPayload { }
		265
		266		[System.Serializable]
		267		public class MetricsModel
		268		{
		269		public int meshes;
		270		public int bodies;
		271		public int materials;
		272		public int textures;
		273		public int triangles;
		274		public int entities;
		275
		276		public static MetricsModel operator + (MetricsModel lhs, MetricsModel rhs)
		277		{
		278		return new MetricsModel()
		279		{
		280		meshes = lhs.meshes + rhs.meshes,
		281		bodies = lhs.bodies + rhs.bodies,
		282		materials = lhs.materials + rhs.materials,
		283		textures = lhs.textures + rhs.textures,
		284		triangles = lhs.triangles + rhs.triangles,
		285		entities = lhs.entities + rhs.entities
		286		};
		287		}
		288		}
		289
		290		[System.Serializable]
		291		private class OnMetricsUpdate
		292		{
		293		public MetricsModel given = new MetricsModel();
		294		public MetricsModel limit = new MetricsModel();
		295		}
		296
		297		[System.Serializable]
		298		public class OnEnterEventPayload { }
		299
		300		[System.Serializable]
		301		public class TransformPayload
		302		{
		303		public Vector3 position = Vector3.zero;
		304		public Quaternion rotation = Quaternion.identity;
		305		public Vector3 scale = Vector3.one;
		306		}
		307
		308		public class OnSendScreenshot
		309		{
		310		public string id;
		311		public string encodedTexture;
		312		};
		313
		314		[System.Serializable]
		315		public class GotoEvent
		316		{
		317		public int x;
		318		public int y;
		319		};
		320
		321		[System.Serializable]
		322		public class BaseResolution
		323		{
		324		public int baseResolution;
		325		};
		326
		327		//-----------------------------------------------------
		328		// Raycast
		329		[System.Serializable]
		330		public class RayInfo
		331		{
		332		public Vector3 origin;
		333		public Vector3 direction;
		334		public float distance;
		335		}
		336
		337		[System.Serializable]
		338		public class RaycastHitInfo
		339		{
		340		public bool didHit;
		341		public RayInfo ray;
		342
		343		public Vector3 hitPoint;
		344		public Vector3 hitNormal;
		345		}
		346
		347		[System.Serializable]
		348		public class HitEntityInfo
		349		{
		350		public string entityId;
		351		public string meshName;
		352		}
		353
		354		[System.Serializable]
		355		public class RaycastHitEntity : RaycastHitInfo
		356		{
		357		public HitEntityInfo entity;
		358		}
		359
		360		[System.Serializable]
		361		public class RaycastHitEntities : RaycastHitInfo
		362		{
		363		public RaycastHitEntity[] entities;
		364		}
		365
		366		[System.Serializable]
		367		public class RaycastResponse<T> where T : RaycastHitInfo
		368		{
		369		public string queryId;
		370		public string queryType;
		371		public T payload;
		372		}
		373
		374		// Note (Zak): We need to explicitly define this classes for the JsonUtility to
		375		// be able to serialize them
		376		[System.Serializable]
		377		public class RaycastHitFirstResponse : RaycastResponse<RaycastHitEntity> { }
		378
		379		[System.Serializable]
		380		public class RaycastHitAllResponse : RaycastResponse<RaycastHitEntities> { }
		381
		382		[System.Serializable]
		383		public class SendExpressionPayload
		384		{
		385		public string id;
		386		public long timestamp;
		387		}
		388
		389		[System.Serializable]
		390		public class UserAcceptedCollectiblesPayload
		391		{
		392		public string id;
		393		}
		394
		395		[System.Serializable]
		396		public class SendBlockPlayerPayload
		397		{
		398		public string userId;
		399		}
		400
		401		[System.Serializable]
		402		public class SendUnblockPlayerPayload
		403		{
		404		public string userId;
		405		}
		406
		407		[System.Serializable]
		408		public class TutorialStepPayload
		409		{
		410		public int tutorialStep;
		411		}
		412
		413		[System.Serializable]
		414		public class PerformanceReportPayload
		415		{
		416		public string samples;
		417		public bool fpsIsCapped;
		418		public int hiccupsInThousandFrames;
		419		public float hiccupsTime;
		420		public float totalTime;
		421		}
		422
		423		[System.Serializable]
		424		public class SystemInfoReportPayload
		425		{
		426		public string graphicsDeviceName = SystemInfo.graphicsDeviceName;
		427		public string graphicsDeviceVersion = SystemInfo.graphicsDeviceVersion;
		428		public int graphicsMemorySize = SystemInfo.graphicsMemorySize;
		429		public string processorType = SystemInfo.processorType;
		430		public int processorCount = SystemInfo.processorCount;
		431		public int systemMemorySize = SystemInfo.systemMemorySize;
		432		}
		433
		434		[System.Serializable]
		435		public class GenericAnalyticPayload
		436		{
		437		public string eventName;
		438		public Dictionary<object, object> data;
		439		}
		440
		441		[System.Serializable]
		442		public class PerformanceHiccupPayload
		443		{
		444		public int hiccupsInThousandFrames;
		445		public float hiccupsTime;
		446		public float totalTime;
		447		}
		448
		449		[System.Serializable]
		450		public class TermsOfServiceResponsePayload
		451		{
		452		public string sceneId;
		453		public bool dontShowAgain;
		454		public bool accepted;
		455		}
		456
		457		[System.Serializable]
		458		public class OpenURLPayload
		459		{
		460		public string url;
		461		}
		462
		463		[System.Serializable]
		464		public class GIFSetupPayload
		465		{
		466		public string imageSource;
		467		public string id;
		468		public bool isWebGL1;
		469		}
		470
		471		[System.Serializable]
		472		public class RequestScenesInfoAroundParcelPayload
		473		{
		474		public Vector2 parcel;
		475		public int scenesAround;
		476		}
		477
		478		[System.Serializable]
		479		public class AudioStreamingPayload
		480		{
		481		public string url;
		482		public bool play;
		483		public float volume;
		484		}
		485
		486		[System.Serializable]
		487		public class SetScenesLoadRadiusPayload
		488		{
		489		public float newRadius;
		490		}
		491
		492		[System.Serializable]
		493		public class SetVoiceChatRecordingPayload
		494		{
		495		public bool recording;
		496		}
		497
		498		[System.Serializable]
		499		public class ApplySettingsPayload
		500		{
		501		public float voiceChatVolume;
		502		public int voiceChatAllowCategory;
		503		}
		504
		505		[System.Serializable]
		506		public class JumpInPayload
		507		{
		508		public FriendsController.UserStatus.Realm realm = new FriendsController.UserStatus.Realm();
		509		public Vector2 gridPosition;
		510		}
		511
		512		[System.Serializable]
		513		public class LoadingFeedbackMessage
		514		{
		515		public string message;
		516		public int loadPercentage;
		517		}
		518
		519		[System.Serializable]
		520		public class AnalyticsPayload
		521		{
		522		[System.Serializable]
		523		public class Property
		524		{
		525		public string key;
		526		public string value;
		527
		528		public Property(string key, string value)
		529		{
		530		this.key = key;
		531		this.value = value;
		532		}
		533		}
		534
		535		public string name;
		536		public Property[] properties;
		537		}
		538
		539		[System.Serializable]
		540		public class DelightedSurveyEnabledPayload
		541		{
		542		public bool enabled;
		543		}
		544
		545		[System.Serializable]
		546		public class ExternalActionSceneEventPayload
		547		{
		548		public string type;
		549		public string payload;
		550		}
		551
		552		[System.Serializable]
		553		public class MuteUserPayload
		554		{
		555		public string[] usersId;
		556		public bool mute;
		557		}
		558
		559		[System.Serializable]
		560		public class CloseUserAvatarPayload
		561		{
		562		public bool isSignUpFlow;
		563		}
		564
		565		[System.Serializable]
		566		public class StringPayload
		567		{
		568		public string value;
		569		}
		570
		571		[System.Serializable]
		572		public class KillPortableExperiencePayload
		573		{
		574		public string portableExperienceId;
		575		}
		576
		577		[System.Serializable]
		578		public class WearablesRequestFiltersPayload
		579		{
		580		public string ownedByUser;
		581		public string[] wearableIds;
		582		public string[] collectionIds;
		583		}
		584
		585		[System.Serializable]
		586		public class RequestWearablesPayload
		587		{
		588		public WearablesRequestFiltersPayload filters;
		589		public string context;
		590		}
		591
		592		[System.Serializable]
		593		public class SearchENSOwnerPayload
		594		{
		595		public string name;
		596		public int maxResults;
		597		}
		598
		599		[System.Serializable]
		600		public class UnpublishScenePayload
		601		{
		602		public string coordinates;
		603		}
		604
		605		#if UNITY_WEBGL && !UNITY_EDITOR
		606		/**
		607		* This method is called after the first render. It marks the loading of the
		608		* rest of the JS client.
		609		*/
		610		[DllImport("__Internal")] public static extern void StartDecentraland();
		611		[DllImport("__Internal")] public static extern void MessageFromEngine(string type, string message);
		612		[DllImport("__Internal")] public static extern string GetGraphicCard();
		613		#else
		614		private static bool hasQueuedMessages = false;
		615		private static List<(string, string)> queuedMessages = new List<(string, string)>();
		616		public static void StartDecentraland() {}
		617		public static void MessageFromEngine(string type, string message)
		618		{
		619		if (OnMessageFromEngine != null)
		620		{
		621		if (hasQueuedMessages)
		622		{
		623		ProcessQueuedMessages();
		624		}
		625		OnMessageFromEngine.Invoke(type, message);
		626		if (VERBOSE)
		627		{
		628		Debug.Log("MessageFromEngine called with: " + type + ", " + message);
		629		}
		630		}
		631		else
		632		{
		633		lock (queuedMessages)
		634		{
		635		queuedMessages.Add((type, message));
		636		}
		637		hasQueuedMessages = true;
		638		}
		639		}
		640
		641		private static void ProcessQueuedMessages()
		642		{
		643		hasQueuedMessages = false;
		644		lock (queuedMessages)
		645		{
		646		foreach((string type, string payload) in queuedMessages)
		647		{
		648		MessageFromEngine(type, payload);
		649		}
		650		queuedMessages.Clear();
		651		}
		652		}
		653
		654		public static string GetGraphicCard() => "In Editor Graphic Card";
		655		#endif
		656
		657		public static void SendMessage(string type)
		658		{
		659		// sending an empty JSON object to be compatible with other messages
		660		MessageFromEngine(type, "{}");
		661		}
		662
		663		public static void SendMessage<T>(string type, T message)
		664		{
		665		string messageJson = JsonUtility.ToJson(message);
		666
		667		if (VERBOSE)
		668		{
		669		Debug.Log($"Sending message: " + messageJson);
		670		}
		671
		672		MessageFromEngine(type, messageJson);
		673		}
		674
		675		private static ReportPositionPayload positionPayload = new ReportPositionPayload();
		676		private static CameraModePayload cameraModePayload = new CameraModePayload();
		677		private static IdleStateChangedPayload idleStateChangedPayload = new IdleStateChangedPayload();
		678		private static OnMetricsUpdate onMetricsUpdate = new OnMetricsUpdate();
		679		private static OnClickEvent onClickEvent = new OnClickEvent();
		680		private static OnPointerDownEvent onPointerDownEvent = new OnPointerDownEvent();
		681		private static OnPointerUpEvent onPointerUpEvent = new OnPointerUpEvent();
		682		private static OnTextSubmitEvent onTextSubmitEvent = new OnTextSubmitEvent();
		683		private static OnTextInputChangeEvent onTextInputChangeEvent = new OnTextInputChangeEvent();
		684		private static OnScrollChangeEvent onScrollChangeEvent = new OnScrollChangeEvent();
		685		private static OnFocusEvent onFocusEvent = new OnFocusEvent();
		686		private static OnBlurEvent onBlurEvent = new OnBlurEvent();
		687		private static OnEnterEvent onEnterEvent = new OnEnterEvent();
		688		private static OnSendScreenshot onSendScreenshot = new OnSendScreenshot();
		689		private static OnPointerEventPayload onPointerEventPayload = new OnPointerEventPayload();
		690		private static OnGlobalPointerEventPayload onGlobalPointerEventPayload = new OnGlobalPointerEventPayload();
		691		private static OnGlobalPointerEvent onGlobalPointerEvent = new OnGlobalPointerEvent();
		692		private static AudioStreamingPayload onAudioStreamingEvent = new AudioStreamingPayload();
		693		private static SetVoiceChatRecordingPayload setVoiceChatRecordingPayload = new SetVoiceChatRecordingPayload();
		694		private static SetScenesLoadRadiusPayload setScenesLoadRadiusPayload = new SetScenesLoadRadiusPayload();
		695		private static ApplySettingsPayload applySettingsPayload = new ApplySettingsPayload();
		696		private static GIFSetupPayload gifSetupPayload = new GIFSetupPayload();
		697		private static JumpInPayload jumpInPayload = new JumpInPayload();
		698		private static GotoEvent gotoEvent = new GotoEvent();
		699		private static SendChatMessageEvent sendChatMessageEvent = new SendChatMessageEvent();
		700		private static BaseResolution baseResEvent = new BaseResolution();
		701		private static AnalyticsPayload analyticsEvent = new AnalyticsPayload();
		702		private static DelightedSurveyEnabledPayload delightedSurveyEnabled = new DelightedSurveyEnabledPayload();
		703		private static ExternalActionSceneEventPayload sceneExternalActionEvent = new ExternalActionSceneEventPayload();
		704		private static MuteUserPayload muteUserEvent = new MuteUserPayload();
		705		private static StoreSceneStateEvent storeSceneState = new StoreSceneStateEvent();
		706		private static CloseUserAvatarPayload closeUserAvatarPayload = new CloseUserAvatarPayload();
		707		private static StringPayload stringPayload = new StringPayload();
		708		private static KillPortableExperiencePayload killPortableExperiencePayload = new KillPortableExperiencePayload()
		709		private static RequestWearablesPayload requestWearablesPayload = new RequestWearablesPayload();
		710		private static SearchENSOwnerPayload searchEnsOwnerPayload = new SearchENSOwnerPayload();
		711
		712		public static void SendSceneEvent<T>(string sceneId, string eventType, T payload)
		713		{
		714		SceneEvent<T> sceneEvent = new SceneEvent<T>();
		715		sceneEvent.sceneId = sceneId;
		716		sceneEvent.eventType = eventType;
		717		sceneEvent.payload = payload;
		718
		719		SendMessage("SceneEvent", sceneEvent);
		720		}
		721
		722		private static void SendAllScenesEvent<T>(string eventType, T payload)
		723		{
		724		AllScenesEvent<T> allScenesEvent = new AllScenesEvent<T>();
		725		allScenesEvent.eventType = eventType;
		726		allScenesEvent.payload = payload;
		727
		728		SendMessage("AllScenesEvent", allScenesEvent);
		729		}
		730
		731		public static void ReportPosition(Vector3 position, Quaternion rotation, float playerHeight)
		732		{
		733		positionPayload.position = position;
		734		positionPayload.rotation = rotation;
		735		positionPayload.playerHeight = playerHeight;
		736
		737		SendMessage("ReportPosition", positionPayload);
		738		}
		739
		740		public static void ReportCameraChanged(CameraMode.ModeId cameraMode)
		741		{
		742		cameraModePayload.cameraMode = cameraMode;
		743		SendAllScenesEvent("cameraModeChanged", cameraModePayload);
		744		}
		745
		746		public static void ReportIdleStateChanged(bool isIdle)
		747		{
		748		idleStateChangedPayload.isIdle = isIdle;
		749		SendAllScenesEvent("idleStateChanged", idleStateChangedPayload);
		750		}
		751
		752		public static void ReportControlEvent<T>(T controlEvent) where T : ControlEvent { SendMessage("ControlEvent", co
		753
		754		public static void BuilderInWorldMessage(string type, string message) { MessageFromEngine(type, message); }
		755
		756		public static void ReportOnClickEvent(string sceneId, string uuid)
		757		{
		758		if (string.IsNullOrEmpty(uuid))
		759		{
		760		return;
		761		}
		762
		763		onClickEvent.uuid = uuid;
		764
		765		SendSceneEvent(sceneId, "uuidEvent", onClickEvent);
		766		}
		767
		768		private static void ReportRaycastResult<T, P>(string sceneId, string queryId, string queryType, P payload) where
		769		{
		770		T response = new T();
		771		response.queryId = queryId;
		772		response.queryType = queryType;
		773		response.payload = payload;
		774
		775		SendSceneEvent<T>(sceneId, "raycastResponse", response);
		776		}
		777
		778		public static void ReportRaycastHitFirstResult(string sceneId, string queryId, RaycastType raycastType, RaycastH
		779
		780		public static void ReportRaycastHitAllResult(string sceneId, string queryId, RaycastType raycastType, RaycastHit
		781
		782		private static OnPointerEventPayload.Hit CreateHitObject(string entityId, string meshName, Vector3 point, Vector
		783		{
		784		OnPointerEventPayload.Hit hit = new OnPointerEventPayload.Hit();
		785
		786		hit.hitPoint = point;
		787		hit.length = distance;
		788		hit.normal = normal;
		789		hit.worldNormal = normal;
		790		hit.meshName = meshName;
		791		hit.entityId = entityId;
		792
		793		return hit;
		794		}
		795
		796		private static void SetPointerEventPayload(OnPointerEventPayload pointerEventPayload, ACTION_BUTTON buttonId, st
		797		{
		798		pointerEventPayload.origin = ray.origin;
		799		pointerEventPayload.direction = ray.direction;
		800		pointerEventPayload.buttonId = buttonId;
		801
		802		if (isHitInfoValid)
		803		pointerEventPayload.hit = CreateHitObject(entityId, meshName, point, normal, distance);
		804		else
		805		pointerEventPayload.hit = null;
		806		}
		807
		808		public static void ReportGlobalPointerDownEvent(ACTION_BUTTON buttonId, Ray ray, Vector3 point, Vector3 normal,
		809		{
		810		SetPointerEventPayload((OnPointerEventPayload) onGlobalPointerEventPayload, buttonId, entityId, meshName, ra
		811		onGlobalPointerEventPayload.type = OnGlobalPointerEventPayload.InputEventType.DOWN;
		812
		813		onGlobalPointerEvent.payload = onGlobalPointerEventPayload;
		814
		815		SendSceneEvent(sceneId, "pointerEvent", onGlobalPointerEvent);
		816		}
		817
		818		public static void ReportGlobalPointerUpEvent(ACTION_BUTTON buttonId, Ray ray, Vector3 point, Vector3 normal, fl
		819		{
		820		SetPointerEventPayload((OnPointerEventPayload) onGlobalPointerEventPayload, buttonId, entityId, meshName, ra
		821		onGlobalPointerEventPayload.type = OnGlobalPointerEventPayload.InputEventType.UP;
		822
		823		onGlobalPointerEvent.payload = onGlobalPointerEventPayload;
		824
		825		SendSceneEvent(sceneId, "pointerEvent", onGlobalPointerEvent);
		826		}
		827
		828		public static void ReportOnPointerDownEvent(ACTION_BUTTON buttonId, string sceneId, string uuid, string entityId
		829		{
		830		if (string.IsNullOrEmpty(uuid))
		831		{
		832		return;
		833		}
		834
		835		onPointerDownEvent.uuid = uuid;
		836		SetPointerEventPayload(onPointerEventPayload, buttonId, entityId, meshName, ray, point, normal, distance, is
		837		onPointerDownEvent.payload = onPointerEventPayload;
		838
		839		SendSceneEvent(sceneId, "uuidEvent", onPointerDownEvent);
		840		}
		841
		842		public static void ReportOnPointerUpEvent(ACTION_BUTTON buttonId, string sceneId, string uuid, string entityId,
		843		{
		844		if (string.IsNullOrEmpty(uuid))
		845		{
		846		return;
		847		}
		848
		849		onPointerUpEvent.uuid = uuid;
		850		SetPointerEventPayload(onPointerEventPayload, buttonId, entityId, meshName, ray, point, normal, distance, is
		851		onPointerUpEvent.payload = onPointerEventPayload;
		852
		853		SendSceneEvent(sceneId, "uuidEvent", onPointerUpEvent);
		854		}
		855
		856		public static void ReportOnTextSubmitEvent(string sceneId, string uuid, string text)
		857		{
		858		if (string.IsNullOrEmpty(uuid))
		859		{
		860		return;
		861		}
		862
		863		onTextSubmitEvent.uuid = uuid;
		864		onTextSubmitEvent.payload.text = text;
		865
		866		SendSceneEvent(sceneId, "uuidEvent", onTextSubmitEvent);
		867		}
		868
		869		public static void ReportOnTextInputChangedEvent(string sceneId, string uuid, string text)
		870		{
		871		if (string.IsNullOrEmpty(uuid))
		872		{
		873		return;
		874		}
		875
		876		onTextInputChangeEvent.uuid = uuid;
		877		onTextInputChangeEvent.payload.value = text;
		878
		879		SendSceneEvent(sceneId, "uuidEvent", onTextInputChangeEvent);
		880		}
		881
		882		public static void ReportOnFocusEvent(string sceneId, string uuid)
		883		{
		884		if (string.IsNullOrEmpty(uuid))
		885		{
		886		return;
		887		}
		888
		889		onFocusEvent.uuid = uuid;
		890		SendSceneEvent(sceneId, "uuidEvent", onFocusEvent);
		891		}
		892
		893		public static void ReportOnBlurEvent(string sceneId, string uuid)
		894		{
		895		if (string.IsNullOrEmpty(uuid))
		896		{
		897		return;
		898		}
		899
		900		onBlurEvent.uuid = uuid;
		901		SendSceneEvent(sceneId, "uuidEvent", onBlurEvent);
		902		}
		903
		904		public static void ReportOnScrollChange(string sceneId, string uuid, Vector2 value, int pointerId)
		905		{
		906		if (string.IsNullOrEmpty(uuid))
		907		{
		908		return;
		909		}
		910
		911		onScrollChangeEvent.uuid = uuid;
		912		onScrollChangeEvent.payload.value = value;
		913		onScrollChangeEvent.payload.pointerId = pointerId;
		914
		915		SendSceneEvent(sceneId, "uuidEvent", onScrollChangeEvent);
		916		}
		917
		918		public static void ReportEvent<T>(string sceneId, T @event) { SendSceneEvent(sceneId, "uuidEvent", @event); }
		919
		920		public static void ReportOnMetricsUpdate(string sceneId, MetricsModel current,
		921		MetricsModel limit)
		922		{
		923		onMetricsUpdate.given = current;
		924		onMetricsUpdate.limit = limit;
		925
		926		SendSceneEvent(sceneId, "metricsUpdate", onMetricsUpdate);
		927		}
		928
		929		public static void ReportOnEnterEvent(string sceneId, string uuid)
		930		{
		931		if (string.IsNullOrEmpty(uuid))
		932		return;
		933
		934		onEnterEvent.uuid = uuid;
		935
		936		SendSceneEvent(sceneId, "uuidEvent", onEnterEvent);
		937		}
		938
		939		public static void LogOut() { SendMessage("LogOut"); }
		940
		941		public static void RedirectToSignUp() { SendMessage("RedirectToSignUp"); }
		942
		943		public static void PreloadFinished(string sceneId) { SendMessage("PreloadFinished", sceneId); }
		944
		945		public static void ReportMousePosition(Vector3 mousePosition, string id)
		946		{
		947		positionPayload.mousePosition = mousePosition;
		948		positionPayload.id = id;
		949		SendMessage("ReportMousePosition", positionPayload);
		950		}
		951
		952		public static void SendScreenshot(string encodedTexture, string id)
		953		{
		954		onSendScreenshot.encodedTexture = encodedTexture;
		955		onSendScreenshot.id = id;
		956		SendMessage("SendScreenshot", onSendScreenshot);
		957		}
		958
		959		public static void SetDelightedSurveyEnabled(bool enabled)
		960		{
		961		delightedSurveyEnabled.enabled = enabled;
		962		SendMessage("SetDelightedSurveyEnabled", delightedSurveyEnabled);
		963		}
		964
		965		public static void SetScenesLoadRadius(float newRadius)
		966		{
		967		setScenesLoadRadiusPayload.newRadius = newRadius;
		968		SendMessage("SetScenesLoadRadius", setScenesLoadRadiusPayload);
		969		}
		970
		971		[System.Serializable]
		972		public class SaveAvatarPayload
		973		{
		974		public string face;
		975		public string face128;
		976		public string face256;
		977		public string body;
		978		public bool isSignUpFlow;
		979		public AvatarModel avatar;
		980		}
		981
		982		public static class RendererAuthenticationType
		983		{
		984		public static string Guest => "guest";
		985		public static string WalletConnect => "wallet_connect";
		986		}
		987
		988		[System.Serializable]
		989		public class SendAuthenticationPayload
		990		{
		991		public string rendererAuthenticationType;
		992		}
		993
		994		[System.Serializable]
		995		public class SendPassportPayload
		996		{
		997		public string name;
		998		public string email;
		999		}
		1000
		1001		[System.Serializable]
		1002		public class SendSaveUserUnverifiedNamePayload
		1003		{
		1004		public string newUnverifiedName;
		1005		}
		1006
		1007		public static void RequestOwnProfileUpdate() { SendMessage("RequestOwnProfileUpdate"); }
		1008
		1009		public static void SendSaveAvatar(AvatarModel avatar, Texture2D faceSnapshot, Texture2D face128Snapshot, Texture
		1010		{
		1011		var payload = new SaveAvatarPayload()
		1012		{
		1013		avatar = avatar,
		1014		face = System.Convert.ToBase64String(faceSnapshot.EncodeToPNG()),
		1015		face128 = System.Convert.ToBase64String(face128Snapshot.EncodeToPNG()),
		1016		face256 = System.Convert.ToBase64String(face256Snapshot.EncodeToPNG()),
		1017		body = System.Convert.ToBase64String(bodySnapshot.EncodeToPNG()),
		1018		isSignUpFlow = isSignUpFlow
		1019		};
		1020		SendMessage("SaveUserAvatar", payload);
		1021		}
		1022
		1023		public static void SendAuthentication(string rendererAuthenticationType) { SendMessage("SendAuthentication", new
		1024
		1025		public static void SendPassport(string name, string email) { SendMessage("SendPassport", new SendPassportPayload
		1026
		1027		public static void SendSaveUserUnverifiedName(string newName)
		1028		{
		1029		var payload = new SendSaveUserUnverifiedNamePayload()
		1030		{
		1031		newUnverifiedName = newName
		1032		};
		1033
		1034		SendMessage("SaveUserUnverifiedName", payload);
		1035		}
		1036
		1037		public static void SendUserAcceptedCollectibles(string airdropId) { SendMessage("UserAcceptedCollectibles", new
		1038
		1039		public static void SaveUserTutorialStep(int newTutorialStep) { SendMessage("SaveUserTutorialStep", new TutorialS
		1040
		1041		public static void SendPerformanceReport(string encodedFrameTimesInMS, bool usingFPSCap, int hiccupsInThousandFr
		1042		{
		1043		SendMessage("PerformanceReport", new PerformanceReportPayload()
		1044		{
		1045		samples = encodedFrameTimesInMS,
		1046		fpsIsCapped = usingFPSCap,
		1047		hiccupsInThousandFrames = hiccupsInThousandFrames,
		1048		hiccupsTime = hiccupsTime,
		1049		totalTime = totalTime
		1050		});
		1051		}
		1052
		1053		public static void SendSystemInfoReport()
		1054		{
		1055		SendMessage("SystemInfoReport", new SystemInfoReportPayload());
		1056		}
		1057
		1058		public static void SendTermsOfServiceResponse(string sceneId, bool accepted, bool dontShowAgain)
		1059		{
		1060		var payload = new TermsOfServiceResponsePayload()
		1061		{
		1062		sceneId = sceneId,
		1063		accepted = accepted,
		1064		dontShowAgain = dontShowAgain
		1065		};
		1066		SendMessage("TermsOfServiceResponse", payload);
		1067		}
		1068
		1069		public static void SendExpression(string expressionID, long timestamp)
		1070		{
		1071		SendMessage("TriggerExpression", new SendExpressionPayload()
		1072		{
		1073		id = expressionID,
		1074		timestamp = timestamp
		1075		});
		1076		}
		1077
		1078		public static void ReportMotdClicked() { SendMessage("MotdConfirmClicked"); }
		1079
		1080		public static void OpenURL(string url) { SendMessage("OpenWebURL", new OpenURLPayload { url = url }); }
		1081
		1082		public static void SendReportScene(string sceneID) { SendMessage("ReportScene", sceneID); }
		1083
		1084		public static void SendReportPlayer(string playerName) { SendMessage("ReportPlayer", playerName); }
		1085
		1086		public static void SendBlockPlayer(string userId)
		1087		{
		1088		SendMessage("BlockPlayer", new SendBlockPlayerPayload()
		1089		{
		1090		userId = userId
		1091		});
		1092		}
		1093
		1094		public static void SendUnblockPlayer(string userId)
		1095		{
		1096		SendMessage("UnblockPlayer", new SendUnblockPlayerPayload()
		1097		{
		1098		userId = userId
		1099		});
		1100		}
		1101
		1102		public static void RequestScenesInfoAroundParcel(Vector2 parcel, int maxScenesArea)
		1103		{
		1104		SendMessage("RequestScenesInfoInArea", new RequestScenesInfoAroundParcelPayload()
		1105		{
		1106		parcel = parcel,
		1107		scenesAround = maxScenesArea
		1108		});
		1109		}
		1110
		1111		public static void SendAudioStreamEvent(string url, bool play, float volume)
		1112		{
		1113		onAudioStreamingEvent.url = url;
		1114		onAudioStreamingEvent.play = play;
		1115		onAudioStreamingEvent.volume = volume;
		1116		SendMessage("SetAudioStream", onAudioStreamingEvent);
		1117		}
		1118
		1119		public static void SendSetVoiceChatRecording(bool recording)
		1120		{
		1121		setVoiceChatRecordingPayload.recording = recording;
		1122		SendMessage("SetVoiceChatRecording", setVoiceChatRecordingPayload);
		1123		}
		1124
		1125		public static void ToggleVoiceChatRecording() { SendMessage("ToggleVoiceChatRecording"); }
		1126
		1127		public static void ApplySettings(float voiceChatVolume, int voiceChatAllowCategory)
		1128		{
		1129		applySettingsPayload.voiceChatVolume = voiceChatVolume;
		1130		applySettingsPayload.voiceChatAllowCategory = voiceChatAllowCategory;
		1131		SendMessage("ApplySettings", applySettingsPayload);
		1132		}
		1133
		1134		public static void RequestGIFProcessor(string gifURL, string gifId, bool isWebGL1)
		1135		{
		1136		gifSetupPayload.imageSource = gifURL;
		1137		gifSetupPayload.id = gifId;
		1138		gifSetupPayload.isWebGL1 = isWebGL1;
		1139
		1140		SendMessage("RequestGIFProcessor", gifSetupPayload);
		1141		}
		1142
		1143		public static void DeleteGIF(string id)
		1144		{
		1145		stringPayload.value = id;
		1146		SendMessage("DeleteGIF", stringPayload);
		1147		}
		1148
		1149		public static void GoTo(int x, int y)
		1150		{
		1151		gotoEvent.x = x;
		1152		gotoEvent.y = y;
		1153		SendMessage("GoTo", gotoEvent);
		1154		}
		1155
		1156		public static void GoToCrowd() { SendMessage("GoToCrowd"); }
		1157
		1158		public static void GoToMagic() { SendMessage("GoToMagic"); }
		1159
		1160		public static void JumpIn(int x, int y, string serverName, string layerName)
		1161		{
		1162		jumpInPayload.realm.serverName = serverName;
		1163		jumpInPayload.realm.layer = layerName;
		1164
		1165		jumpInPayload.gridPosition.x = x;
		1166		jumpInPayload.gridPosition.y = y;
		1167
		1168		SendMessage("JumpIn", jumpInPayload);
		1169		}
		1170
		1171		public static void SendChatMessage(ChatMessage message)
		1172		{
		1173		sendChatMessageEvent.message = message;
		1174		SendMessage("SendChatMessage", sendChatMessageEvent);
		1175		}
		1176
		1177		public static void UpdateFriendshipStatus(FriendsController.FriendshipUpdateStatusMessage message) { SendMessage
		1178
		1179		public static void ScenesLoadingFeedback(LoadingFeedbackMessage message) { SendMessage("ScenesLoadingFeedback",
		1180
		1181		public static void FetchHotScenes() { SendMessage("FetchHotScenes"); }
		1182
		1183		public static void SetBaseResolution(int resolution)
		1184		{
		1185		baseResEvent.baseResolution = resolution;
		1186		SendMessage("SetBaseResolution", baseResEvent);
		1187		}
		1188
		1189		public static void ReportAnalyticsEvent(string eventName) { ReportAnalyticsEvent(eventName, null); }
		1190
		1191		public static void ReportAnalyticsEvent(string eventName, AnalyticsPayload.Property[] eventProperties)
		1192		{
		1193		analyticsEvent.name = eventName;
		1194		analyticsEvent.properties = eventProperties;
		1195		SendMessage("Track", analyticsEvent);
		1196		}
		1197
		1198		public static void FetchBalanceOfMANA() { SendMessage("FetchBalanceOfMANA"); }
		1199
		1200		public static void SendSceneExternalActionEvent(string sceneId, string type, string payload)
		1201		{
		1202		sceneExternalActionEvent.type = type;
		1203		sceneExternalActionEvent.payload = payload;
		1204		SendSceneEvent(sceneId, "externalAction", sceneExternalActionEvent);
		1205		}
		1206
		1207		public static void SetMuteUsers(string[] usersId, bool mute)
		1208		{
		1209		muteUserEvent.usersId = usersId;
		1210		muteUserEvent.mute = mute;
		1211		SendMessage("SetMuteUsers", muteUserEvent);
		1212		}
		1213
		1214		public static void SendCloseUserAvatar(bool isSignUpFlow)
		1215		{
		1216		closeUserAvatarPayload.isSignUpFlow = isSignUpFlow;
		1217		SendMessage("CloseUserAvatar", closeUserAvatarPayload);
		1218		}
		1219
		1220		public static void KillPortableExperience(string portableExperienceId)
		1221		{
		1222		killPortableExperiencePayload.portableExperienceId = portableExperienceId;
		1223		SendMessage("KillPortableExperience", killPortableExperiencePayload);
		1224		}
		1225
		1226		public static void RequestWearables(
		1227		string ownedByUser,
		1228		string[] wearableIds,
		1229		string[] collectionIds,
		1230		string context)
		1231		{
		1232		requestWearablesPayload.filters = new WearablesRequestFiltersPayload
		1233		{
		1234		ownedByUser = ownedByUser,
		1235		wearableIds = wearableIds,
		1236		collectionIds = collectionIds
		1237		};
		1238
		1239		requestWearablesPayload.context = context;
		1240
		1241		SendMessage("RequestWearables", requestWearablesPayload);
		1242		}
		1243
		1244		public static void SearchENSOwner(string name, int maxResults)
		1245		{
		1246		searchEnsOwnerPayload.name = name;
		1247		searchEnsOwnerPayload.maxResults = maxResults;
		1248
		1249		SendMessage("SearchENSOwner", searchEnsOwnerPayload);
		1250		}
		1251
		1252		public static void RequestUserProfile(string userId)
		1253		{
		1254		stringPayload.value = userId;
		1255		SendMessage("RequestUserProfile", stringPayload);
		1256		}
		1257
		1258		public static void ReportAvatarFatalError() { SendMessage("ReportAvatarFatalError"); }
		1259
		1260		public static void UnpublishScene(Vector2Int sceneCoordinates)
		1261		{
		1262		var payload = new UnpublishScenePayload() { coordinates = $"{sceneCoordinates.x},{sceneCoordinates.y}" };
		1263		SendMessage("UnpublishScene", payload);
		1264		}
		1265
		1266		public static void NotifyStatusThroughChat(string message)
		1267		{
		1268		stringPayload.value = message;
		1269		SendMessage("NotifyStatusThroughChat", stringPayload);
		1270		}
		1271		}
		1272		}