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