private void SetupDrillSensor(VRageMath.Matrix fromReference, int id, VRageMath.BoundingBox bb) { // grid size in meters per block float gridSize = sensors[id].CubeGrid.GridSize; // matrix from grid coordinate system to sensor coordinate system VRageMath.Matrix toSensor = new VRageMath.Matrix(); sensors[id].Orientation.GetMatrix(out toSensor); // matrix is orthogonal => transposed matrix = inversed matrix VRageMath.Matrix.Transpose(ref toSensor, out toSensor); VRageMath.Vector3[] corners = bb.GetCorners(); VRageMath.Vector3 diffMax = corners[1] - sensors[id].Position; VRageMath.Vector3 diffMin = corners[7] - sensors[id].Position; List <VRageMath.Vector3> .Enumerator enumerator = XUtils.Directions.GetEnumerator(); while (enumerator.MoveNext()) { VRageMath.Vector3 dir = enumerator.Current; VRageMath.Vector3 gridDir = VRageMath.Vector3.Transform(dir, fromReference); float lengthToMax = (diffMax * gridDir).Max(); float lengthToMin = (diffMin * gridDir).Max(); float offset = Sensors.getOffset(VRageMath.Vector3.Transform(gridDir, toSensor)); float value = _astroidDetectSize + (Math.Max(lengthToMax, lengthToMin) + offset) * gridSize; value = Math.Max(Math.Min(value, sensors.Max), sensors.Min); sensors.Extend(dir, id, value); } }
public void Update(float updateStepTime) { VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyCamera-Update"); Zoom.Update(updateStepTime); VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); Vector3 newCameraPosOffset = Vector3.Zero; // spring if (CameraSpring.Enabled) { CameraSpring.Update(updateStepTime, out newCameraPosOffset); } // shake if (CameraShake.ShakeEnabled) { Vector3 shakePos, shakeDir; CameraShake.UpdateShake(updateStepTime, out shakePos, out shakeDir); newCameraPosOffset += shakePos; } // apply if (newCameraPosOffset != Vector3.Zero) { Vector3D newCameraPosOffsetD = newCameraPosOffset; Vector3D newCameraPosOffsetRotatedD; Vector3D.Rotate(ref newCameraPosOffsetD, ref ViewMatrix, out newCameraPosOffsetRotatedD); ViewMatrix.Translation += newCameraPosOffsetRotatedD; } UpdatePropertiesInternal(ViewMatrix); }
public void Extend(VRageMath.Vector3 dir, int id, float value) { if (!XUtils.Directions.Contains(dir)) { throw new Exception("Invalid direction vector used: " + dir); } if (id < 0 || id >= CountSensors) { throw new Exception("Parameter id (= " + id + ") out of range [" + 0 + ", " + CountSensors + ")."); } if (value < Min || value > Max) { throw new Exception("Parameter value (= " + value + ") out of range [" + Min + ", " + Max + "]."); } IMySensorBlock sensor = sensorBlocks[id]; VRageMath.Matrix toSensor; sensor.Orientation.GetMatrix(out toSensor); VRageMath.Matrix.Transpose(ref toSensor, out toSensor); VRageMath.Matrix toGrid; referenceBlock.Orientation.GetMatrix(out toGrid); VRageMath.Vector3.Transform(ref dir, ref toGrid, out dir); VRageMath.Vector3.Transform(ref dir, ref toSensor, out dir); string propteryId = extendDirections[dir]; sensor.SetValue(propteryId, value); }
public BindableVector3DModel(VRageMath.Vector3 vector) : this() { X = vector.X; Y = vector.Y; Z = vector.Z; }
private float GetRotate(VRageMath.Vector3 axis) { if (!XUtils.Directions.Contains(axis)) { throw new Exception("Invalid axis vector used: " + axis); } VRageMath.Matrix local = new VRageMath.Matrix(); referenceBlock.Orientation.GetMatrix(out local); axis = VRageMath.Vector3.Transform(axis, local); float totalValue = 0; for (int i = 0; i < gyroscopeBlocks.Count; ++i) { IMyGyro gyro = gyroscopeBlocks[i] as IMyGyro; gyro.Orientation.GetMatrix(out local); VRageMath.Matrix toGyro = VRageMath.Matrix.Transpose(local); VRageMath.Vector3 transformedAxis = VRageMath.Vector3.Transform(axis, toGyro); GyroAction action = GyroAction.getActionAroundAxis(transformedAxis); float value = gyro.GetValue <float>(action.Name); totalValue += action.Reversed ? -value : value; } return(totalValue); }
public void UpdateThrusters(List <IMyTerminalBlock> blocks) { thrusterBlocks = new Dictionary <VRageMath.Vector3, List <IMyThrust> >(); VRageMath.Matrix toReference = new VRageMath.Matrix(); referenceBlock.Orientation.GetMatrix(out toReference); VRageMath.Matrix.Transpose(ref toReference, out toReference); VRageMath.Matrix tmp = new VRageMath.Matrix(); for (int i = 0; i < blocks.Count; ++i) { IMyTerminalBlock block = blocks[i]; if (block is IMyThrust) { block.Orientation.GetMatrix(out tmp); // The exhaust is directed to the Forward vector of the thruster, so it accelerates to Backward. VRageMath.Vector3 dir = VRageMath.Vector3.Transform(tmp.Backward, toReference); if (!thrusterBlocks.ContainsKey(dir)) { thrusterBlocks[dir] = new List <IMyThrust>(); } thrusterBlocks[dir].Add(block as IMyThrust); } } if (thrusterBlocks.Count == 0) { throw new Exception("There is no thruster within the given block list."); } }
/// <summary> /// Calculates a transformation matrix to transform grid coordinates to world coordinates. /// </summary> /// <param name="blocks"></param> /// <returns></returns> public static VRageMath.Matrix toWorld(List <IMyCubeBlock> blocks) { if (blocks == null) { throw new Exception("The block list is null"); } if (blocks.Count < 3) { throw new Exception("Need at least 3 blocks."); } IMyCubeBlock origin = blocks[0]; VRageMath.Vector3 localCoord = origin.Position; // first basis vector VRageMath.Vector3 u = blocks[1].Position - localCoord; // second basis vector int vIndex = 2; VRageMath.Vector3 v = blocks[vIndex].Position - localCoord; while (u.Dot(v) * u.Dot(v) == u.LengthSquared() * v.LengthSquared() && vIndex < blocks.Count) { v = blocks[++vIndex].Position - localCoord; } if (u.Dot(v) * u.Dot(v) == u.LengthSquared() + v.LengthSquared()) { throw new Exception("All blocks are linear dependent => It's not possible to calculate a transformation matrix."); } debug.Append("choose: ").Append(u).Append(v).AppendLine(); VRageMath.Matrix localBasis = VRageMath.Matrix.CreateWorld(localCoord, u, v); VRageMath.Vector3 worldCoord = origin.GetPosition(); // world basis depending on the local bases (same coordinates) VRageMath.Vector3 ug = blocks[1].GetPosition() - worldCoord; VRageMath.Vector3 vg = blocks[vIndex].GetPosition() - worldCoord; VRageMath.Matrix worldBasis = VRageMath.Matrix.CreateWorld(worldCoord, ug, vg); VRageMath.Matrix inverseLocalBasis; // if local basis is orthogonal, take the transposed matrix, because then // the transposed and the inverse matrix are the same and it's obviously // easier to get the transposed matrix. if (VRageMath.Vector3.ArePerpendicular(ref u, ref v)) { inverseLocalBasis = VRageMath.Matrix.Transpose(localBasis); } else { inverseLocalBasis = VRageMath.Matrix.Invert(localBasis); } return(inverseLocalBasis * worldBasis); }
public static double DistanceFrom(this VRageMath.Vector3 start, VRageMath.Vector3 end) { var x = Math.Pow(end.X - start.X, 2); var y = Math.Pow(end.Y - start.Y, 2); var z = Math.Pow(end.Z - start.Z, 2); return(Math.Abs(Math.Sqrt(x + y + z))); }
/// <summary> /// Calculates a transformation matrix to transform grid coordinates to world coordinates. /// </summary> /// <param name="blocks"></param> /// <returns></returns> public static VRageMath.Matrix ToWorld(List <IMyCubeBlock> blocks) { if (blocks == null) { throw new Exception("The block list is null"); } if (blocks.Count < 3) { throw new Exception("Need at least 3 blocks."); } IMyCubeBlock origin = blocks[0]; VRageMath.Vector3 localCoord = origin.Position; // first basis vector VRageMath.Vector3 u = blocks[1].Position - localCoord; // second basis vector int vIndex = 2; VRageMath.Vector3 v = blocks[vIndex].Position - localCoord; // TODO use an epsilon value instead of 0, because of the precision error of floating point multiplication. while (u.Dot(v) == 0 && vIndex < blocks.Count) { v = blocks[++vIndex].Position - localCoord; } if (u.Dot(v) == 0) { throw new Exception("All blocks are linear dependent => It's not possible to calculate a transformation matrix."); } VRageMath.Matrix localBasis = VRageMath.Matrix.CreateWorld(localCoord, u, v); VRageMath.Vector3 worldCoord = origin.GetPosition(); // world basis depending on the local bases (same coordinates) VRageMath.Vector3 ug = blocks[1].GetPosition() - worldCoord; VRageMath.Vector3 vg = blocks[vIndex].GetPosition() - worldCoord; VRageMath.Matrix worldBasis = VRageMath.Matrix.CreateWorld(worldCoord, ug, vg); VRageMath.Matrix inverseLocalBasis; // if local basis is orthogonal, take the transposed matrix, because then // the transposed and the inverse matrix are the same and it's obviously // easier to get the transposed matrix. if (VRageMath.Vector3.ArePerpendicular(ref u, ref v)) { inverseLocalBasis = VRageMath.Matrix.Transpose(localBasis); } else { inverseLocalBasis = VRageMath.Matrix.Invert(localBasis); } return(inverseLocalBasis * worldBasis); }
void IMyEntity.SetColorMaskForSubparts(VRageMath.Vector3 colorMaskHsv) { if (Subparts != null) { foreach (var subPart in Subparts) { subPart.Value.Render.ColorMaskHsv = colorMaskHsv; } } }
public void Handle(DrillEvent e) { Action <DrillEvent> action; if (_stateBehavior.TryGetValue(_state, out action)) { action(e); } _lastTime = DateTime.Now; _lastWorldPosition = ReferenceBlock.GetPosition(); }
/* * private void thumbnailToolStripMenuItem_Click(object sender, EventArgs e) * { * TreeNode node = SectorTree.SelectedNode; * CubeGrid cg = (CubeGrid)node.Tag; * pictureBox1.Image = cg.getThumbnail(); * } * * private void loggingCheck_CheckedChanged(object sender, EventArgs e) * { * loggingEnabled = loggingCheck.Checked; * } */ private void importModuleToolStripMenuItem_Click(object sender, EventArgs e) { TreeNode node = SectorTree.SelectedNode; CubeGrid cg = (CubeGrid)node.Tag; DialogResult result = fileopen.ShowDialog(); if (result == DialogResult.OK) { this.update_status("Importing Module"); string filename = fileopen.FileName; string xml = File.ReadAllText(filename); CubeGrid module = sector.loadCGFragment(xml, false); CubeBlock module_attachment_point = module.getBlock("LargeBlockArmorCornerInvWhite"); if (module_attachment_point != null) { //Console.WriteLine("Got module attachment"); TreeNode main_node = SectorTree.SelectedNode; CubeGrid main = (CubeGrid)main_node.Tag; CubeBlock main_attachment_point = main.getBlock("LargeBlockArmorCornerInvWhite"); if (main_attachment_point != null) { Console.WriteLine("Before rotation!!"); VRageMath.Vector3 diff = Sector.diff_orientation(main_attachment_point, module_attachment_point); //Console.WriteLine("Got module attachment"); //Console.WriteLine("Up :" + main_attachment_point.PositionAndOrientation.up.ToString() + " " + module_attachment_point.PositionAndOrientation.up.ToString()); //Console.WriteLine("Forward :" + main_attachment_point.PositionAndOrientation.forward.ToString() + " " + module_attachment_point.PositionAndOrientation.forward.ToString()); module.reOrient(module_attachment_point); //Console.WriteLine("module attachment point after reorient: "+module_attachment_point.PositionAndOrientation.position.ToString()); main.reOrient(main_attachment_point); //lets try some rotation Console.WriteLine("Steps: " + vrageMath.AngleToSteps(diff.X) + " " + vrageMath.AngleToSteps(diff.Y) + " " + vrageMath.AngleToSteps(diff.Z)); module.rotate_grid("X", vrageMath.AngleToSteps(diff.X)); module.rotate_grid("Y", vrageMath.AngleToSteps(diff.Y)); module.rotate_grid("Z", vrageMath.AngleToSteps(diff.Z)); Console.WriteLine("After rotation!!"); diff = Sector.diff_orientation(module_attachment_point, main_attachment_point); main.merge(module); SectorTree.Nodes.Clear(); SectorTree.Nodes.Add(sector.getTreeNode()); } } else { Console.WriteLine("Couldn't get module attachment"); } } this.update_status(""); }
public Drill(IMyShipController reference, float drillVelocity = 1.5f, float asteroidDetectSize = 1.5f, float epsilon = 0.1f) : base(reference) { _state = _uninitializedState; _lastWorldPosition = reference.GetPosition(); _stateBehavior[_uninitializedState] = UpdateUninitialized; _stateBehavior[_standbyState] = UpdateStandby; _stateBehavior[_searchState] = UpdateSearch; _stateBehavior[_drillState] = UpdateDrill; _drillVelocity = drillVelocity; _astroidDetectSize = asteroidDetectSize; _epsilon = epsilon; }
private void StopDrilling() { for (int i = 0; i < _drills.Count; ++i) { IMyShipDrill block = _drills[i]; block.GetActionWithName("OnOff_Off").Apply(block); } for (int i = 0; i < XUtils.Directions.Count; ++i) { VRageMath.Vector3 dir = XUtils.Directions[i]; thrusts.SetThrustersEnabled(dir, true); thrusts.Accelerate(dir, thrusts.DefaultAcceleration); } }
internal void AddSphereRing(BoundingSphere sphere, Color color, Matrix onb) { float increment = 1.0f / 32; for (float i = 0; i < 1; i += increment) { float a0 = 2 * (float)Math.PI * i; float a1 = 2 * (float)Math.PI * (i + increment); Add( Vector3.Transform(new Vector3(Math.Cos(a0), 0, Math.Sin(a0)) * sphere.Radius, onb) + sphere.Center, Vector3.Transform(new Vector3(Math.Cos(a1), 0, Math.Sin(a1)) * sphere.Radius, onb) + sphere.Center, color); } }
internal void AddQuad(Vector3 v0, Vector3 v1, Vector3 v2, Vector3 v3, Color color) { var bcolor = new Byte4(color.R, color.G, color.B, color.A); Add(new MyVertexFormatPositionColor(v0, bcolor)); Add(new MyVertexFormatPositionColor(v1, bcolor)); Add(new MyVertexFormatPositionColor(v1, bcolor)); Add(new MyVertexFormatPositionColor(v2, bcolor)); Add(new MyVertexFormatPositionColor(v2, bcolor)); Add(new MyVertexFormatPositionColor(v3, bcolor)); Add(new MyVertexFormatPositionColor(v3, bcolor)); Add(new MyVertexFormatPositionColor(v0, bcolor)); }
void IPrimitiveManagerBase.GetPrimitiveBox(int prim_index, out AABB primbox) { BoundingBox bbox = BoundingBox.CreateInvalid(); Vector3 v1 = GetVertex(Triangles[prim_index].I0); Vector3 v2 = GetVertex(Triangles[prim_index].I1); Vector3 v3 = GetVertex(Triangles[prim_index].I2); bbox.Include( ref v1, ref v2, ref v3); primbox = new AABB() { m_min = bbox.Min.ToBullet(), m_max = bbox.Max.ToBullet() }; }
public static void CalculateRotation(ref VRageMath.Vector3 a, ref VRageMath.Vector3 b, out VRageMath.Matrix rotation) { if (!VRageMath.Vector3.IsUnit(ref a)) { a.Normalize(); } if (!VRageMath.Vector3.IsUnit(ref b)) { b.Normalize(); } VRageMath.Vector3 v = a.Cross(b); float s = v.Length(); // sine float c = a.Dot(b); // cosine VRageMath.Matrix cross = Utils.CreateSkewSymmetricMatrix(v); rotation = Identity + cross + cross * cross * (1 - c) / s; }
public void SetThrustersEnabled(VRageMath.Vector3 dir, bool value) { if (!thrusterBlocks.ContainsKey(dir)) { throw new Exception("Warning! No thruster in direction " + dir + "."); } var list = thrusterBlocks[dir]; for (int i = 0; i < list.Count; ++i) { IMyThrust block = list[i]; if (block.Enabled ^ value) { block.GetActionWithName("OnOff").Apply(block); } } }
public bool AreThrustersEnabled(VRageMath.Vector3 dir) { if (!thrusterBlocks.ContainsKey(dir)) { throw new Exception("Warning! No thruster in direction " + dir + "."); } bool enabled = false; var list = thrusterBlocks[dir]; int i = 0; while (!enabled && i < list.Count) { enabled |= list[i].Enabled; i++; } return(enabled); }
public void ApplyAction(VRageMath.Vector3 dir, string name) { if (!XUtils.Directions.Contains(dir)) { throw new Exception("Invalid direction vector used: " + dir); } VRageMath.Matrix local = new VRageMath.Matrix(); referenceBlock.Orientation.GetMatrix(out local); dir = VRageMath.Vector3.Transform(dir, local); var list = thrusterBlocks[dir]; for (int i = 0; i < list.Count; ++i) { IMyThrust thruster = list[i]; thruster.GetActionWithName(name).Apply(thruster); } }
/// <summary> /// Accelerates the ship relative to the reference block. /// </summary> /// <param name="dir">The direction relative to the reference block in which the ship should be accelerated.</param> /// <param name="value">The amount of force to accelerate in Newton.</param> public void Accelerate(VRageMath.Vector3 dir, float value) { if ((value < MinAcceleration || value > MaxAcceleration) && value != DefaultAcceleration) { throw new Exception("Value '" + value + "' out of range [" + MinAcceleration + ", " + MaxAcceleration + "] + " + DefaultAcceleration + "."); } if (!thrusterBlocks.ContainsKey(dir)) { throw new Exception("Warning! No thruster in direction " + dir + "."); } var list = thrusterBlocks[dir]; for (int i = 0; i < list.Count; ++i) { IMyThrust thruster = list[i]; thruster.SetValueFloat("Override", value); } }
internal void AddCone(Vector3 translation, Vector3 directionVec, Vector3 baseVec, int tessalation, Color color) { var axis = directionVec; axis.Normalize(); var apex = translation + directionVec; var steps = tessalation; var stepsRcp = (float)(Math.PI * 2 / steps); for (int i = 0; i < 32; i++) { float a0 = i * stepsRcp; float a1 = (i + 1) * stepsRcp; var A = translation + Vector3.Transform(baseVec, Matrix.CreateFromAxisAngle(axis, a0)); var B = translation + Vector3.Transform(baseVec, Matrix.CreateFromAxisAngle(axis, a1)); Add(A, B, color); Add(A, apex, color); } }
public void UpdateBlocks(List <IMyTerminalBlock> list) { gyros = new List <IMyGyro>(); thrusters = new Dictionary <VRageMath.Vector3, List <IMyThrust> >(); VRageMath.Matrix tmp = new VRageMath.Matrix(); for (int i = 0; i < list.Count; ++i) { var block = list[i]; if (block is IMyGyro) { IMyGyro gyro = (IMyGyro)block; if (gyros.Count == 0) { gyroRotateMin = gyro.GetMininum <float>(GyroAction.Pitch.GetName()); gyroRotateMax = gyro.GetMaximum <float>(GyroAction.Pitch.GetName()); } gyros.Add(gyro); } else if (block is IMyThrust) { IMyThrust thruster = block as IMyThrust; if (thrusters.Count == 0) { thrusterOverrideMin = thruster.GetMininum <float>("Override"); thrusterOverrideMax = thruster.GetMaximum <float>("Override"); } block.Orientation.GetMatrix(out tmp); // The exhaust is directed to the Forward vector of the thruster, so it accelerates to Backward. VRageMath.Vector3 dir = tmp.Backward; if (!thrusters.ContainsKey(dir)) { thrusters[dir] = new List <IMyThrust>(); } thrusters[dir].Add(thruster); } } }
public int GetClosestSensor(VRageMath.Vector3 point, List <int> exclude) { if (sensorBlocks.Count == 0) { throw new Exception("Cannot get the closest sensor, because there exists no sensor."); } int i = 0; while (exclude.Contains(i) && i < CountSensors) { ++i; } if (i == CountSensors) { return(i); } int id = i; float dist2NearestBlock = (sensorBlocks[i].Position - point).LengthSquared(); for (; i < sensorBlocks.Count; ++i) { if (exclude.Contains(i)) { continue; } float dist2 = (sensorBlocks[i].Position - point).LengthSquared(); if (dist2 < dist2NearestBlock) { id = i; dist2NearestBlock = dist2; } } return(id); }
/// <summary> /// Rotates the ship relative to the reference block. /// A positive Yaw value rotates around the Up vector, such that the Right vector is moved to the Backward vector on the shortest way. /// A positive Pitch value rotates around the Right vector, such that the Up vector is moved to the Backward vector on the shortest way. /// A positive Roll value rotates around the Backward vector, such that the Up vector is moved to the Right vector on the shortest way. /// </summary> /// <param name="axis"></param> /// <param name="value"></param> private void Rotate(VRageMath.Vector3 axis, float value) { if (value < Min || value > Max) { throw new Exception("Value '" + value + "' out of range [" + Min + ", " + Max + "]."); } VRageMath.Matrix local = new VRageMath.Matrix(); referenceBlock.Orientation.GetMatrix(out local); axis = VRageMath.Vector3.Transform(axis, local); for (int i = 0; i < gyroscopeBlocks.Count; ++i) { IMyGyro gyro = gyroscopeBlocks[i] as IMyGyro; gyro.Orientation.GetMatrix(out local); VRageMath.Matrix toGyro = VRageMath.Matrix.Transpose(local); VRageMath.Vector3 transformedAxis = VRageMath.Vector3.Transform(axis, toGyro); GyroAction action = GyroAction.getActionAroundAxis(transformedAxis); gyro.SetValue(action.Name, action.Reversed ? -value : value); } }
/// <summary> /// Rotates the ship relative to the reference block. /// A positive Yaw value rotates around the Up vector, such that the Right vector is moved to the Backward vector on the shortest way. /// A positive Pitch value rotates around the Right vector, such that the Up vector is moved to the Backward vector on the shortest way. /// A positive Roll value rotates around the Backward vector, such that the Up vector is moved to the Right vector on the shortest way. /// </summary> /// <param name="axis"></param> /// <param name="value"></param> public void Rotate(VRageMath.Vector3 axis, float value) { if (value < gyroRotateMin || value > gyroRotateMax) { throw new Exception("Value out of range [" + gyroRotateMin + ", " + gyroRotateMax + "]."); } VRageMath.Matrix local = new VRageMath.Matrix(); referenceBlock.Orientation.GetMatrix(out local); axis = VRageMath.Vector3.Transform(axis, local); for (int i = 0; i < gyros.Count; ++i) { IMyGyro gyro = gyros[i] as IMyGyro; gyro.Orientation.GetMatrix(out local); VRageMath.Matrix toGyro = VRageMath.Matrix.Transpose(local); VRageMath.Vector3 transformedAxis = VRageMath.Vector3.Transform(axis, toGyro); GyroAction action = gyroActions[transformedAxis]; gyro.SetValue(action.GetName(), action.Reversed ? -value : value); } }
/// <summary> /// Accelerates the ship relative to the reference block. /// </summary> /// <param name="dir">The direction relative to the reference block in which the ship should be accelerated.</param> /// <param name="value">The amount of force to accelerate in Newton.</param> public void Accelerate(VRageMath.Vector3 dir, float value) { if (value < thrusterOverrideMin || value > thrusterOverrideMax) { throw new Exception("Value out of range [" + thrusterOverrideMin + ", " + thrusterOverrideMax + "]."); } VRageMath.Matrix local = new VRageMath.Matrix(); referenceBlock.Orientation.GetMatrix(out local); dir = VRageMath.Vector3.Transform(dir, local); if (!thrusters.ContainsKey(dir)) { throw new Exception("Warning! No thruster in direction " + dir + "."); } var list = thrusters[dir]; for (int i = 0; i < list.Count; ++i) { IMyThrust thruster = list[i]; thruster.SetValueFloat("Override", value); } }
// Sends input (keyboard/mouse) to screen which has focus (top-most) public void HandleInputAfterSimulation() { if (MySession.Static != null) { bool cameraControllerMovementAllowed = MyScreenManager.GetScreenWithFocus() == MyGuiScreenGamePlay.Static && MyGuiScreenGamePlay.Static != null && !MyScreenManager.InputToNonFocusedScreens; bool lookAroundEnabled = MyInput.Static.IsGameControlPressed(MyControlsSpace.LOOKAROUND) || (MySession.Static.ControlledEntity != null && MySession.Static.ControlledEntity.PrimaryLookaround); //After respawn, the controlled object might be null bool shouldStopControlledObject = MySession.Static.ControlledEntity != null && (!cameraControllerMovementAllowed && m_cameraControllerMovementAllowed != cameraControllerMovementAllowed); bool movementAllowedInPause = MySession.Static.GetCameraControllerEnum() == MyCameraControllerEnum.Spectator || MySession.Static.GetCameraControllerEnum() == MyCameraControllerEnum.SpectatorDelta || MySession.Static.GetCameraControllerEnum() == MyCameraControllerEnum.SpectatorFixed; bool rotationAllowedInPause = movementAllowedInPause; //GK: consider removing if in the future is not different from movementAllowed bool devScreenFlag = MyScreenManager.GetScreenWithFocus() is MyGuiScreenDebugBase && !MyInput.Static.IsAnyAltKeyPressed(); MyCameraControllerEnum cce = MySession.Static.GetCameraControllerEnum(); float rollIndicator = MyInput.Static.GetRoll(); Vector2 rotationIndicator = MyInput.Static.GetRotation(); VRageMath.Vector3 moveIndicator = MyInput.Static.GetPositionDelta(); var focusScreen = MyScreenManager.GetScreenWithFocus(); if (MySandboxGame.IsPaused && focusScreen is MyGuiScreenGamePlay) { if (!movementAllowedInPause && !rotationAllowedInPause) { return; } if (!movementAllowedInPause) { moveIndicator = VRageMath.Vector3.Zero; } if (!rotationAllowedInPause || devScreenFlag) { rollIndicator = 0.0f; rotationIndicator = Vector2.Zero; } MySession.Static.CameraController.Rotate(rotationIndicator, rollIndicator); } else if (lookAroundEnabled) { if (cameraControllerMovementAllowed) { //Then move camera (because it can be dependent on control object) MySession.Static.CameraController.Rotate(rotationIndicator, rollIndicator); if (!m_lookAroundEnabled && shouldStopControlledObject) { MySession.Static.ControlledEntity.MoveAndRotateStopped(); } } if (shouldStopControlledObject) { MySession.Static.CameraController.RotateStopped(); } } //Hack to make spectators work until they are made entities else if (MySession.Static.CameraController is MySpectatorCameraController && MySpectatorCameraController.Static.SpectatorCameraMovement == MySpectatorCameraMovementEnum.ConstantDelta) { if (cameraControllerMovementAllowed) { MySpectatorCameraController.Static.MoveAndRotate(moveIndicator, rotationIndicator, rollIndicator); } } if (shouldStopControlledObject) { MySession.Static.ControlledEntity.MoveAndRotateStopped(); } m_cameraControllerMovementAllowed = cameraControllerMovementAllowed; m_lookAroundEnabled = lookAroundEnabled; } }
void Main() { // initialize var blocks = new List <IMyTerminalBlock>(); if (counter == 0) { GridTerminalSystem.GetBlocksOfType <IMyShipController>(blocks, FilterShipController); if (blocks.Count == 0) { throw new Exception("Did not find any cockpit."); } controller = blocks[0] as IMyShipController; debug.Append("use ").Append(controller.CustomName).Append(':').AppendLine(); perpBlocks = Utils.FindPerpendicularTo(controller); ship = new ShipController(controller); worldCoord = controller.GetPosition(); debug.Append("POSITION = ").Append(worldCoord).AppendLine(); Debug(debug.ToString()); debug.Clear(); counter++; return; } worldCoord = new VRageMath.Vector3D(0, 0, 0); bool orthogonal = perpBlocks.Count == 3; VRageMath.Matrix toWorld = orthogonal ? Utils.toWorld(GridTerminalSystem.Blocks) : Utils.toWorld(perpBlocks); blocks = new List <IMyTerminalBlock>(); GridTerminalSystem.GetBlocksOfType <IMyThrust>(blocks); GridTerminalSystem.GetBlocksOfType <IMyGyro>(blocks); debug.Append("worldCoord = ").Append(VRageMath.Vector3I.Round(worldCoord)).AppendLine(); debug.Append("controller.GetPosition() = ").Append(VRageMath.Vector3I.Round(controller.GetPosition())).AppendLine(); debug.Append("controller.Position = ").Append(controller.Position).AppendLine(); debug.Append("transfrom controller.Position = ").Append(VRageMath.Vector3I.Round(VRageMath.Vector3.Transform(controller.Position, toWorld))).AppendLine(); debug.Append("transfrom controller.Position = ").Append(VRageMath.Vector3I.Round(VRageMath.Vector3.Transform(controller.GetPosition(), VRageMath.Matrix.Invert(toWorld)))).AppendLine(); VRageMath.Vector3 worldDir = worldCoord - controller.GetPosition(); float distance = worldDir.LengthSquared() > 0 ? worldDir.Normalize() : 0; debug.Append("distance = ").Append(distance).AppendLine(); debug.Append("direction = ").Append(worldDir).AppendLine(); VRageMath.Matrix worldController = new VRageMath.Matrix(); controller.Orientation.GetMatrix(out worldController); worldController = worldController * toWorld; debug.Append("worldController = ").AppendLine(); debug.Append(worldController.Right).AppendLine(); debug.Append(worldController.Up).AppendLine(); debug.Append(worldController.Backward).AppendLine(); debug.Append(worldController.Translation).AppendLine(); debug.Append("origin worldController = ").Append(VRageMath.Vector3I.Round(VRageMath.Vector3.Transform(new VRageMath.Vector3(), worldController))).AppendLine(); //VRageMath.Vector3 n = orthogonal ? worldController.Right : worldController.Up.Cross(worldController.Backward); //VRageMath.Vector3 projDir = worldDir - worldDir.Dot(n) / n.Dot(n) * n; //if (projDir.LengthSquared() > 0) // projDir.Normalize(); //VRageMath.Vector3 eY = worldController.Up; //eY.Normalize(); //VRageMath.Vector3 eZ = worldController.Backward; //eZ.Normalize(); //float cosinePhiY = eY.Dot(projDir); //float cosinePhiZ = eZ.Dot(projDir); //float pitch = (float)(cosinePhiY > 0 ? -Math.Acos(cosinePhiZ) : Math.Acos(cosinePhiZ)); ////VRageMath.Matrix.AlignRotationToAxes(); //debug.Append("pitch = ").Append(pitch).AppendLine(); debug.Append("worldController.IsRotation() = ").Append(worldController.IsRotation()); VRageMath.Matrix toAlign = VRageMath.Matrix.CreateFromDir(worldDir, worldController.Up); VRageMath.Matrix align = VRageMath.Matrix.AlignRotationToAxes(ref toAlign, ref worldController); VRageMath.Vector3 xyz = new VRageMath.Vector3(); VRageMath.Matrix.GetEulerAnglesXYZ(ref align, out xyz); xyz = 0.1f * xyz; debug.Append(xyz).AppendLine(); ship.UpdateBlocks(blocks); ship.Stop(); ship.Rotate(Identity.Left, xyz.GetDim(0)); ship.Rotate(Identity.Down, xyz.GetDim(1)); ship.Rotate(Identity.Forward, xyz.GetDim(2)); Debug(debug.ToString()); debug.Clear(); }
internal void Add6FacedConvex(Vector3 [] vertices, Color color) { AddQuad(vertices[0], vertices[1], vertices[2], vertices[3], color); AddQuad(vertices[4], vertices[5], vertices[6], vertices[7], color); AddQuad(vertices[0], vertices[1], vertices[5], vertices[4], color); AddQuad(vertices[0], vertices[3], vertices[7], vertices[4], color); AddQuad(vertices[3], vertices[2], vertices[6], vertices[7], color); AddQuad(vertices[2], vertices[1], vertices[5], vertices[6], color); }
public void LoadAnimationData() { if (m_loadedData) return; lock (this) { VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyModel::LoadAnimationData"); MyLog.Default.WriteLine("MyModel.LoadData -> START", LoggingOptions.LOADING_MODELS); MyLog.Default.IncreaseIndent(LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("m_assetName: " + m_assetName, LoggingOptions.LOADING_MODELS); // Read data from model TAG parameter. There are stored vertex positions, triangle indices, vectors, ... everything we need. VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Model - load data - import data"); MyLog.Default.WriteLine(String.Format("Importing asset {0}, path: {1}", m_assetName, AssetName), LoggingOptions.LOADING_MODELS); try { m_importer.ImportData(AssetName); } catch { MyLog.Default.WriteLine(String.Format("Importing asset failed {0}", m_assetName)); throw; } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Model - load data - load tag data"); Dictionary<string, object> tagData = m_importer.GetTagData(); Debug.Assert(tagData.Count != 0, String.Format("Uncompleted tagData for asset: {0}, path: {1}", m_assetName, AssetName)); if (tagData.Count != 0) { DataVersion = m_importer.DataVersion; Animations = (ModelAnimations)tagData[MyImporterConstants.TAG_ANIMATIONS]; Bones = (MyModelBone[])tagData[MyImporterConstants.TAG_BONES]; BoundingBox = (BoundingBox)tagData[MyImporterConstants.TAG_BOUNDING_BOX]; BoundingSphere = (BoundingSphere)tagData[MyImporterConstants.TAG_BOUNDING_SPHERE]; BoundingBoxSize = BoundingBox.Max - BoundingBox.Min; BoundingBoxSizeHalf = BoundingBoxSize / 2.0f; Dummies = tagData[MyImporterConstants.TAG_DUMMIES] as Dictionary<string, MyModelDummy>; BoneMapping = tagData[MyImporterConstants.TAG_BONE_MAPPING] as VRageMath.Vector3I[]; if (BoneMapping.Length == 0) BoneMapping = null; } else { DataVersion = 0; Animations = null; Bones = null; BoundingBox = default(BoundingBox); BoundingSphere = default(BoundingSphere); BoundingBoxSize = default(Vector3); BoundingBoxSizeHalf = default(Vector3); Dummies = null; BoneMapping = null; } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); ModelInfo = new MyModelInfo(GetTrianglesCount(), GetVerticesCount(), BoundingBoxSize); if (tagData.Count != 0) m_loadedData = true; MyLog.Default.DecreaseIndent(LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("MyModel.LoadAnimationData -> END", LoggingOptions.LOADING_MODELS); VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); } }
// Sort of lazy-load, where constructor just saves information about what this model should be, but real load is done here - and only one time. // This loads only vertex data, doesn't touch GPU // Can be called from main and background thread public void LoadData() { if (m_loadedData) return; lock (this) { VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyModel::LoadData"); MyLog.Default.WriteLine("MyModel.LoadData -> START", LoggingOptions.LOADING_MODELS); MyLog.Default.IncreaseIndent(LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("m_assetName: " + m_assetName, LoggingOptions.LOADING_MODELS); // Read data from model TAG parameter. There are stored vertex positions, triangle indices, vectors, ... everything we need. VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Model - load data - import data"); MyLog.Default.WriteLine(String.Format("Importing asset {0}, path: {1}", m_assetName, AssetName), LoggingOptions.LOADING_MODELS); string assetForImport = AssetName; var fsPath = Path.IsPathRooted(AssetName) ? AssetName : Path.Combine(MyFileSystem.ContentPath, AssetName); if (!MyFileSystem.FileExists(fsPath)) { assetForImport = @"Models\Debug\Error.mwm"; } try { m_importer.ImportData(assetForImport); } catch { MyLog.Default.WriteLine(String.Format("Importing asset failed {0}", m_assetName)); VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); throw; } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); DataVersion = m_importer.DataVersion; VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Model - load data - load tag data"); Dictionary<string, object> tagData = m_importer.GetTagData(); if (tagData.Count == 0) { VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); throw new Exception(String.Format("Uncompleted tagData for asset: {0}, path: {1}", m_assetName, AssetName)); } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Model - load data - vertex, normals, texture coords"); HalfVector4[] vertices = (HalfVector4[])tagData[MyImporterConstants.TAG_VERTICES]; System.Diagnostics.Debug.Assert(vertices.Length > 0); Byte4[] normals = (Byte4[])tagData[MyImporterConstants.TAG_NORMALS]; m_vertices = new MyCompressedVertexNormal[vertices.Length]; if (normals.Length > 0) { for (int v = 0; v < vertices.Length; v++) { m_vertices[v] = new MyCompressedVertexNormal() { Position = vertices[v],// VF_Packer.PackPosition(ref vertices[v]), Normal = normals[v]//VF_Packer.PackNormalB4(ref normals[v]) }; } } else { for (int v = 0; v < vertices.Length; v++) { m_vertices[v] = new MyCompressedVertexNormal() { Position = vertices[v],// VF_Packer.PackPosition(ref vertices[v]), }; } } m_verticesCount = vertices.Length; VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Model - load data - mesh"); var materials = new Dictionary<string, MyMeshMaterial>(); m_meshContainer.Clear(); if (tagData.ContainsKey(MyImporterConstants.TAG_MESH_PARTS)) { List<int> indices = new List<int>(GetVerticesCount()); // Default capacity estimation int maxIndex = 0; List<MyMeshPartInfo> meshParts = tagData[MyImporterConstants.TAG_MESH_PARTS] as List<MyMeshPartInfo>; foreach (MyMeshPartInfo meshPart in meshParts) { MyMesh mesh = new MyMesh(meshPart, m_assetName); mesh.IndexStart = indices.Count; mesh.TriCount = meshPart.m_indices.Count / 3; if (mesh.Material.Name != null) materials.Add(mesh.Material.Name, mesh.Material); if (m_loadUV && false == m_hasUV) { m_texCoords = (HalfVector2[])tagData[MyImporterConstants.TAG_TEXCOORDS0]; m_hasUV = true; m_loadUV = false; } if (meshPart.m_MaterialDesc != null && meshPart.Technique == MyMeshDrawTechnique.GLASS) { GlassData = mesh; HalfVector2[] forLoadingTexCoords0 = (HalfVector2[])tagData[MyImporterConstants.TAG_TEXCOORDS0]; List<HalfVector2> neededTexCoords = new List<HalfVector2>(); for (int t = 0; t < meshPart.m_indices.Count; t++) { int index = meshPart.m_indices[t]; neededTexCoords.Add(forLoadingTexCoords0[index]); } GlassTexCoords = neededTexCoords.ToArray(); } System.Diagnostics.Debug.Assert(mesh.TriCount > 0); if (mesh.TriCount == 0) { VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); return; } foreach (var i in meshPart.m_indices) { indices.Add(i); if (i > maxIndex) { maxIndex = i; } } m_meshContainer.Add(mesh); } if (maxIndex <= ushort.MaxValue) { // create 16 bit indices m_Indices_16bit = new ushort[indices.Count]; for (int i = 0; i < indices.Count; i++) { m_Indices_16bit[i] = (ushort)indices[i]; } } else { // use 32bit indices m_Indices = indices.ToArray(); } } m_meshSections.Clear(); if (tagData.ContainsKey(MyImporterConstants.TAG_MESH_SECTIONS)) { List<MyMeshSectionInfo> sections = tagData[MyImporterConstants.TAG_MESH_SECTIONS] as List<MyMeshSectionInfo>; int sectionindex = 0; foreach (MyMeshSectionInfo sectinfo in sections) { MyMeshSection section = new MyMeshSection() { Name = sectinfo.Name, Index = sectionindex }; m_meshSections.Add(section.Name, section); sectionindex++; } } if (tagData.ContainsKey(MyImporterConstants.TAG_MODEL_BVH)) { m_bvh = new MyQuantizedBvhAdapter(tagData[MyImporterConstants.TAG_MODEL_BVH] as GImpactQuantizedBvh, this); } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Model - load data - other data"); Animations = (ModelAnimations)tagData[MyImporterConstants.TAG_ANIMATIONS]; Bones = (MyModelBone[])tagData[MyImporterConstants.TAG_BONES]; BoundingBox = (BoundingBox)tagData[MyImporterConstants.TAG_BOUNDING_BOX]; BoundingSphere = (BoundingSphere)tagData[MyImporterConstants.TAG_BOUNDING_SPHERE]; BoundingBoxSize = BoundingBox.Max - BoundingBox.Min; BoundingBoxSizeHalf = BoundingBoxSize / 2.0f; Dummies = tagData[MyImporterConstants.TAG_DUMMIES] as Dictionary<string, MyModelDummy>; BoneMapping = tagData[MyImporterConstants.TAG_BONE_MAPPING] as VRageMath.Vector3I[]; if (tagData.ContainsKey(MyImporterConstants.TAG_MODEL_FRACTURES)) ModelFractures = (MyModelFractures)tagData[MyImporterConstants.TAG_MODEL_FRACTURES]; object patternScale; if (tagData.TryGetValue(MyImporterConstants.TAG_PATTERN_SCALE, out patternScale)) { PatternScale = (float)patternScale; } if (BoneMapping.Length == 0) BoneMapping = null; if (tagData.ContainsKey(MyImporterConstants.TAG_HAVOK_COLLISION_GEOMETRY)) { HavokData = (byte[])tagData[MyImporterConstants.TAG_HAVOK_COLLISION_GEOMETRY]; byte[] tagCollisionData = (byte[])tagData[MyImporterConstants.TAG_HAVOK_COLLISION_GEOMETRY]; if (tagCollisionData.Length > 0 && HkBaseSystem.IsThreadInitialized) { bool containsSceneData; bool containsDestructionData; List<HkShape> shapesList = new List<HkShape>(); if (!HkShapeLoader.LoadShapesListFromBuffer(tagCollisionData, shapesList, out containsSceneData, out containsDestructionData)) { MyLog.Default.WriteLine(string.Format("Model {0} - Unable to load collision geometry", AssetName), LoggingOptions.LOADING_MODELS); //Debug.Fail("Collision model was exported in wrong way: " + m_assetName); } if (shapesList.Count > 10) MyLog.Default.WriteLine(string.Format("Model {0} - Found too many collision shapes, only the first 10 will be used", AssetName), LoggingOptions.LOADING_MODELS); if (HavokCollisionShapes != null) { Debug.Fail("Shapes already loaded"); } if (shapesList.Count > 0) { HavokCollisionShapes = shapesList.ToArray(); } else { MyLog.Default.WriteLine(string.Format("Model {0} - Unable to load collision geometry from file, default collision will be used !", AssetName)); } if (containsDestructionData) HavokDestructionData = tagCollisionData; ExportedWrong = !containsSceneData; } } if (tagData.ContainsKey(MyImporterConstants.TAG_HAVOK_DESTRUCTION)) { if (((byte[])tagData[MyImporterConstants.TAG_HAVOK_DESTRUCTION]).Length > 0) HavokDestructionData = (byte[])tagData[MyImporterConstants.TAG_HAVOK_DESTRUCTION]; } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Model - load data - copy triangle indices"); // Prepare data CopyTriangleIndices(); m_trianglesCount = Triangles.Length; // Remember this numbers as list may be cleared at the end of this method VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); MyLog.Default.WriteLine("Triangles.Length: " + Triangles.Length, LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("Vertexes.Length: " + GetVerticesCount(), LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("Centered: " + (bool)tagData[MyImporterConstants.TAG_CENTERED], LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("UseChannelTextures: " + (bool)tagData[MyImporterConstants.TAG_USE_CHANNEL_TEXTURES], LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("Length in meters: " + (float)tagData[MyImporterConstants.TAG_LENGTH_IN_METERS], LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("Rescale to length in meters?: " + (bool)tagData[MyImporterConstants.TAG_RESCALE_TO_LENGTH_IN_METERS], LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("BoundingBox: " + BoundingBox, LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("BoundingSphere: " + BoundingSphere, LoggingOptions.LOADING_MODELS); VRage.Utils.Stats.PerAppLifetime.MyModelsCount++; VRage.Utils.Stats.PerAppLifetime.MyModelsMeshesCount += m_meshContainer.Count; VRage.Utils.Stats.PerAppLifetime.MyModelsVertexesCount += GetVerticesCount(); VRage.Utils.Stats.PerAppLifetime.MyModelsTrianglesCount += Triangles.Length; ModelInfo = new MyModelInfo(GetTrianglesCount(), GetVerticesCount(), BoundingBoxSize); m_loadedData = true; m_loadingErrorProcessed = false; MyLog.Default.DecreaseIndent(LoggingOptions.LOADING_MODELS); MyLog.Default.WriteLine("MyModel.LoadData -> END", LoggingOptions.LOADING_MODELS); VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); } }
public void GetVertex(int vertexIndex1, int vertexIndex2, int vertexIndex3, out Vector3 v1, out Vector3 v2, out Vector3 v3) { v1 = GetVertex(vertexIndex1); v2 = GetVertex(vertexIndex2); v3 = GetVertex(vertexIndex3); }
internal void Add(Vector3 from, Vector3 to, Color colorFrom, Color? colorTo = null) { List.Add(new MyVertexFormatPositionColor(from, new Byte4(colorFrom.PackedValue))); List.Add(new MyVertexFormatPositionColor(to, colorTo.HasValue ? new Byte4(colorTo.Value.PackedValue) : new Byte4(colorFrom.PackedValue))); }