< Summary

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

Metrics

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