public JsonData ToJsonData(JsonData cache = null)
{
if (userData != null)
{
return(userData);
}
if (cache == null)
{
cache = new JsonData();
}
cache["device"] = device;
cache["mode"] = mode;
cache["id"] = id;
cache["code"] = code;
cache["uuid"] = uuid;
if (datas != null && datas.Length > 0)
{
cache["data"] = LitJsonHelper.CreateArrayJsonData(datas);
}
if (res)
{
cache["sendTo"] = "uCode";
}
return(cache);
}
internal void RequestSupportCmdInfo(BridgeRequest req, BridgeResponse rep)
{
var json = req.GetArgument();
if (json.IsObject)
{
if (json.ContainsKey("protocol"))
{
JsonData protocols = json["protocol"];
if (protocols.IsArray)
{
JsonData result = new JsonData();
result.SetJsonType(JsonType.Object);
var protocolsCount = protocols.Count;
for (int i = 0; i < protocolsCount; i++)
{
var protocol = (string)protocols[i];
if (string.IsNullOrEmpty(protocol) || protocol == "Explorer")
{
protocol = "Explorer";
var support = CommandFactory.GetCommandSupprtList(typeof(ExploreProtocol));
result[protocol] = LitJsonHelper.CreateArrayJsonData(support);
}
}
rep.SetResult(BridgeCode.Success, result);
return;
}
}
}
DebugUtility.LogError(LoggerTags.Project, "The first argument is not JSON object, examples: 'protocol': [ 'Explorer' ] ");
rep.SetFailureResult(BridgeCode.Failure);
}
// LitJson转换成自定义格式
public static void ConvertToBinaryFile(string fileName, string configName, string json)
{
if (string.IsNullOrEmpty(fileName) || string.IsNullOrEmpty(json))
{
return;
}
ConvertClassInfo info = GetConvertClass(configName);
if (info == null || info.DictionaryType == null)
{
return;
}
// System.Type dictType = info.DictionaryType;
System.Collections.IDictionary values = LitJsonHelper.ToTypeObject(json, info.DictionaryType) as System.Collections.IDictionary;
if (values == null)
{
return;
}
string newFileName = string.Format("{0}/{1}.bytes", Path.GetDirectoryName(fileName), info.convertName);
FileStream stream = new FileStream(newFileName, FileMode.Create, FileAccess.Write);
try {
try {
ConfigWrap.ToStream(stream, values);
} catch (Exception e) {
UnityEngine.Debug.LogErrorFormat("【转换异常】{0}=>{1}", fileName, e.ToString());
}
} finally {
stream.Flush();
stream.Close();
stream.Dispose();
}
}
public static void FromJson(JsonData jsonNode, out string name, out string path, out int layer, out string tag, out Vector3 pos, out Quaternion rot, out Vector3 scale)
{
name = (string)jsonNode[SerializationConst.name];
path = (string)jsonNode[SerializationConst.path];
tag = string.Empty;
layer = LayerUtility.DefaultLayer;
if (jsonNode.ContainsKey(SerializationConst.layer))
{
layer = (int)jsonNode[SerializationConst.layer];
}
if (jsonNode.ContainsKey(SerializationConst.tag))
{
tag = (string)jsonNode[SerializationConst.tag];
}
if (string.IsNullOrEmpty(tag))
{
tag = TagUtility.Untagged;
}
var transform = jsonNode[SerializationConst.transform];
LitJsonHelper.ParseVector(transform[0], out pos);
LitJsonHelper.ParseQuaternion(transform[1], out rot);
LitJsonHelper.ParseVector(transform[2], out scale);
}
public override void Init()
{
base.Init();
// connected = false;
// wsConnected = true;
//实例化jsonhelper
jsonHelper = new LitJsonHelper();
}
public bool Parse(LitJson.JsonData modelData)
{
mAssetDatas.Clear();
mModelData = modelData;
if (modelData.ContainsKey(SerializationConst.assets))
{
LitJsonHelper.ParseJsonObject(modelData[SerializationConst.assets], assetDatas);
}
mGameObjectDataModel = new RobotGameObjectDataModel(modelData);
return(true);
}
public JsonData ToJsonData()
{
var result = new JsonData();
result.SetJsonType(JsonType.Object);
var device = new JsonData();
device.SetJsonType(JsonType.Object);
device["deviceID"] = deviceID;
device["supported"] = LitJsonHelper.CreateArrayJsonData(supportModes);
result["device"] = device;
return(result);
}
protected override void SerializeToJson(LitJson.JsonData modelData)
{
RevertUnknownID();
mPartsGroup.Clear();
mParts.Clear();
mRobot.transform.GetComponentsInChildren(true, mPartsGroup);
mRobot.transform.GetComponentsInChildren(true, mParts);
GenerateUniquePath(mRobot.transform);
SerializeToJson(modelData, mRobot.transform);
var assets = new Dictionary <string, int>();
PredicatePreloadingAssets(modelData, assets);
if (assets.Count > 0)
{
modelData[SerializationConst.assets] = LitJsonHelper.CreateObjectJsonData(assets);
}
}
public static JsonData ToJson(Transform tr, JsonData node)
{
try
{
node[SerializationConst.name] = tr.name;
node[SerializationConst.path] = tr.GetHierarchyPath(typeof(Robot));
node[SerializationConst.layer] = tr.gameObject.layer;
string tag = tr.gameObject.tag;
node[SerializationConst.tag] = tag; // == TagUtility.EditorOnly ? TagUtility.Untagged : tag;
var transform = new JsonData();
transform.Add(LitJsonHelper.CreateJsonData(tr.transform.localPosition));
transform.Add(LitJsonHelper.CreateJsonData(tr.transform.localRotation));
transform.Add(LitJsonHelper.CreateJsonData(tr.transform.localScale));
node[SerializationConst.transform] = transform;
}
catch (Exception ex)
{
DebugUtility.LogError(LoggerTags.Project, ex.Message);
}
return(node);
}
private static void RegisterRobots()
{
Register(typeof(Robot), (componentData, component) =>
{
var userData = componentData.userData;
if (userData != null)
{
if (component is RobotVehicle vehicle)
{
if (userData.ContainsKey("left"))
{
var left = userData["left"];
int leftCount = left.Count;
var leftRotations = LitJsonHelper.ParseJsonArray(left, data => (string)data, ArrayHelper <string> .Empty);
vehicle.leftRotationParts = new RotationPartComponent[leftCount];
for (int i = 0; i < leftCount; i++)
{
vehicle.leftRotationParts[i] = vehicle.FindHierarchyPath <RotationPartComponent>(leftRotations[i]);
}
}
if (userData.ContainsKey("right"))
{
var right = userData["right"];
int rightCount = right.Count;
var rightRotations = LitJsonHelper.ParseJsonArray(right, data => (string)data, ArrayHelper <string> .Empty);
vehicle.rightRotationParts = new RotationPartComponent[rightCount];
for (int i = 0; i < rightCount; i++)
{
vehicle.rightRotationParts[i] = vehicle.FindHierarchyPath <RotationPartComponent>(rightRotations[i]);
}
}
vehicle.moveFactor = LitJsonHelper.ParseJsonToFloat(userData["moveFactor"]);
vehicle.rotationSpeed = LitJsonHelper.ParseJsonToFloat(userData["rotationSpeed"]);
vehicle.angularVelocity = LitJsonHelper.ParseJsonToFloat(userData["angularVelocity"]);
}
}
return(true);
});
}
private static void RegisterRobots()
{
Register(typeof(Robot), (component) =>
{
var userData = new JsonData();
if (component is RobotVehicle vehicle)
{
if (vehicle.leftRotationParts != null && vehicle.leftRotationParts.Length > 0)
{
userData["left"] = LitJsonHelper.CreateArrayJsonData(vehicle.leftRotationParts.GetHierarchyPath(typeof(Robot)));
}
if (vehicle.rightRotationParts != null && vehicle.rightRotationParts.Length > 0)
{
userData["right"] = LitJsonHelper.CreateArrayJsonData(vehicle.rightRotationParts.GetHierarchyPath(typeof(Robot)));
}
userData["moveFactor"] = LitJsonHelper.CreateJsonData(vehicle.moveFactor);
userData["rotationSpeed"] = LitJsonHelper.CreateJsonData(vehicle.rotationSpeed);
userData["angularVelocity"] = LitJsonHelper.CreateJsonData(vehicle.angularVelocity);
}
return(userData);
});
}
private static void RegisterPhysics()
{
Register(typeof(BoxCollider), (componentData, component) =>
{
var userData = componentData.userData;
if (userData != null)
{
if (component is BoxCollider collider)
{
LitJsonHelper.ParseVector(userData["size"], out Vector3 size);
collider.size = size;
LitJsonHelper.ParseVector(userData["center"], out Vector3 center);
collider.center = center;
collider.isTrigger = ((int)userData["isTrigger"]) == 1;
}
}
return(true);
});
Register(typeof(SphereCollider), (componentData, component) =>
{
var userData = componentData.userData;
if (userData != null)
{
if (component is SphereCollider collider)
{
collider.radius = LitJsonHelper.ParseJsonToFloat(userData["radius"]);
LitJsonHelper.ParseVector(userData["center"], out Vector3 center);
collider.center = center;
collider.isTrigger = ((int)userData["isTrigger"]) == 1;
}
}
return(true);
});
Register(typeof(MeshCollider), (componentData, component) =>
{
return(true);
});
Register(typeof(CapsuleCollider), (componentData, component) =>
{
var userData = componentData.userData;
if (userData != null)
{
if (component is CapsuleCollider collider)
{
collider.radius = LitJsonHelper.ParseJsonToFloat(userData["radius"]);
collider.height = LitJsonHelper.ParseJsonToFloat(userData["height"]);
LitJsonHelper.ParseVector(userData["center"], out Vector3 center);
collider.center = center;
collider.isTrigger = ((int)userData["isTrigger"]) == 1;
collider.direction = (int)userData["direction"];
}
}
return(true);
});
Register(typeof(Rigidbody), (componentData, component) =>
{
var userData = componentData.userData;
if (userData != null)
{
if (component is Rigidbody rigidbody)
{
rigidbody.mass = LitJsonHelper.ParseJsonToFloat(userData["mass"]);
rigidbody.drag = LitJsonHelper.ParseJsonToFloat(userData["drag"]);
rigidbody.angularDrag = LitJsonHelper.ParseJsonToFloat(userData["angularDrag"]);
rigidbody.useGravity = (int)userData["useGravity"] == 1;
rigidbody.isKinematic = (int)userData["isKinematic"] == 1;
rigidbody.collisionDetectionMode = (CollisionDetectionMode)(int)userData["collisionDetectionMode"];
rigidbody.interpolation = (RigidbodyInterpolation)(int)userData["interpolation"];
rigidbody.constraints = (RigidbodyConstraints)(int)userData["constraints"];
}
}
return(true);
});
}
private static void RegisterPhysics()
{
Register(typeof(BoxCollider), (component) =>
{
var userData = new JsonData();
if (component is BoxCollider collider)
{
userData["size"] = LitJsonHelper.CreateJsonData(collider.size);
userData["center"] = LitJsonHelper.CreateJsonData(collider.center);
userData["isTrigger"] = collider.isTrigger.To01();
}
return(userData);
});
Register(typeof(SphereCollider), (component) =>
{
var userData = new JsonData();
if (component is SphereCollider collider)
{
userData["radius"] = LitJsonHelper.CreateJsonData(collider.radius);
userData["center"] = LitJsonHelper.CreateJsonData(collider.center);
userData["isTrigger"] = collider.isTrigger.To01();
}
return(userData);
});
Register(typeof(MeshCollider), (component) =>
{
throw new Exception("Unsupported MeshCollider");
});
Register(typeof(CapsuleCollider), (component) =>
{
var userData = new JsonData();
if (component is CapsuleCollider collider)
{
userData["radius"] = LitJsonHelper.CreateJsonData(collider.radius);
userData["center"] = LitJsonHelper.CreateJsonData(collider.center);
userData["height"] = LitJsonHelper.CreateJsonData(collider.height);
userData["direction"] = collider.direction;
userData["isTrigger"] = collider.isTrigger.To01();
}
return(userData);
});
Register(typeof(Rigidbody), (component) =>
{
var userData = new JsonData();
if (component is Rigidbody rigidbody)
{
userData["mass"] = LitJsonHelper.CreateJsonData(rigidbody.mass);
userData["drag"] = LitJsonHelper.CreateJsonData(rigidbody.drag);
userData["angularDrag"] = LitJsonHelper.CreateJsonData(rigidbody.angularDrag);
userData["useGravity"] = rigidbody.useGravity.To01();
userData["isKinematic"] = rigidbody.isKinematic.To01();
userData["collisionDetectionMode"] = (int)rigidbody.collisionDetectionMode;
userData["interpolation"] = (int)rigidbody.interpolation;
userData["constraints"] = (int)rigidbody.constraints;
}
return(userData);
});
}
public static ExploreProtocol Create(ExploreProtocolDataType type, string jsonStr, string context = "")
{
try
{
var node = JsonMapper.ToObject(jsonStr);
if (node != null)
{
int device = -1;
if (node.ContainsKey("device"))
{
device = (int)node["device"];
}
int mode = -1;
if (node.ContainsKey("mode"))
{
mode = (int)node["mode"];
}
int id = -1;
if (node.ContainsKey("id"))
{
id = (int)node["id"];
}
int code = -1;
if (node.ContainsKey("code"))
{
code = (int)node["code"];
}
string uuid = string.Empty;
if (node.ContainsKey("uuid"))
{
uuid = ((string)node["uuid"]); //.ToLower();
}
bool debug = false;
if (node.ContainsKey("debug"))
{
debug = (int)node["debug"] == 1;
}
ExploreProtocol p = new ExploreProtocol();
p.dataType = type;
p.device = device;
p.mode = mode;
p.id = id;
p.code = code;
p.uuid = uuid;
p.debug = debug;
if (node.ContainsKey("data"))
{
var datas = node["data"]; // it's array of int
switch (type)
{
case ExploreProtocolDataType.DTObject:
{
p.datas = LitJsonHelper.ParseJsonArray(datas, jsonParam =>
{
LitJsonHelper.SafeConvert(jsonParam, out object result);
return(result);
}, ArrayHelper <object> .Empty);
break;
}
case ExploreProtocolDataType.DTInt:
{
p.datas = LitJsonHelper.ParseJsonArray(datas, jsonParam =>
{
LitJsonHelper.SafeConvert(jsonParam, out int result);
return(result);
}, ArrayHelper <int> .Empty);
break;
}
case ExploreProtocolDataType.DTFloat:
{
p.datas = LitJsonHelper.ParseJsonArray(datas, jsonParam =>
{
LitJsonHelper.SafeConvert(jsonParam, out float result);
return(result);
}, ArrayHelper <float> .Empty);
break;
}
}
}
return(p);
}
}
catch (System.Exception ex)
{
DebugUtility.LogError(LoggerTags.Module, "Failure to create json data , Context : {0}, Stack : {1}", context, ex.StackTrace);
}
return(null);
}
private static void RegisterParts()
{
Register(typeof(Part), (componentData, component) =>
{
return(true);
});
Register(typeof(PartsGroup), (componentData, component) =>
{
var userData = componentData.userData;
if (userData != null)
{
if (component is PartsGroup group)
{
group.upAxis = (AxisType)(int)userData["up"];
group.inverseAxis = (int)userData["inv"] == 1;
group.commandType = (ECommandType)(int)userData["commandType"];
if (userData.ContainsKey("targets"))
{
var robot = group.robot;
var targetPaths = LitJsonHelper.ParseJsonArray(userData["targets"], data => (string)data, ArrayHelper <string> .Empty);
group.controlTargets = new Group[targetPaths.Length];
for (int i = 0; i < targetPaths.Length; i++)
{
string path = targetPaths[i];
if (string.IsNullOrEmpty(path))
{
continue;
}
group.controlTargets[i] = robot.transform.FindHierarchyPath <Group>(path);
}
}
}
}
return(true);
});
Register(typeof(PartComponent), (componentData, component) =>
{
var userData = componentData.userData;
if (userData != null)
{
var pc = (PartComponent)component;
var part = pc.GetPart();
if (userData.ContainsKey("pivotLink"))
{
if (part != null)
{
pc.pivotLink = part.FindHierarchyPath((string)userData["pivotLink"]);
}
}
if (component is AdvancedPartComponent apc)
{
apc.id = (int)userData["id"];
}
if (component is ButtonSensorComponent bsc)
{
bsc.eventTimeout = LitJsonHelper.ParseJsonToFloat(userData["eventTimeout"]);
bsc.timeout = LitJsonHelper.ParseJsonToFloat(userData["timeout"]);
}
if (component is LineTraceSensorComponent ltsc)
{
ltsc.expectedRange = LitJsonHelper.ParseJsonToFloat(userData["expectedRange"]);
}
if (component is RotationPartComponent rpc)
{
if (part != null)
{
if (userData.ContainsKey("axisDP"))
{
rpc.axisDP = part.FindHierarchyPath <AxleConnectivity>((string)userData["axisDP"]);
}
}
rpc.wrapMode = (ERotationWrapMode)(int)userData["wrapMode"];
rpc.convertMode = (EEulerAngleConvertMode)(int)userData["convertMode"];
rpc.minEularAngleY = LitJsonHelper.ParseJsonToFloat(userData["minEularAngleY"]);
rpc.maxEularAngleY = LitJsonHelper.ParseJsonToFloat(userData["maxEularAngleY"]);
rpc.localEulerAnglesY = LitJsonHelper.ParseJsonToFloat(userData["localEulerAnglesY"]);
}
}
return(true);
});
}
private static void RegisterParts()
{
Register(typeof(Part), (component) =>
{
var part = (Part)component;
var userData = new JsonData();
userData[SerializationConst.address] = part.addressName;
return(userData);
});
Register(typeof(PartsGroup), (component) =>
{
var group = (PartsGroup)component;
var userData = new JsonData();
userData.SetJsonType(JsonType.Object);
userData["up"] = (int)group.upAxis;
userData["inv"] = group.inverseAxis.To01();
userData["commandType"] = (int)group.commandType;
if (group.controlTargets != null && group.controlTargets.Length > 0)
{
userData["targets"] = LitJsonHelper.CreateArrayJsonData(group.controlTargets.GetHierarchyPath(typeof(Robot)));
}
return(userData);
});
Register(typeof(PartComponent), (component) =>
{
var userData = new JsonData();
var pc = (PartComponent)component;
if (pc.pivotLink != null && pc.pivotLink != pc.transform)
{
userData["pivotLink"] = pc.pivotLink.GetHierarchyPath(typeof(Part));
}
if (component is AdvancedPartComponent apc)
{
userData["id"] = apc.id;
}
if (component is ButtonSensorComponent bsc)
{
userData["eventTimeout"] = LitJsonHelper.CreateJsonData(bsc.eventTimeout);
userData["timeout"] = LitJsonHelper.CreateJsonData(bsc.timeout);
}
if (component is LineTraceSensorComponent ltsc)
{
userData["expectedRange"] = LitJsonHelper.CreateJsonData(ltsc.expectedRange);
}
if (component is RotationPartComponent rpc)
{
if (rpc.axisDP != null)
{
userData["axisDP"] = rpc.axisDP.transform.GetHierarchyPath(typeof(Part));
}
userData["minEularAngleY"] = LitJsonHelper.CreateJsonData(rpc.minEularAngleY);
userData["maxEularAngleY"] = LitJsonHelper.CreateJsonData(rpc.maxEularAngleY);
userData["wrapMode"] = (int)rpc.wrapMode;
userData["convertMode"] = (int)rpc.convertMode;
userData["localEulerAnglesY"] = LitJsonHelper.CreateJsonData(rpc.localEulerAnglesY);
}
return(userData);
});
}
static User()
{
LitJsonHelper.Initialize();
Load();
}
