TRS_MML/Silly-Home
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added Unity project files

Browse Source
This commit is contained in:
Trash :3
2026-06-07 16:58:24 +01:00
parent 3cc05d260b
commit 23bbcab156
3942 changed files with 453676 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
Packages/com.vrchat.worlds/Runtime/Udon/Serialization/Formatters/DataTokenFormatter.cs Normal file
View File

@ -0,0 +1,202 @@
using VRC.SDK3.Data;
using VRC.Udon.Serialization.OdinSerializer;
[assembly: RegisterFormatter(typeof(DataTokenFormatter))]
public class DataTokenFormatter : BaseFormatter<DataToken>
{
//DataTokenFormatter allows for Udon to serialize Data containers in field initializers and embed inside Udon assembly.
//This class exists in both the SDK project and the client project. Both versions should be identical and any changes to one needs to be duplicated to the other.
private static readonly Serializer<object> _referenceReaderWriter = Serializer.Get<object>();
protected override void DeserializeImplementation(ref DataToken value, IDataReader reader)
{
reader.ReadByte(out byte _type);
TokenType Type = (TokenType)_type;
switch (Type)
{
case TokenType.Boolean:
{
reader.ReadBoolean(out bool innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.SByte:
{
reader.ReadSByte(out sbyte innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.Byte:
{
reader.ReadByte(out byte innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.Short:
{
reader.ReadInt16(out short innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.UShort:
{
reader.ReadUInt16(out ushort innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.Int:
{
reader.ReadInt32(out int innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.UInt:
{
reader.ReadUInt32(out uint innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.Long:
{
reader.ReadInt64(out long innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.ULong:
{
reader.ReadUInt64(out ulong innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.Float:
{
reader.ReadSingle(out float innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.Double:
{
reader.ReadDouble(out double innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.String:
{
reader.ReadString(out string innerValue);
value = new DataToken(innerValue);
break;
}
case TokenType.DataDictionary:
{
value = new DataToken((DataDictionary)_referenceReaderWriter.ReadValue(reader));
break;
}
case TokenType.DataList:
{
value = new DataToken((DataList)_referenceReaderWriter.ReadValue(reader));
break;
}
case TokenType.Reference:
{
value = new DataToken(_referenceReaderWriter.ReadValue(reader));
break;
}
case TokenType.Error:
{
reader.ReadByte(out byte innerValue);
value = new DataToken((DataError)innerValue);
break;
}
}
}
protected override void SerializeImplementation(ref DataToken value, IDataWriter writer)
{
writer.WriteByte("_type", (byte)value.TokenType);
switch (value.TokenType)
{
case TokenType.Boolean:
{
writer.WriteBoolean("_boolean", value.Boolean);
break;
}
case TokenType.SByte:
{
writer.WriteSByte("_sbyte", value.SByte);
break;
}
case TokenType.Byte:
{
writer.WriteByte("_byte", value.Byte);
break;
}
case TokenType.Short:
{
writer.WriteInt16("_short", value.Short);
break;
}
case TokenType.UShort:
{
writer.WriteUInt16("_ushort", value.UShort);
break;
}
case TokenType.Int:
{
writer.WriteInt32("_int", value.Int);
break;
}
case TokenType.UInt:
{
writer.WriteUInt32("_uint", value.UInt);
break;
}
case TokenType.Long:
{
writer.WriteInt64("_long", value.Long);
break;
}
case TokenType.ULong:
{
writer.WriteUInt64("_ulong", value.ULong);
break;
}
case TokenType.Float:
{
writer.WriteSingle("_float", value.Float);
break;
}
case TokenType.Double:
{
writer.WriteDouble("_double", value.Double);
break;
}
case TokenType.String:
{
writer.WriteString("_string", value.String);
break;
}
case TokenType.DataDictionary:
{
_referenceReaderWriter.WriteValue(value.DataDictionary, writer);
break;
}
case TokenType.DataList:
{
_referenceReaderWriter.WriteValue(value.DataList, writer);
break;
}
case TokenType.Reference:
{
_referenceReaderWriter.WriteValue(value.Reference, writer);
break;
}
case TokenType.Error:
{
writer.WriteByte("_error", (byte)value.Error);
break;
}
}
}
}

11
Packages/com.vrchat.worlds/Runtime/Udon/Serialization/Formatters/DataTokenFormatter.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e297f55d72e99c94abb5722781971931
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

35
Packages/com.vrchat.worlds/Runtime/Udon/Serialization/Formatters/UdonGameObjectComponentReferenceFormatter.cs Normal file
View File

@ -0,0 +1,35 @@
using System;
using VRC.Udon.Common;
using VRC.Udon.Serialization.OdinSerializer;
using VRC.Udon.Serialization.Formatters;
[assembly: RegisterFormatter(typeof(UdonGameObjectComponentReferenceFormatter))]
namespace VRC.Udon.Serialization.Formatters
{
public sealed class UdonGameObjectComponentReferenceFormatter : BaseFormatter<UdonGameObjectComponentHeapReference>
{
private static readonly Serializer<Type> _typeSerializer = Serializer.Get<Type>();
protected override UdonGameObjectComponentHeapReference GetUninitializedObject()
{
return null;
}
// ReSharper disable once RedundantAssignment
protected override void DeserializeImplementation(ref UdonGameObjectComponentHeapReference value, IDataReader reader)
{
Type type = _typeSerializer.ReadValue(reader);
value = new UdonGameObjectComponentHeapReference(type);
RegisterReferenceID(value, reader);
InvokeOnDeserializingCallbacks(ref value, reader.Context);
}
protected override void SerializeImplementation(ref UdonGameObjectComponentHeapReference value, IDataWriter writer)
{
_typeSerializer.WriteValue(value.type, writer);
}
}
}

11
Packages/com.vrchat.worlds/Runtime/Udon/Serialization/Formatters/UdonGameObjectComponentReferenceFormatter.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b1d0b8aa8084bcd44a572d524d7a31bb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

59
Packages/com.vrchat.worlds/Runtime/Udon/Serialization/Formatters/UdonProgramFormatter.cs Normal file
View File

@ -0,0 +1,59 @@
using VRC.Udon.Common;
using VRC.Udon.Common.Interfaces;
using VRC.Udon.Serialization.OdinSerializer;
using VRC.Udon.Serialization.Formatters;
[assembly: RegisterFormatter(typeof(UdonProgramFormatter))]
#if UNITY_6000_0_OR_NEWER
[assembly: BindTypeNameToType("UnityEngine.PhysicMaterialCombine, UnityEngine.PhysicsModule", typeof(UnityEngine.PhysicsMaterialCombine))]
[assembly: BindTypeNameToType("UnityEngine.PhysicMaterial, UnityEngine.PhysicsModule", typeof(UnityEngine.PhysicsMaterial))]
#endif
namespace VRC.Udon.Serialization.Formatters
{
public sealed class UdonProgramFormatter : BaseFormatter<UdonProgram>
{
private static readonly Serializer<byte[]> _byteArrayReaderWriter = Serializer.Get<byte[]>();
private static readonly Serializer<IUdonHeap> _udonHeapReaderWriter = Serializer.Get<IUdonHeap>();
private static readonly Serializer<IUdonSymbolTable> _udonSymbolTableReaderWriter = Serializer.Get<IUdonSymbolTable>();
private static readonly Serializer<IUdonSyncMetadataTable> _udonSyncMetadataTableReaderWriter = Serializer.Get<IUdonSyncMetadataTable>();
protected override UdonProgram GetUninitializedObject()
{
return null;
}
// ReSharper disable once RedundantAssignment
protected override void DeserializeImplementation(ref UdonProgram value, IDataReader reader)
{
reader.ReadString(out string instructionSetIdentifier);
reader.ReadInt32(out int instructionSetVersion);
byte[] byteCode = _byteArrayReaderWriter.ReadValue(reader);
IUdonHeap heap = _udonHeapReaderWriter.ReadValue(reader);
IUdonSymbolTable entryPoints = _udonSymbolTableReaderWriter.ReadValue(reader);
IUdonSymbolTable symbolTable = _udonSymbolTableReaderWriter.ReadValue(reader);
IUdonSyncMetadataTable syncMetadataTable = _udonSyncMetadataTableReaderWriter.ReadValue(reader);
if(!reader.ReadInt32(out int updateOrder))
{
updateOrder = 0;
}
value = new UdonProgram(instructionSetIdentifier, instructionSetVersion, byteCode, heap, entryPoints, symbolTable, syncMetadataTable, updateOrder);
RegisterReferenceID(value, reader);
InvokeOnDeserializingCallbacks(ref value, reader.Context);
}
protected override void SerializeImplementation(ref UdonProgram value, IDataWriter writer)
{
writer.WriteString("InstructionSetIdentifier", value.InstructionSetIdentifier);
writer.WriteInt32("InstructionSetVersion", value.InstructionSetVersion);
_byteArrayReaderWriter.WriteValue("ByteCode", value.ByteCode, writer);
_udonHeapReaderWriter.WriteValue("Heap", value.Heap, writer);
_udonSymbolTableReaderWriter.WriteValue("EntryPoints", value.EntryPoints, writer);
_udonSymbolTableReaderWriter.WriteValue("SymbolTable", value.SymbolTable, writer);
_udonSyncMetadataTableReaderWriter.WriteValue("SyncMetadataTable", value.SyncMetadataTable, writer);
writer.WriteInt32("UpdateOrder", value.UpdateOrder);
}
}
}

11
Packages/com.vrchat.worlds/Runtime/Udon/Serialization/Formatters/UdonProgramFormatter.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f2626352b2a60eb41adc3580ae44c750
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: