public static void Test_Quat_Generic_Initialization_Against_Unity(float a, float b, float c, float d) { //arrange Quaternion<float> genericQuat = new Quaternion<float>(a, b, c, d); UnityEngine.Quaternion unityQuat = new UnityEngine.Quaternion(a, b, c, d); //assert for (int i = 0; i < 4; i++) Assert.AreEqual(genericQuat[i], unityQuat[i]); }
public void ProcessPacket(CreatePrebuildsRequest packet, NebulaConnection conn) { PlanetData planet = GameMain.galaxy.PlanetById(packet.PlanetId); if (planet.factory == null) { Log.Warn($"planet.factory was null create new one"); planet.factory = GameMain.data.GetOrCreateFactory(planet); } PlayerAction_Build pab = GameMain.mainPlayer.controller?.actionBuild; if (pab != null) { //Make backup of values that are overwritten List <BuildPreview> tmpList = pab.buildPreviews; bool tmpConfirm = pab.waitConfirm; UnityEngine.Vector3 tmpPos = pab.previewPose.position; UnityEngine.Quaternion tmpRot = pab.previewPose.rotation; PlanetFactory tmpFactory = null; NearColliderLogic tmpNearcdLogic = null; PlanetPhysics tmpPlanetPhysics = null; float tmpBuildArea = GameMain.mainPlayer.mecha.buildArea; PlanetData tmpData = null; bool loadExternalPlanetData = GameMain.localPlanet != planet; //Load temporary planet data, since host is not there if (loadExternalPlanetData) { tmpFactory = (PlanetFactory)AccessTools.Field(typeof(PlayerAction_Build), "factory").GetValue(GameMain.mainPlayer.controller.actionBuild); tmpNearcdLogic = (NearColliderLogic)AccessTools.Field(typeof(PlayerAction_Build), "nearcdLogic").GetValue(GameMain.mainPlayer.controller.actionBuild); tmpPlanetPhysics = (PlanetPhysics)AccessTools.Field(typeof(PlayerAction_Build), "planetPhysics").GetValue(pab); tmpData = GameMain.mainPlayer.planetData; } //Create Prebuilds from incomming packet and prepare new position pab.buildPreviews = packet.GetBuildPreviews(); pab.waitConfirm = true; using (FactoryManager.EventFromServer.On()) { FactoryManager.EventFactory = planet.factory; pab.previewPose.position = new UnityEngine.Vector3(packet.PosePosition.x, packet.PosePosition.y, packet.PosePosition.z); pab.previewPose.rotation = new UnityEngine.Quaternion(packet.PoseRotation.x, packet.PoseRotation.y, packet.PoseRotation.z, packet.PoseRotation.w); //Check if some mandatory variables are missing if (planet.physics == null || planet.physics.colChunks == null) { planet.physics = new PlanetPhysics(planet); planet.physics.Init(); } if (AccessTools.Field(typeof(CargoTraffic), "beltRenderingBatch").GetValue(planet.factory.cargoTraffic) == null) { planet.factory.cargoTraffic.CreateRenderingBatches(); } if (planet.aux == null) { planet.aux = new PlanetAuxData(planet); } //Set temporary Local Planet / Factory data that are needed for original methods CheckBuildConditions() and CreatePrebuilds() AccessTools.Field(typeof(PlayerAction_Build), "factory").SetValue(GameMain.mainPlayer.controller.actionBuild, planet.factory); AccessTools.Field(typeof(PlayerAction_Build), "planetPhysics").SetValue(GameMain.mainPlayer.controller.actionBuild, planet.physics); AccessTools.Field(typeof(PlayerAction_Build), "nearcdLogic").SetValue(GameMain.mainPlayer.controller.actionBuild, planet.physics.nearColliderLogic); AccessTools.Property(typeof(global::Player), "planetData").SetValue(GameMain.mainPlayer, planet, null); //Check if prebuilds can be build (collision check, height check, etc) GameMain.mainPlayer.mecha.buildArea = float.MaxValue; bool canBuild; using (FactoryManager.IgnoreBasicBuildConditionChecks.On()) { canBuild = pab.CheckBuildConditions(); canBuild &= CheckBuildingConnections(pab.buildPreviews, planet.factory.entityPool, planet.factory.prebuildPool); } if (canBuild) { FactoryManager.PacketAuthor = packet.AuthorId; pab.CreatePrebuilds(); FactoryManager.PacketAuthor = -1; } //Revert changes back to the original planet if (loadExternalPlanetData) { planet.physics.Free(); planet.physics = null; AccessTools.Property(typeof(global::Player), "planetData").SetValue(GameMain.mainPlayer, tmpData, null); AccessTools.Field(typeof(PlayerAction_Build), "planetPhysics").SetValue(GameMain.mainPlayer.controller.actionBuild, tmpPlanetPhysics); AccessTools.Field(typeof(PlayerAction_Build), "factory").SetValue(GameMain.mainPlayer.controller.actionBuild, tmpFactory); AccessTools.Field(typeof(PlayerAction_Build), "nearcdLogic").SetValue(GameMain.mainPlayer.controller.actionBuild, tmpNearcdLogic); } GameMain.mainPlayer.mecha.buildArea = tmpBuildArea; FactoryManager.EventFactory = null; } pab.buildPreviews = tmpList; pab.waitConfirm = tmpConfirm; pab.previewPose.position = tmpPos; pab.previewPose.rotation = tmpRot; } }
static void WriteBackInstance(ILRuntime.Runtime.Enviorment.AppDomain __domain, StackObject *ptr_of_this_method, IList <object> __mStack, ref UnityEngine.Quaternion instance_of_this_method) { ptr_of_this_method = ILIntepreter.GetObjectAndResolveReference(ptr_of_this_method); switch (ptr_of_this_method->ObjectType) { case ObjectTypes.Object: { __mStack[ptr_of_this_method->Value] = instance_of_this_method; } break; case ObjectTypes.FieldReference: { var ___obj = __mStack[ptr_of_this_method->Value]; if (___obj is ILTypeInstance) { ((ILTypeInstance)___obj)[ptr_of_this_method->ValueLow] = instance_of_this_method; } else { var t = __domain.GetType(___obj.GetType()) as CLRType; t.SetFieldValue(ptr_of_this_method->ValueLow, ref ___obj, instance_of_this_method); } } break; case ObjectTypes.StaticFieldReference: { var t = __domain.GetType(ptr_of_this_method->Value); if (t is ILType) { ((ILType)t).StaticInstance[ptr_of_this_method->ValueLow] = instance_of_this_method; } else { ((CLRType)t).SetStaticFieldValue(ptr_of_this_method->ValueLow, instance_of_this_method); } } break; case ObjectTypes.ArrayReference: { var instance_of_arrayReference = __mStack[ptr_of_this_method->Value] as UnityEngine.Quaternion[]; instance_of_arrayReference[ptr_of_this_method->ValueLow] = instance_of_this_method; } break; } }
/// <summary> /// Copies data from a Unity rotation into the structure /// </summary> /// <param name="rot">Rotation data</param> /// public void CopyFrom(UnityEngine.Quaternion rot) { qx = rot.x; qy = rot.y; qz = rot.z; qw = rot.w; }
/// <summary> /// Copies data from the structure to a Unity position class /// </summary> /// <param name="rot">Rotation data to copy into</param> /// public void CopyTo(ref UnityEngine.Quaternion rot) { rot.x = qx; rot.y = qy; rot.z = qz; rot.w = qw; }
public static T Create <T>(string name, UnityEngine.Transform parent, Vector3 position, Quaternion rotation, Vector3 scale) where T : ChiselNode { return(Create <T>(name, parent, Matrix4x4.TRS(position, rotation, scale))); }
public static T Create <T>(string name, ChiselModel model, Vector3 position, Quaternion rotation, Vector3 scale) where T : ChiselNode { return(Create <T>(name, model ? model.transform : null, position, rotation, scale)); }
public static T Create <T>(string name, UnityEngine.Transform parent, Vector3 position, Quaternion rotation, Vector3 scale) where T : ChiselNode { // TODO: ensure we're creating this in the active scene // TODO: handle scene being locked by version control if (string.IsNullOrEmpty(name)) { #if UNITY_EDITOR name = UnityEditor.GameObjectUtility.GetUniqueNameForSibling(parent, typeof(T).Name); #else name = typeof(T).Name; #endif } var newGameObject = new UnityEngine.GameObject(name); #if UNITY_EDITOR UnityEditor.Undo.RegisterCreatedObjectUndo(newGameObject, "Created " + name); #endif newGameObject.SetActive(false); try { var brushTransform = newGameObject.transform; #if UNITY_EDITOR if (parent) { UnityEditor.Undo.SetTransformParent(brushTransform, parent, "Move child node underneath parent operation"); } UnityEditor.Undo.RecordObject(brushTransform, "Move child node to given position"); brushTransform.localPosition = position; brushTransform.localRotation = rotation; brushTransform.localScale = scale; return(UnityEditor.Undo.AddComponent <T>(newGameObject)); #else if (parent) { brushTransform.SetParent(parent, false); } brushTransform.localPosition = position; brushTransform.localRotation = rotation; brushTransform.localScale = scale; return(newGameObject.AddComponent <T>()); #endif } finally { newGameObject.SetActive(true); } }
static public GfQuatf QuaternionToQuatf(UnityEngine.Quaternion quaternion) { // See pxr/unity quaternion layout above. return(new GfQuatf(quaternion.w, quaternion.x, quaternion.y, quaternion.z)); }
public static IDG.Fixed ToFixedRotation(this UnityEngine.Quaternion rotation) { return(-rotation.eulerAngles.y.ToFixed()); }
public static UnityEngine.Object Instantiate(UnityEngine.Object original, UnityEngine.Vector3 position, UnityEngine.Quaternion rotation) { throw new NotImplementedException("This function was automatically generated by Mockery and has no real implementation yet."); }
public void ProcessPacket(CreatePrebuildsRequest packet, NebulaConnection conn) { PlanetData planet = GameMain.galaxy.PlanetById(packet.PlanetId); if (planet.factory == null) { // We only execute the code if the client has loaded the factory at least once. // Else it will get it once it goes to the planet for the first time. return; } PlayerAction_Build pab = GameMain.mainPlayer.controller?.actionBuild; if (pab != null) { //Make backup of values that are overwritten List <BuildPreview> tmpList = pab.buildPreviews; bool tmpConfirm = pab.waitConfirm; UnityEngine.Vector3 tmpPos = pab.previewPose.position; UnityEngine.Quaternion tmpRot = pab.previewPose.rotation; PlanetFactory tmpFactory = (PlanetFactory)AccessTools.Field(typeof(PlayerAction_Build), "factory").GetValue(GameMain.mainPlayer.controller.actionBuild); PlanetPhysics tmpPlanetPhysics = (PlanetPhysics)AccessTools.Field(typeof(PlayerAction_Build), "planetPhysics").GetValue(pab); //Create Prebuilds from incomming packet pab.buildPreviews = packet.GetBuildPreviews(); pab.waitConfirm = true; using (FactoryManager.EventFromServer.On()) { FactoryManager.EventFactory = planet.factory; pab.previewPose.position = new UnityEngine.Vector3(packet.PosePosition.x, packet.PosePosition.y, packet.PosePosition.z); pab.previewPose.rotation = new UnityEngine.Quaternion(packet.PoseRotation.x, packet.PoseRotation.y, packet.PoseRotation.z, packet.PoseRotation.w); AccessTools.Field(typeof(PlayerAction_Build), "factory").SetValue(GameMain.mainPlayer.controller.actionBuild, planet.factory); //Create temporary physics for spawning building's colliders if (planet.physics == null || planet.physics.colChunks == null) { planet.physics = new PlanetPhysics(planet); planet.physics.Init(); } if (AccessTools.Field(typeof(CargoTraffic), "beltRenderingBatch").GetValue(planet.factory.cargoTraffic) == null) { planet.factory.cargoTraffic.CreateRenderingBatches(); } //Take item from the inventory if player is author of the build if (packet.AuthorId == LocalPlayer.PlayerId) { foreach (BuildPreview buildPreview in pab.buildPreviews) { if (GameMain.mainPlayer.inhandItemId == buildPreview.item.ID && GameMain.mainPlayer.inhandItemCount > 0) { GameMain.mainPlayer.UseHandItems(1); } else { int num = 1; GameMain.mainPlayer.package.TakeTailItems(ref buildPreview.item.ID, ref num, false); } } } AccessTools.Field(typeof(PlayerAction_Build), "planetPhysics").SetValue(GameMain.mainPlayer.controller.actionBuild, planet.physics); pab.CreatePrebuilds(); FactoryManager.EventFactory = null; } //Author has to call this for the continuous belt building if (packet.AuthorId == LocalPlayer.PlayerId) { pab.AfterPrebuild(); } //Revert changes back AccessTools.Field(typeof(PlayerAction_Build), "planetPhysics").SetValue(GameMain.mainPlayer.controller.actionBuild, tmpPlanetPhysics); AccessTools.Field(typeof(PlayerAction_Build), "factory").SetValue(GameMain.mainPlayer.controller.actionBuild, tmpFactory); pab.buildPreviews = tmpList; pab.waitConfirm = tmpConfirm; pab.previewPose.position = tmpPos; pab.previewPose.rotation = tmpRot; } }
public static UnityEngine.Vector3 ToEulerAngles(UnityEngine.Quaternion rotation) { throw new NotImplementedException("This function was automatically generated by Mockery and has no real implementation yet."); }
public static System.Single Dot(UnityEngine.Quaternion a, UnityEngine.Quaternion b) { throw new NotImplementedException("This function was automatically generated by Mockery and has no real implementation yet."); }
/// <summary>Write quaternion</summary> /// <param name="stream">Bit Stream</param> /// <param name="value">Value</param> public static void WriteQuaternion(this BitStream stream, UnityEngine.Quaternion value) { stream.WriteVector3(value.eulerAngles); }
/// <summary> /// Decompose the given matrix into translation, rotation, and scale, accounting for potential /// handedness changes in the matrix. Returns false if the matrix is singular. /// </summary> /// <remarks> /// Note that for a change of handedness, all scales will invert and a corrective rotation will /// be aded, which will not match the original TSR values, but will be correct in terms of /// orientation, position and scale. /// </remarks> public static bool Decompose( UnityEngine.Matrix4x4 matrix, out UnityEngine.Vector3 translation, out UnityEngine.Quaternion rotation, out UnityEngine.Vector3 scale) { // PERFORMANCE: Move this into C++. translation = new UnityEngine.Vector3(); rotation = new UnityEngine.Quaternion(); scale = new UnityEngine.Vector3(); if (matrix[3, 3] == 0.0f) { return(false); } // Normalize the matrix. for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) { matrix[i, j] /= matrix[3, 3]; } } // perspectiveMatrix is used to solve for perspective, but it also provides // an easy way to test for singularity of the upper 3x3 component. UnityEngine.Matrix4x4 persp = matrix; for (int i = 0; i < 3; i++) { persp[3, i] = 0; } persp[3, 3] = 1; if (persp.determinant == 0.0f) { return(false); } // Next take care of translation (easy). translation = new UnityEngine.Vector3(matrix[0, 3], matrix[1, 3], matrix[2, 3]); matrix[3, 0] = 0; matrix[3, 1] = 0; matrix[3, 2] = 0; UnityEngine.Vector3[] rows = new UnityEngine.Vector3[3]; UnityEngine.Vector3 Pdum3; // Now get scale and shear. for (int i = 0; i < 3; ++i) { rows[i].x = matrix[0, i]; rows[i].y = matrix[1, i]; rows[i].z = matrix[2, i]; } // Compute X scale factor and normalize first row. scale.x = rows[0].magnitude; rows[0] = rows[0].normalized; // Compute XY shear factor and make 2nd row orthogonal to 1st. UnityEngine.Vector3 Skew; Skew.z = UnityEngine.Vector3.Dot(rows[0], rows[1]); rows[1] = WeightedAvg(rows[1], rows[0], 1, -Skew.z); // Now, compute Y scale and normalize 2nd row. scale.y = rows[1].magnitude; rows[1] = rows[1].normalized; // Compute XZ and YZ shears, orthogonalize 3rd row. Skew.y = UnityEngine.Vector3.Dot(rows[0], rows[2]); rows[2] = WeightedAvg(rows[2], rows[0], 1, -Skew.y); Skew.x = UnityEngine.Vector3.Dot(rows[1], rows[2]); rows[2] = WeightedAvg(rows[2], rows[1], 1, -Skew.x); // Next, get Z scale and normalize 3rd row. scale.z = rows[2].magnitude; rows[2] = rows[2].normalized; // At this point, the matrix (in rows[]) is orthonormal. // Check for a coordinate system flip. If the determinant // is -1, then negate the matrix and the scaling factors. Pdum3 = UnityEngine.Vector3.Cross(rows[1], rows[2]); if (UnityEngine.Vector3.Dot(rows[0], Pdum3) < 0) { for (int i = 0; i < 3; i++) { scale[i] *= -1; rows[i] *= -1; } } // Now, get the rotations out, as described in the gem. #if false // Euler Angles. rotation.y = UnityEngine.Mathf.Asin(-rows[0][2]); if (Mathf.Cos(rotation.y) != 0) { rotation.x = UnityEngine.Mathf.Atan2(rows[1][2], rows[2][2]); rotation.z = UnityEngine.Mathf.Atan2(rows[0][1], rows[0][0]); } else { rotation.x = UnityEngine.Mathf.Atan2(-rows[2][0], rows[1][1]); rotation.z = 0; } #else // Quaternions. { int i, j, k = 0; float root, trace = rows[0].x + rows[1].y + rows[2].z; if (trace > 0) { root = UnityEngine.Mathf.Sqrt(trace + 1.0f); rotation.w = 0.5f * root; root = 0.5f / root; rotation.x = root * (rows[1].z - rows[2].y); rotation.y = root * (rows[2].x - rows[0].z); rotation.z = root * (rows[0].y - rows[1].x); } // End if > 0 else { int[] Next = new int[] { 1, 2, 0 }; i = 0; if (rows[1].y > rows[0].x) { i = 1; } if (rows[2].z > rows[i][i]) { i = 2; } j = Next[i]; k = Next[j]; root = UnityEngine.Mathf.Sqrt(rows[i][i] - rows[j][j] - rows[k][k] + 1.0f); rotation[i] = 0.5f * root; root = 0.5f / root; rotation[j] = root * (rows[i][j] + rows[j][i]); rotation[k] = root * (rows[i][k] + rows[k][i]); rotation.w = root * (rows[j][k] - rows[k][j]); } // End if <= 0 } #endif return(true); }
public static UnityEngine.Quaternion Slerp(UnityEngine.Quaternion from, UnityEngine.Quaternion to, System.Single t) { throw new NotImplementedException("This function was automatically generated by Mockery and has no real implementation yet."); }
public static bool GenerateRevolvedShapeAsset(CSGBrushMeshAsset brushMeshAsset, CSGRevolvedShapeDefinition definition) { definition.Validate(); var surfaces = definition.surfaceAssets; var descriptions = definition.surfaceDescriptions; var shapeVertices = new List <Vector2>(); var shapeSegmentIndices = new List <int>(); GetPathVertices(definition.shape, definition.curveSegments, shapeVertices, shapeSegmentIndices); Vector2[][] polygonVerticesArray; int[][] polygonIndicesArray; if (!Decomposition.ConvexPartition(shapeVertices, shapeSegmentIndices, out polygonVerticesArray, out polygonIndicesArray)) { brushMeshAsset.Clear(); return(false); } // TODO: splitting it before we do the composition would be better var polygonVerticesList = polygonVerticesArray.ToList(); for (int i = polygonVerticesList.Count - 1; i >= 0; i--) { SplitPolygon(polygonVerticesList, i); } var subMeshes = new List <CSGBrushSubMesh>(); var horzSegments = definition.revolveSegments; //horizontalSegments; var horzDegreePerSegment = definition.totalAngle / horzSegments; // TODO: make this work when intersecting rotation axis // 1. split polygons along rotation axis // 2. if edge lies on rotation axis, make sure we don't create infinitely thin quad // collapse this quad, or prevent this from happening // TODO: share this code with torus generator for (int p = 0; p < polygonVerticesList.Count; p++) { var polygonVertices = polygonVerticesList[p]; // var segmentIndices = polygonIndicesArray[p]; var shapeSegments = polygonVertices.Length; var vertSegments = polygonVertices.Length; var descriptionIndex = new int[2 + vertSegments]; descriptionIndex[0] = 0; descriptionIndex[1] = 1; for (int v = 0; v < vertSegments; v++) { descriptionIndex[v + 2] = 2; } var horzOffset = definition.startAngle; for (int h = 1, pr = 0; h < horzSegments + 1; pr = h, h++) { var hDegree0 = (pr * horzDegreePerSegment) + horzOffset; var hDegree1 = (h * horzDegreePerSegment) + horzOffset; var rotation0 = Quaternion.AngleAxis(hDegree0, Vector3.forward); var rotation1 = Quaternion.AngleAxis(hDegree1, Vector3.forward); var subMeshVertices = new Vector3[vertSegments * 2]; for (int v = 0; v < vertSegments; v++) { subMeshVertices[v + vertSegments] = rotation0 * new Vector3(polygonVertices[v].x, 0, polygonVertices[v].y); subMeshVertices[v] = rotation1 * new Vector3(polygonVertices[v].x, 0, polygonVertices[v].y); } var subMesh = new CSGBrushSubMesh(); if (!CreateExtrudedSubMesh(subMesh, vertSegments, descriptionIndex, descriptionIndex, 0, 1, subMeshVertices, surfaces, descriptions)) { continue; } if (!subMesh.Validate()) { brushMeshAsset.Clear(); return(false); } subMeshes.Add(subMesh); } } brushMeshAsset.SubMeshes = subMeshes.ToArray(); brushMeshAsset.CalculatePlanes(); brushMeshAsset.SetDirty(); return(true); }
public static T Create <T>(Vector3 position, Quaternion rotation, Vector3 scale) where T : ChiselNode { return(Create <T>(null, (UnityEngine.Transform)null, position, rotation, scale)); }
public static bool Intersect(CubeXCollider src, CylinderXCollider dst, out XContact?contact) { var invP = Quaternion.Inverse(src.Quaternion) * (dst.Position - src.Position); Vector3 n = Vector3.zero; n.x = invP.x; n.z = invP.z; var extents = src.Size * 0.5f; var halfHa = extents.y; var topA = halfHa; var bottomA = -halfHa; var halfHb = dst.Height * 0.5f; var topB = invP.y + halfHb; var bottomB = invP.y - halfHb; var space = dst.Radius; var sqrSpace = space * space; // 相撞时,俯视图下的圆和矩形必然相交 var closest = n; closest.x = Mathf.Clamp(closest.x, -extents.x, extents.x); closest.z = Mathf.Clamp(closest.z, -extents.z, extents.z); if ((n - closest).sqrMagnitude > sqrSpace) { contact = null; return(false); } // 处理相交的情况 Vector3 normal; float penetration; float verticalP = float.PositiveInfinity; float horizontalP; var inside = false; if (n == closest) { inside = true; var disX = extents.x - Mathf.Abs(n.x); var disZ = extents.z - Mathf.Abs(n.z); //找到最近的一个面 if (disX < disZ) { // 沿X轴 if (n.x > 0) { closest.x = extents.x; } else { closest.x = -extents.x; } } else { // 沿Z轴 if (n.z > 0) { closest.z = extents.z; } else { closest.z = -extents.z; } } horizontalP = space + (n - closest).magnitude; } else { horizontalP = space - (n - closest).magnitude; } if (Mathf.Sign(topA - topB) != Mathf.Sign(bottomB - bottomA)) { // 斜向相撞 if (topB > topA) { verticalP = topA - bottomB; } else { verticalP = topB - bottomA; } } if (horizontalP < verticalP) { normal = (src.Quaternion * (n - closest)).normalized; if (inside) { normal = -normal; } penetration = horizontalP; } else { normal = topB > topA ? Vector3.up : Vector3.down; penetration = verticalP; } if (normal == Vector3.zero) { normal = Vector3.up; } contact = new XContact(src, dst, normal, penetration); return(true); }
public Entity BuildPlayer(UnityEngine.Vector3 pos, UnityEngine.Quaternion rot, float size, float height) { return(BuildPlayer(EntitiesManager.GetNextID(), pos, rot, size, height)); }
public static bool Intersect(CubeXCollider src, SphereXCollider dst, out XContact?contact) { // 反向旋转sphere的位置,使得可以在cube的坐标系下进行碰撞判断 var extents = src.Size * 0.5f; var invQ = Quaternion.Inverse(src.Quaternion); var invP = invQ * (dst.Position - src.Position); // 以下所有操作都是在cube的坐标系下,随后的实际方向需要进行坐标系转换 var n = invP; var closest = n; closest.x = Mathf.Clamp(closest.x, -extents.x, extents.x); closest.y = Mathf.Clamp(closest.y, -extents.y, extents.y); closest.z = Mathf.Clamp(closest.z, -extents.z, extents.z); var inside = false; if (n == closest) { inside = true; var disX = extents.x - Mathf.Abs(n.x); var disY = extents.y - Mathf.Abs(n.y); var disZ = extents.z - Mathf.Abs(n.z); //找到最近的一个面 if (disX < disY && disX < disZ) { // 沿X轴 if (n.x > 0) { closest.x = extents.x; } else { closest.x = -extents.x; } } else if (disY < disX && disY < disZ) { // 沿Y轴 if (n.y > 0) { closest.y = extents.y; } else { closest.y = -extents.y; } } else { // 沿Z轴 if (n.z > 0) { closest.z = extents.z; } else { closest.z = -extents.z; } } } var dir = n - closest; var sqrDist = dir.sqrMagnitude; var space = dst.Radius; var sqrSpace = space * space; if (sqrDist < sqrSpace || inside) { var dist = Mathf.Sqrt(sqrDist); var normal = (src.Quaternion * dir).normalized; var penetration = space - dist; if (inside) { normal = -normal; penetration = space + dist; } if (normal == Vector3.zero) { normal = Vector3.up; } contact = new XContact(src, dst, normal, penetration); return(true); } contact = null; return(false); }
/// <summary> /// Copies data from a Unity position and rotation into the structure /// </summary> /// <param name="pos">Position data</param> /// <param name="rot">Rotation data</param> /// public void CopyFrom(UnityEngine.Vector3 pos, UnityEngine.Quaternion rot) { px = pos.x; py = pos.y; pz = pos.z; qx = rot.x; qy = rot.y; qz = rot.z; qw = rot.w; }
public static void DrawMesh(UnityEngine.Mesh mesh, UnityEngine.Vector3 position, UnityEngine.Quaternion rotation, UnityEngine.Material material, System.Int32 layer, UnityEngine.Camera camera, System.Int32 submeshIndex) { }
/// <summary> /// Copies data from the structure to a Unity position and rotation class /// </summary> /// <param name="pos">Position data to copy into</param> /// <param name="rot">Rotation data to copy into</param> /// public void CopyTo(ref UnityEngine.Vector3 pos, ref UnityEngine.Quaternion rot) { pos.x = px; pos.y = py; pos.z = pz; rot.x = qx; rot.y = qy; rot.z = qz; rot.w = qw; }
public static void DrawMesh(UnityEngine.Mesh mesh, UnityEngine.Vector3 position, UnityEngine.Quaternion rotation, UnityEngine.Material material, System.Int32 layer) { }
public static void Test_Quat_Generic_Vector_Multiplication_Against_Unity(float a, float b, float c, float d) { //arrange Quaternion<float> genericQuat = new Quaternion<float>(a, b, c, d); Vector3<float> genericVec3 = new Vector3<float>(b, c, d); //arrange UnityEngine.Quaternion unityQuat = new UnityEngine.Quaternion(a, b, c, d); UnityEngine.Vector3 unityVec3 = new UnityEngine.Vector3(b, c, d); //act Vector3<float> genericResultVec3 = genericQuat.RotateVector(genericVec3); UnityEngine.Vector3 unityResultVec3 = unityQuat * unityVec3; //assert for (int i = 0; i < 3; i++) //for Vector3 I rewrote the code so that it mostly matched UnityEngine after JIT values, not that I looked at the JIT compiled code but the values matched //after changing it. However, for some reason these do not line up like before. Operator overloads aren't equivalent to methods and something is happening //to make this not equivalent even though it's the same exact floating point math C# code. Assert.AreEqual(genericResultVec3[i], unityResultVec3[i], Math.Abs((((int)unityResultVec3[i]) * Vector3<float>.kEpsilon))); }
public static void DrawMesh(UnityEngine.Mesh mesh, UnityEngine.Vector3 position, UnityEngine.Quaternion rotation, UnityEngine.Material material, System.Int32 layer, UnityEngine.Camera camera, System.Int32 submeshIndex, UnityEngine.MaterialPropertyBlock properties, System.Boolean castShadows, System.Boolean receiveShadows) { }
public static void Test_Quat_Generic_QuatAndQuat_Multiplication_Against_Unity(float a, float b, float c, float d, float e, float f) { float g = (float)(new Random(System.DateTime.UtcNow.Millisecond).NextDouble()); //arrange Quaternion<float> genericQuatOne = new Quaternion<float>(a, b, c, d); Quaternion<float> genericQuatTwo = new Quaternion<float>(d, e, f, g); UnityEngine.Quaternion unityQuatTwo = new UnityEngine.Quaternion(d, e, f, g); UnityEngine.Quaternion unityQuatOne = new UnityEngine.Quaternion(a, b, c, d); //act Quaternion<float> genericResult = genericQuatOne.MultiplyBy(genericQuatTwo); UnityEngine.Quaternion unityResult = unityQuatOne * unityQuatTwo; //assert for (int i = 0; i < 4; i++)//for some reason this works with precision. Maybe too much floating point math in the vector one. Assert.AreEqual(genericResult[i], unityResult[i]); }
public static void DrawMesh(UnityEngine.Mesh mesh, UnityEngine.Vector3 position, UnityEngine.Quaternion rotation) { }
public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Quaternion val) { val = new UnityEngine.Quaternion(); int top = LuaAPI.lua_gettop(L); if (Utils.LoadField(L, idx, "x")) { translator.Get(L, top + 1, out val.x); } LuaAPI.lua_pop(L, 1); if (Utils.LoadField(L, idx, "y")) { translator.Get(L, top + 1, out val.y); } LuaAPI.lua_pop(L, 1); if (Utils.LoadField(L, idx, "z")) { translator.Get(L, top + 1, out val.z); } LuaAPI.lua_pop(L, 1); if (Utils.LoadField(L, idx, "w")) { translator.Get(L, top + 1, out val.w); } LuaAPI.lua_pop(L, 1); }
public static void DrawMesh(UnityEngine.Mesh mesh, UnityEngine.Vector3 position, UnityEngine.Quaternion rotation, System.Int32 materialIndex) { }
/// <summary> /// Translation from basic BSEngine Types to UnityEnginge Types /// </summary> /// <param name="obj">Object to transfrom</param> /// <returns>Object with translated type</returns> private static object BSEngineToUnity(object obj) { if (obj.GetType() == typeof(BSEngine.Math.Vector2)) { BSEngine.Math.Vector2 bse = (BSEngine.Math.Vector2)obj; UnityEngine.Vector2 v2 = new UnityEngine.Vector2(bse.x, bse.y); return v2; } else if (obj.GetType() == typeof(BSEngine.Math.Vector3)) { BSEngine.Math.Vector3 bse = (BSEngine.Math.Vector3)obj; UnityEngine.Vector3 v3 = new UnityEngine.Vector3(bse.x, bse.y, bse.z); return v3; } else if (obj.GetType() == typeof(BSEngine.Math.Vector4)) { BSEngine.Math.Vector4 bse = (BSEngine.Math.Vector4)obj; UnityEngine.Vector4 v4 = new UnityEngine.Vector4(bse.x, bse.y, bse.z, bse.w); return v4; } else if (obj.GetType() == typeof(BSEngine.Math.Quaternion)) { BSEngine.Math.Quaternion bse = (BSEngine.Math.Quaternion)obj; UnityEngine.Quaternion q = new UnityEngine.Quaternion(bse.x, bse.y, bse.z, bse.w); return q; } else { return null; } }
private void ProcessAssets() { Logger.Info("Process Assets..."); Dictionary <Transform, UnityEngine.Transform> tfLookup = new Dictionary <Transform, UnityEngine.Transform>(); Dictionary <UnityEngine.Transform, Transform> tfLookup2 = new Dictionary <UnityEngine.Transform, Transform>(); foreach (var assetsFile in assetsFileList) { foreach (var obj in assetsFile.Objects) { if (obj is GameObject m_GameObject) { //unity parse UnityEngine.GameObject go = new UnityEngine.GameObject(); go.name = m_GameObject.m_Name; var goCmp = go.AddComponent <DumpedGameObject>(); goCmp.m_PathID = obj.m_PathID; foreach (var pptr in m_GameObject.m_Components) { if (pptr.TryGet(out var m_Component)) { switch (m_Component) { case Transform m_Transform: m_GameObject.m_Transform = m_Transform; //unity parse Vector3 v1 = m_Transform.m_LocalPosition; Quaternion v2 = m_Transform.m_LocalRotation; Vector3 v3 = m_Transform.m_LocalScale; go.transform.localPosition = new UnityEngine.Vector3(v1.X, v1.Y, v1.Z); go.transform.localRotation = new UnityEngine.Quaternion(v2.X, v2.Y, v2.Z, v2.W); go.transform.localScale = new UnityEngine.Vector3(v3.X, v3.Y, v3.Z); tfLookup.Add(m_Transform, go.transform); tfLookup2.Add(go.transform, m_Transform); break; case MeshRenderer m_MeshRenderer: m_GameObject.m_MeshRenderer = m_MeshRenderer; //unity parse var meshRenderer = go.AddComponent <UnityEngine.MeshRenderer>(); meshRenderer.sharedMaterials = m_MeshRenderer.UnityMaterials; break; case MeshFilter m_MeshFilter: m_GameObject.m_MeshFilter = m_MeshFilter; //unity parse var filter = go.AddComponent <UnityEngine.MeshFilter>(); { if (m_MeshFilter.m_Mesh.TryGet(out var mesh)) { filter.sharedMesh = mesh.UnityMesh; } } break; case SkinnedMeshRenderer m_SkinnedMeshRenderer: m_GameObject.m_SkinnedMeshRenderer = m_SkinnedMeshRenderer; var skinnedMeshRenderer = go.AddComponent <UnityEngine.SkinnedMeshRenderer>(); { if (m_SkinnedMeshRenderer.m_Mesh.TryGet(out var mesh)) { skinnedMeshRenderer.sharedMesh = mesh.UnityMesh; } skinnedMeshRenderer.sharedMaterials = m_SkinnedMeshRenderer.UnityMaterials; } break; case Animator m_Animator: m_GameObject.m_Animator = m_Animator; var animator = go.AddComponent <UnityEngine.Animator>(); break; case Animation m_Animation: m_GameObject.m_Animation = m_Animation; var animation = go.AddComponent <UnityEngine.Animation>(); break; case MonoBehaviour m_MonoBehaviour: var cmp = go.AddComponent <DumpedBehaviour>(); if (m_MonoBehaviour.m_Script.TryGet(out var script)) { if (!string.IsNullOrEmpty(script.m_Namespace)) { cmp.m_ScriptName = string.Format("{0}.{1}.{2}", script.m_AssemblyName, script.m_Namespace, script.m_ClassName); } else { cmp.m_ScriptName = string.Format("{0}.{2}", script.m_AssemblyName, script.m_Namespace, script.m_ClassName); } cmp.m_ClassName = script.m_ClassName; cmp.m_PathID = m_MonoBehaviour.m_PathID; var type = m_MonoBehaviour.ToType(); if (type == null) { var nodes = m_MonoBehaviour.TypeTreeNodes; type = m_MonoBehaviour.ToType(nodes); } var str = JsonConvert.SerializeObject(type, Formatting.Indented); cmp.m_DumpedJson = str; } else { cmp.m_ScriptName = "null"; } break; default: break; } } } } else if (obj is SpriteAtlas m_SpriteAtlas) { foreach (var m_PackedSprite in m_SpriteAtlas.m_PackedSprites) { if (m_PackedSprite.TryGet(out var m_Sprite)) { if (m_Sprite.m_SpriteAtlas.IsNull) { m_Sprite.m_SpriteAtlas.Set(m_SpriteAtlas); } } } } } } foreach (var item in tfLookup2) { var unityTf = item.Key; var parsedTf = item.Value; if (parsedTf.m_Father.TryGet(out var father)) { UnityEngine.Vector3 pre1 = unityTf.transform.localPosition; UnityEngine.Quaternion pre2 = unityTf.transform.localRotation; UnityEngine.Vector3 pre3 = unityTf.transform.localScale; unityTf.parent = tfLookup[father]; unityTf.localPosition = pre1; unityTf.localRotation = pre2; unityTf.localScale = pre3; } } }