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