public Box(AnimatTools.Framework.DataObject doParent) : base(doParent) { m_vGraphicsBoxSize = new Vec3d(this); m_vGraphicsBoxSize.X = m_vGraphicsBoxSize.Y = m_vGraphicsBoxSize.Z = 1; m_snWidth = new AnimatTools.Framework.ScaledNumber(this, "WidthScaled", "meters", "m"); m_snHeight = new AnimatTools.Framework.ScaledNumber(this, "HeightScaled", "meters", "m"); m_snLength = new AnimatTools.Framework.ScaledNumber(this, "LengthScaled", "meters", "m"); m_vrSize = new DxBoxSizeRef(this); }
/// <summary> /// Replace Y value /// </summary> /// <param name="v3"></param> /// <param name="y"></param> /// <returns></returns> public static Vec3d SetY(this Vec3d v3, decimal y) { return(new Vec3d(v3.X, y, v3.Z)); }
/// <summary> /// Calculate the square of the distance between two 3D coordinates. /// </summary> /// <param name="v1">The first 3D coordinate.</param> /// <param name="v2">The second 3D coordinate.</param> /// <returns>The square of the distance between the given points.</returns> /// <!-- /// vec3d.c /// double _pointSquareDist /// --> internal static decimal PointSquareDistance(this Vec3d v1, Vec3d v2) { return((v1.X - v2.X).Square() + (v1.Y - v2.Y).Square() + (v1.Z - v2.Z).Square()); }
public override bool OnHeldInteractStep(float secondsUsed, ItemSlot slot, EntityAgent byEntity, BlockSelection blockSel, EntitySelection entitySel) { if (blockSel == null) { return(false); } ILiquidMetalSink be = byEntity.World.BlockAccessor.GetBlockEntity(blockSel.Position) as ILiquidMetalSink; if (be == null) { return(false); } if (!be.CanReceiveAny) { return(false); } KeyValuePair <ItemStack, int> contents = GetContents(byEntity.World, slot.Itemstack); if (!be.CanReceive(contents.Key)) { return(false); } float speed = 1.5f; float temp = GetTemperature(byEntity.World, slot.Itemstack); if (byEntity.World is IClientWorldAccessor) { ModelTransform tf = new ModelTransform(); tf.EnsureDefaultValues(); tf.Origin.Set(0.5f, 0.2f, 0.5f); tf.Translation.Set(0, 0, -Math.Min(0.25f, speed * secondsUsed / 4)); tf.Scale = 1f + Math.Min(0.25f, speed * secondsUsed / 4); tf.Rotation.X = Math.Max(-110, -secondsUsed * 90 * speed); byEntity.Controls.UsingHeldItemTransformBefore = tf; } IPlayer byPlayer = null; if (byEntity is EntityPlayer) { byPlayer = byEntity.World.PlayerByUid(((EntityPlayer)byEntity).PlayerUID); } if (secondsUsed > 1 / speed) { if ((int)(30 * secondsUsed) % 3 == 1) { Vec3d pos = byEntity.Pos.XYZ .Ahead(0.1f, byEntity.Pos.Pitch, byEntity.Pos.Yaw) .Ahead(1.0f, byEntity.Pos.Pitch, byEntity.Pos.Yaw - GameMath.PIHALF) ; pos.Y += byEntity.EyeHeight - 0.4f; smokePouring.minPos = pos.AddCopy(-0.15, -0.15, -0.15); Vec3d blockpos = blockSel.Position.ToVec3d().Add(0.5, 0.2, 0.5); bigMetalSparks.minQuantity = Math.Max(0.2f, 1 - (secondsUsed - 1) / 4); if ((int)(30 * secondsUsed) % 7 == 1) { bigMetalSparks.minPos = pos; bigMetalSparks.minVelocity.Set(-2, -1, -2); bigMetalSparks.addVelocity.Set(4, 1, 4); byEntity.World.SpawnParticles(bigMetalSparks, byPlayer); byEntity.World.SpawnParticles(smokePouring, byPlayer); } float y2 = 0; Block block = byEntity.World.BlockAccessor.GetBlock(blockSel.Position); Cuboidf[] collboxs = block.GetCollisionBoxes(byEntity.World.BlockAccessor, blockSel.Position); for (int i = 0; collboxs != null && i < collboxs.Length; i++) { y2 = Math.Max(y2, collboxs[i].Y2); } // Metal Spark on the mold bigMetalSparks.minVelocity.Set(-2, 1, -2); bigMetalSparks.addVelocity.Set(4, 5, 4); bigMetalSparks.minPos = blockpos.AddCopy(-0.25, y2 - 2 / 16f, -0.25); bigMetalSparks.addPos.Set(0.5, 0, 0.5); bigMetalSparks.glowLevel = (byte)GameMath.Clamp((int)temp - 770, 48, 128); byEntity.World.SpawnParticles(bigMetalSparks, byPlayer); // Smoke on the mold byEntity.World.SpawnParticles( Math.Max(1, 12 - (secondsUsed - 1) * 6), ColorUtil.ToRgba(50, 220, 220, 220), blockpos.AddCopy(-0.5, y2 - 2 / 16f, -0.5), blockpos.Add(0.5, y2 - 2 / 16f + 0.15, 0.5), new Vec3f(-0.5f, 0f, -0.5f), new Vec3f(0.5f, 0f, 0.5f), 1.5f, -0.05f, 0.75f, EnumParticleModel.Quad, byPlayer ); } int transferedAmount = Math.Min(2, contents.Value); be.ReceiveLiquidMetal(contents.Key, ref transferedAmount, temp); int newAmount = Math.Max(0, contents.Value - (2 - transferedAmount)); slot.Itemstack.Attributes.SetInt("units", newAmount); if (newAmount <= 0 && byEntity.World is IServerWorldAccessor) { slot.Itemstack = new ItemStack(byEntity.World.GetBlock(new AssetLocation(CodeWithoutParts(1) + "-burned"))); slot.MarkDirty(); // Since we change the item stack we have to call this ourselves OnHeldInteractStop(secondsUsed, slot, byEntity, blockSel, entitySel); return(false); } return(true); } return(true); }
public static void ScaleMesh(Mesh d3dMesh, Vec3d vSize) { ScaleMesh(d3dMesh, (float) vSize.X, (float) vSize.Y, (float) vSize.Z); }
protected override void CalculateDistanceFromCamera() { Vector3 v3Tmp = this.Worldlocation; v3Tmp.TransformCoordinate(CombinedTransformationMatrix * Device.Transform.World1); Vec3d dvTmp = new Vec3d(null, v3Tmp.X, v3Tmp.Y, v3Tmp.Z); this.m_fDistFromCamera = dvTmp.Distance(this.ParentStructure.BodyEditor.BodyView.CameraPosition); }
protected virtual void SelectPart(int iX, int iY) { if(Editor.PhysicalStructure.RootBody != null) { AnimatTools.DataObjects.Physical.BodyPart bpTmpSelected = null; System.Collections.ArrayList colSelected; //list of all elements selected bool bCurrentSelectedInList = false; //lets find which ones are selected colSelected = Editor.PhysicalStructure.TestIntersection(iX, iY, Editor.CommandBar.CommandMode); //find out which body is the closest one selected foreach (AnimatTools.DataObjects.Physical.BodyPart bpPart in colSelected) { if(this.Editor.PropertiesBar.SelectedPart != null && bpPart == this.Editor.PropertiesBar.SelectedPart) bCurrentSelectedInList = true; //got to have at least one body selected if we're in this loop if(bpTmpSelected == null) bpTmpSelected = bpPart; //if rbTmp is closer to the camera than the current selected one //change the current one to the selected one if(bpPart.IntersectionDistance < bpTmpSelected.IntersectionDistance) bpTmpSelected = bpPart; } if(Editor.CommandBar.CommandMode != AnimatTools.Forms.BodyPlan.Command.enumCommandMode.SelectReceptiveFields || this.Editor.PropertiesBar.SelectedPart == null || this.Editor.PropertiesBar.SelectedPart is AnimatTools.DataObjects.Physical.Joint) this.Editor.PropertiesBar.SelectPart(bpTmpSelected, this.IsCtrlKeyPressed); else { //If we are in receptive field mode and their is a selcted rigid body part then lets test to see if the user is attempting to //select one of the receptive fields. if(bCurrentSelectedInList) { RigidBodies.RigidBody_DX rbPart = (RigidBodies.RigidBody_DX ) this.Editor.PropertiesBar.SelectedPart; Vec3d vVertex = new Vec3d(null, 0,0,0); if(rbPart.TestReceptiveFieldIntersection(iX, iY, ref vVertex)) rbPart.SelectedReceptiveField = vVertex; else this.Editor.PropertiesBar.SelectPart(bpTmpSelected, this.IsCtrlKeyPressed); } else this.Editor.PropertiesBar.SelectPart(bpTmpSelected, this.IsCtrlKeyPressed); } } }
//float yawOffset; private void updateTargetPos() { float yaw = (float)Math.Atan2(targetEntity.ServerPos.X - entity.ServerPos.X, targetEntity.ServerPos.Z - entity.ServerPos.Z); /*tmpVec = tmpVec.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z); * tmpVec.Ahead(10, 0, yaw - GameMath.PI / 2); * * int tries = 10; * double dx, dy, dz; * while (tries-- > 0) * { * dx = rand.NextDouble() * 8 - 4; * dy = rand.NextDouble() * 8 - 4; * dz = rand.NextDouble() * 8 - 4; * * if (entity.Properties.Habitat == EnumHabitat.Land) * { * tmpVec.Y = moveDownToFloor((int)tmpVec.X, tmpVec.Y, (int)tmpVec.Z); * } * * tmpVec.Add(dx, dx, dz); * * pathTraverser.NavigateTo(targetPos, moveSpeed, 1, OnGoalReached, OnStuck, tries > 0, 999, true); * }*/ // Some simple steering behavior, works really suxy tmpVec = tmpVec.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z); tmpVec.Ahead(0.9, 0, yaw - GameMath.PI / 2); // Running into wall? if (traversable(tmpVec)) { //yawOffset = 0; targetPos.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z).Ahead(10, 0, yaw - GameMath.PI / 2); return; } // Try 90 degrees left tmpVec = tmpVec.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z); tmpVec.Ahead(0.9, 0, yaw - GameMath.PI); if (traversable(tmpVec)) { targetPos.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z).Ahead(10, 0, yaw - GameMath.PI); return; } // Try 90 degrees right tmpVec = tmpVec.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z); tmpVec.Ahead(0.9, 0, yaw); if (traversable(tmpVec)) { targetPos.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z).Ahead(10, 0, yaw); return; } // Run towards target o.O tmpVec = tmpVec.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z); tmpVec.Ahead(0.9, 0, -yaw); //if (traversable(tmpVec)) { targetPos.Set(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z).Ahead(10, 0, -yaw); return; } }
/// <summary> /// /// </summary> /// <param name="origin"></param> /// <param name="scale"></param> /// <param name="countX"></param> /// <param name="countY"></param> /// <param name="countZ"></param> /// <param name="wrapModeX"></param> /// <param name="wrapModeY"></param> /// <param name="wrapModeZ"></param> /// <param name="sampleMode"></param> public GridScalarField3d(Vec3d origin, Vec3d scale, int countX, int countY, int countZ, WrapMode wrapModeX, WrapMode wrapModeY, WrapMode wrapModeZ, SampleMode sampleMode = SampleMode.Linear) : base(origin, scale, countX, countY, countZ, wrapModeX, wrapModeY, wrapModeZ, sampleMode) { }
public override bool OnHeldInteractStep(float secondsUsed, ItemSlot slot, EntityAgent byEntity, BlockSelection blockSel, EntitySelection entitySel) { if (blockSel == null) { return(false); } if (slot.Itemstack.TempAttributes.GetInt("refilled") > 0) { return(false); } float prevsecondsused = slot.Itemstack.TempAttributes.GetFloat("secondsUsed"); slot.Itemstack.TempAttributes.SetFloat("secondsUsed", secondsUsed); float remainingwater = GetRemainingWateringSeconds(slot.Itemstack); SetRemainingWateringSeconds(slot.Itemstack, remainingwater -= secondsUsed - prevsecondsused); if (remainingwater <= 0) { return(false); } IWorldAccessor world = byEntity.World; BlockPos targetPos = blockSel.Position; Block facingBlock = world.BlockAccessor.GetBlock(blockSel.Position.AddCopy(blockSel.Face)); if (facingBlock.Code.Path == "fire") { world.BlockAccessor.SetBlock(0, blockSel.Position.AddCopy(blockSel.Face)); } Block block = world.BlockAccessor.GetBlock(blockSel.Position); bool notOnSolidblock = false; if ((block.CollisionBoxes == null || block.CollisionBoxes.Length == 0) && !block.IsLiquid()) { notOnSolidblock = true; targetPos = targetPos.DownCopy(); } BlockEntityFarmland be = world.BlockAccessor.GetBlockEntity(targetPos) as BlockEntityFarmland; if (be != null) { be.WaterFarmland(secondsUsed - prevsecondsused); } float speed = 4f; if (world.Side == EnumAppSide.Client) { ModelTransform tf = new ModelTransform(); tf.EnsureDefaultValues(); tf.Origin.Set(0.5f, 0.2f, 0.5f); tf.Translation.Set(-Math.Min(0.25f, speed * secondsUsed / 4), 0, 0); tf.Rotation.Z = GameMath.Min(60, secondsUsed * 90 * speed, 80 - remainingwater * 5); byEntity.Controls.UsingHeldItemTransformBefore = tf; } IPlayer byPlayer = null; if (byEntity is EntityPlayer) { byPlayer = byEntity.World.PlayerByUid(((EntityPlayer)byEntity).PlayerUID); } if (secondsUsed > 1 / speed) { Vec3d pos = blockSel.Position.ToVec3d().Add(blockSel.HitPosition); if (notOnSolidblock) { pos.Y = (int)pos.Y + 0.05; } WaterParticles.minPos = pos.Add(-0.125 / 2, 1 / 16f, -0.125 / 2); byEntity.World.SpawnParticles(WaterParticles, byPlayer); } return(true); }
/// <summary> /// /// </summary> /// <param name="r0"></param> /// <param name="r1"></param> /// <param name="p0"></param> /// <param name="p1"></param> public void Set(Vec3d p0, Vec3d p1) { _delta = p1 - p0; }
/// <summary> /// /// </summary> /// <param name="i0"></param> /// <param name="i1"></param> /// <param name="p0"></param> /// <param name="r0"></param> /// <param name="p1"></param> /// <param name="r1"></param> /// <param name="weight"></param> public Translation(int i0, int i1, Vec3d p0, Vec3d p1, double weight = 1.0) : this(i0, i1) { Set(p0, p1); }
/// <inheritdoc /> public sealed override void GradientAt(Vec3d point, out double gx, out double gy, out double gz) { throw new NotImplementedException(); }
public abstract Vec3f GetVelocity(Vec3d pos);
public static Mesh CreateBox(Microsoft.DirectX.Direct3D.Device d3dDevice, Vec3d vSize) { return CreateBox(d3dDevice, (float) vSize.X, (float) vSize.Y, (float) vSize.Z); }
/// <summary> /// /// </summary> /// <param name="point"></param> /// <returns></returns> public Vec3d GradientAt(Vec3d point) { // TODO throw new NotImplementedException(); }
/// <summary> /// /// </summary> /// <param name="point"></param> /// <param name="scale"></param> /// <returns></returns> public static double Box(Vec3d point, Vec3d scale) { var d = Vec3d.Abs(point) - scale; return(Math.Min(d.ComponentMax, 0.0) + Vec3d.Min(d, 0.0).Length); }
/// <summary> /// /// </summary> /// <param name="acceleration"></param> /// <param name="capacity"></param> /// <param name="strength"></param> public FalseWeight(int index, Vec3d acceleration, double strength = 1.0) { _handle.Index = index; _acceleration = acceleration; Strength = strength; }
private void ribbonButton51_Click(object sender, EventArgs e) { if (featurePrimitiveLineString == null) { LineStringGeometry lineString = new LineStringGeometry(); Vec3d vec3d1 = new Vec3d(); vec3d1.set(-74, 40.714, 0); Vec3d vec3d2 = new Vec3d(); vec3d2.set(139.75, 35.68, 0); lineString.push_back(vec3d1); lineString.push_back(vec3d2); Feature feature = new Feature(); feature.setGeometry( lineString ); featurePrimitiveLineString = new FeaturePrimitive(); featurePrimitiveLineString.setFeature( feature ); m_earthRoot.addChild( featurePrimitiveLineString ); } }
public override void FinishExecute(bool cancelled) { base.FinishExecute(cancelled); targetPos = null; pathTraverser.Stop(); }
public override void SaveData(ref AnimatTools.DataObjects.Simulation dsSim, ref AnimatTools.DataObjects.Physical.PhysicalStructure doStructure, ref AnimatTools.Interfaces.StdXml oXml) { base.SaveData (ref dsSim, ref doStructure, ref oXml); oXml.IntoElem(); if(!oXml.FindChildElement("Constraint", false)) oXml.AddChildElement("Constraint"); oXml.IntoElem(); oXml.SetAttrib("Low",this.m_fltMinMovement); oXml.SetAttrib("High", this.m_fltMaxMovement); oXml.OutOfElem(); oXml.AddChildElement("Length", m_fltLength); oXml.AddChildElement("EnableMotor",this.m_bEnableMotor); oXml.AddChildElement("ServoMotor",this.m_bServoMotor); oXml.AddChildElement("ServoGain",this.m_fltServoGain); m_snMaxForce.SaveData(ref oXml, "MaxForce"); m_snMaxVelocity.SaveData(ref oXml, "MaxVelocity"); RigidBodies.RigidBody_DX rbParent = (RigidBodies.RigidBody_DX)this.Parent; Vector3 v3Rot = Util_DX.DecomposeXYZRotationMatrix(this.CombinedTransformationMatrix);; float x = Geometry.DegreeToRadian(180); m_v3Axis.TransformCoordinate(Matrix.RotationX(Geometry.DegreeToRadian(180)) * Matrix.RotationY(Geometry.DegreeToRadian(180)) * Matrix.RotationZ(Geometry.DegreeToRadian(180)) * Matrix.RotationX(v3Rot.X)* Matrix.RotationY(v3Rot.Y) * Matrix.RotationZ(v3Rot.Z)); Vec3d vRotationAxis = new Vec3d(null,m_v3Axis.X, m_v3Axis.Y, m_v3Axis.Z); Util.SaveVector(ref oXml, "RotationAxis", vRotationAxis); m_v3Axis = new Vector3(0,0,1); oXml.OutOfElem(); }
/// <summary> /// Performs the physics on the specified entity. /// </summary> /// <param name="dt"></param> /// <param name="pos"></param> public void DoPhysics(float dt, EntityPos pos) { Vec3d motionBefore = pos.Motion.Clone(); bool feetInLiquidBefore = entity.FeetInLiquid; bool onGroundBefore = entity.OnGround; bool swimmingBefore = entity.Swimming; bool onCollidedBefore = entity.Collided; float dtFac = 60 * dt; Block belowBlock = entity.World.BlockAccessor.GetBlock((int)pos.X, (int)(pos.Y - 0.05f), (int)pos.Z); // On ground drag if (entity.OnGround) { if (!entity.FeetInLiquid) { pos.Motion.X *= (1 - groundDragFactor * belowBlock.DragMultiplier); pos.Motion.Z *= (1 - groundDragFactor * belowBlock.DragMultiplier); } } // Water or air drag if (entity.FeetInLiquid || entity.Swimming) { pos.Motion *= (float)Math.Pow(waterDragValue, dt * 33); } else { pos.Motion *= (float)Math.Pow(airDragValue, dt * 33); } Block inblock = entity.World.BlockAccessor.GetBlock((int)pos.X, (int)(pos.Y), (int)pos.Z); Block aboveblock = entity.World.BlockAccessor.GetBlock((int)pos.X, (int)(pos.Y + 1), (int)pos.Z); if (entity.FeetInLiquid) { Vec3d pushvec = inblock.PushVector; if (pushvec != null) { float pushstrength = 0.3f * 1000f / GameMath.Clamp(entity.MaterialDensity, 750, 2500) * dtFac; pos.Motion.Add( pushvec.X * pushstrength, pushvec.Y * pushstrength, pushvec.Z * pushstrength ); } } // Gravity if (pos.Y > -100 && entity.ApplyGravity) { double gravStrength = gravityPerSecond / 60f * dtFac + Math.Max(0, -0.015f * pos.Motion.Y * dtFac); if (entity.Swimming) { // above 0 => floats // below 0 => sinks float baseboyancy = GameMath.Clamp(1 - entity.MaterialDensity / inblock.MaterialDensity, -1, 1); float waterY = (int)pos.Y + inblock.LiquidLevel / 8f + (aboveblock.IsLiquid() ? 9 / 8f : 0); float bottomSubmergedness = waterY - (float)pos.Y; // 0 = at swim line // 1 = completely submerged float swimlineSubmergedness = GameMath.Clamp(bottomSubmergedness - (entity.CollisionBox.Y2 - (float)entity.SwimmingOffsetY), 0, 1); double boyancyStrength = GameMath.Clamp(60 * baseboyancy * swimlineSubmergedness, -1.5f, 1.5f) - 1; double waterDrag = GameMath.Clamp(100 * Math.Abs(pos.Motion.Y * dtFac) - 0.02f, 1, 1.25f); pos.Motion.Y += gravStrength * boyancyStrength; pos.Motion.Y /= waterDrag; } else { pos.Motion.Y -= gravStrength; } } moveDelta.Set(pos.Motion.X * dtFac, pos.Motion.Y * dtFac, pos.Motion.Z * dtFac); nextPosition.Set(pos.X + moveDelta.X, pos.Y + moveDelta.Y, pos.Z + moveDelta.Z); bool falling = pos.Motion.Y < 0; entity.World.CollisionTester.ApplyTerrainCollision(entity, pos, dtFac, ref outposition); if (entity.World.BlockAccessor.IsNotTraversable((int)(pos.X + moveDelta.X), (int)pos.Y, (int)pos.Z)) { outposition.X = pos.X; } if (entity.World.BlockAccessor.IsNotTraversable((int)pos.X, (int)(pos.Y + moveDelta.Y), (int)pos.Z)) { outposition.Y = pos.Y; } if (entity.World.BlockAccessor.IsNotTraversable((int)pos.X, (int)pos.Y, (int)(pos.Z + moveDelta.Z))) { outposition.Z = pos.Z; } entity.OnGround = entity.CollidedVertically && falling; pos.SetPos(outposition); if ((nextPosition.X < outposition.X && pos.Motion.X < 0) || (nextPosition.X > outposition.X && pos.Motion.X > 0)) { pos.Motion.X = 0; } if ((nextPosition.Y < outposition.Y && pos.Motion.Y < 0) || (nextPosition.Y > outposition.Y && pos.Motion.Y > 0)) { pos.Motion.Y = 0; } if ((nextPosition.Z < outposition.Z && pos.Motion.Z < 0) || (nextPosition.Z > outposition.Z && pos.Motion.Z > 0)) { pos.Motion.Z = 0; } Block block = entity.World.BlockAccessor.GetBlock(pos.XInt, pos.YInt, pos.ZInt); entity.FeetInLiquid = block.MatterState == EnumMatterState.Liquid; entity.InLava = block.LiquidCode == "lava"; if (entity.FeetInLiquid) { float waterY = (int)pos.Y + block.LiquidLevel / 8f + (aboveblock.IsLiquid() ? 9 / 8f : 0); float bottomSubmergedness = waterY - (float)pos.Y; // 0 = at swim line // 1 = completely submerged float swimlineSubmergedness = bottomSubmergedness - (entity.CollisionBox.Y2 - (float)entity.SwimmingOffsetY); entity.Swimming = swimlineSubmergedness > 0; } else { entity.Swimming = false; } if (!onCollidedBefore && entity.Collided) { entity.OnCollided(); } if (!onGroundBefore && entity.OnGround) { entity.OnFallToGround(motionBefore.Y); } if ((!entity.Swimming && !feetInLiquidBefore && entity.FeetInLiquid) || (!entity.FeetInLiquid && !swimmingBefore && entity.Swimming)) { entity.OnCollideWithLiquid(); } if (!falling || entity.OnGround) { entity.PositionBeforeFalling.Set(outposition); } if (GlobalConstants.OutsideWorld(pos.X, pos.Y, pos.Z, entity.World.BlockAccessor)) { entity.DespawnReason = new EntityDespawnReason() { reason = EnumDespawnReason.Death, damageSourceForDeath = new DamageSource() { Source = EnumDamageSource.Fall } }; return; } Cuboidd entityBox = entity.World.CollisionTester.entityBox; for (int y = (int)entityBox.Y1; y <= (int)entityBox.Y2; y++) { for (int x = (int)entityBox.X1; x <= (int)entityBox.X2; x++) { for (int z = (int)entityBox.Z1; z <= (int)entityBox.Z2; z++) { entity.World.CollisionTester.tmpPos.Set(x, y, z); entity.World.CollisionTester.tempCuboid.Set(x, y, z, x + 1, y + 1, z + 1); if (entity.World.CollisionTester.tempCuboid.IntersectsOrTouches(entityBox)) { entity.World.BlockAccessor.GetBlock(x, y, z).OnEntityInside(entity.World, entity, entity.World.CollisionTester.tmpPos); } } } } OnPhysicsTickCallback?.Invoke(dtFac); }
public override void SaveData(ref AnimatTools.DataObjects.Simulation dsSim, ref AnimatTools.DataObjects.Physical.PhysicalStructure doStructure, ref AnimatTools.Interfaces.StdXml oXml) { base.SaveData (ref dsSim, ref doStructure, ref oXml); oXml.IntoElem(); RigidBodies.RigidBody_DX rbParent = (RigidBodies.RigidBody_DX)this.Parent; Vector3 v3Rot = Util_DX.DecomposeXYZRotationMatrix(this.CombinedTransformationMatrix);; float x = Geometry.DegreeToRadian(180); if(!oXml.FindChildElement("Constraint", false)) oXml.AddChildElement("Constraint"); oXml.IntoElem(); oXml.SetAttrib("Low",this.m_fltMinAngle); oXml.SetAttrib("High", this.m_fltMaxAngle); oXml.OutOfElem(); oXml.AddChildElement("EnableMotor",this.m_bEnableMotor); oXml.AddChildElement("ServoMotor",this.m_bServoMotor); oXml.AddChildElement("ServoGain",this.m_fltServoGain); m_snMaxTorque.SaveData(ref oXml, "MaxTorque"); m_snMaxVelocity.SaveData(ref oXml, "MaxVelocity"); // if(v3Rot.Y >= 180) // m_v3Axis.TransformCoordinate(/*Matrix.RotationX(Geometry.DegreeToRadian(180))* Matrix.RotationY(Geometry.DegreeToRadian(180)) * Matrix.RotationZ(Geometry.DegreeToRadian(180)) **/ Matrix.RotationX(v3Rot.X)* Matrix.RotationY(v3Rot.Y) * Matrix.RotationZ(v3Rot.Z)); // else //m_v3Axis.TransformCoordinate(Matrix.RotationX(Geometry.DegreeToRadian(180)) * Matrix.RotationY(Geometry.DegreeToRadian(180)) * Matrix.RotationZ(Geometry.DegreeToRadian(180)) * Matrix.RotationX(v3Rot.X)* Matrix.RotationY(v3Rot.Y) * Matrix.RotationZ(v3Rot.Z)); Matrix m = this.CombinedTransformationMatrix; m.M41 = 0; m.M42 = 0; m.M43 = 0; //Quaternion q = Quaternion.RotationYawPitchRoll(v3Rot.Y, v3Rot.X, v3Rot.Z); //m_v3Axis.TransformCoordinate(Matrix.RotationQuaternion(q)); m_v3Axis.TransformCoordinate(m); //Vec3d vRotationAxis = new Vec3d(null,1, 0, 0); Vec3d vRotationAxis = new Vec3d(null,m_v3Axis.X, m_v3Axis.Y, m_v3Axis.Z); Util.SaveVector(ref oXml, "RotationAxis", vRotationAxis); oXml.OutOfElem(); m_v3Axis = new Vector3(0,0,1); }
/// <inheritdoc /> void IBody.ApplyTorque(Vec3d delta) { throw new NotSupportedException(_rotationErrorMessage); }
/// <inheritdoc /> public void Calculate(IReadOnlyList <IBody> bodies) { _handle.Delta = Vec3d.Reject(_start - bodies[_handle].Position, _direction); }
/// <inheritdoc /> void IBody.ApplyRotate(Vec3d delta, double weight) { throw new NotSupportedException(_rotationErrorMessage); }
public override void OnHeldInteractStart(ItemSlot slot, EntityAgent byEntity, BlockSelection blockSel, EntitySelection entitySel, bool firstEvent, ref EnumHandHandling handling) { if (blockSel != null) { if ((byEntity as EntityPlayer)?.Player != null && !api.World.Claims.TryAccess((byEntity as EntityPlayer)?.Player, blockSel.Position, EnumBlockAccessFlags.BuildOrBreak)) { return; } if (byEntity.Controls.Sprint) { handling = EnumHandHandling.PreventDefault; //if (byEntity.Api.Side == EnumAppSide.Client) return; ITreeAttribute start; Vec3d pos = blockSel.Position.ToVec3d(); if ((start = slot.Itemstack.TempAttributes.GetTreeAttribute("startPoint")) != null) { ITreeAttribute box = slot.Itemstack.Attributes.GetOrAddTreeAttribute("workArea"); box.SetDouble("x1", start.GetDouble("x1") > pos.X ? pos.X : start.GetDouble("x1")); box.SetDouble("y1", start.GetDouble("y1") > pos.Y ? pos.Y : start.GetDouble("y1")); box.SetDouble("z1", start.GetDouble("z1") > pos.Z ? pos.Z : start.GetDouble("z1")); box.SetDouble("x2", (start.GetDouble("x1") > pos.X ? start.GetDouble("x1") : pos.X) + 1); box.SetDouble("y2", (start.GetDouble("y1") > pos.Y ? start.GetDouble("y1") : pos.Y)); box.SetDouble("z2", (start.GetDouble("z1") > pos.Z ? start.GetDouble("z1") : pos.Z) + 1); slot.Itemstack.TempAttributes.RemoveAttribute("startPoint"); ((byEntity as EntityPlayer)?.Player as IServerPlayer)?.SendMessage(GlobalConstants.InfoLogChatGroup, Lang.Get("temporalhack:work-area"), EnumChatType.Notification); } else { slot.Itemstack.Attributes.RemoveAttribute("workArea"); start = slot.Itemstack.TempAttributes.GetOrAddTreeAttribute("startPoint"); start.SetDouble("x1", pos.X); start.SetDouble("y1", pos.Y); start.SetDouble("z1", pos.Z); ((byEntity as EntityPlayer)?.Player as IServerPlayer)?.SendMessage(GlobalConstants.InfoLogChatGroup, Lang.Get("temporalhack:work-start"), EnumChatType.Notification); } return; } if (byEntity.Controls.Sneak) { handling = EnumHandHandling.PreventDefault; //if (byEntity.Api.Side == EnumAppSide.Client) return; ITreeAttribute tree; BlockEntity sel = api.World.BlockAccessor.GetBlockEntity(blockSel.Position); if (sel is BlockEntityBarrel) { tree = slot.Itemstack.Attributes.GetOrAddTreeAttribute("workBarrel"); tree.SetInt("x", blockSel.Position.X); tree.SetInt("y", blockSel.Position.Y); tree.SetInt("z", blockSel.Position.Z); ((byEntity as EntityPlayer)?.Player as IServerPlayer)?.SendMessage(GlobalConstants.InfoLogChatGroup, Lang.Get("temporalhack:work-barrel"), EnumChatType.Notification); } else if (sel is BlockEntityGenericTypedContainer) { //System.Diagnostics.Debug.WriteLine(blockSel.Position.X + "," + blockSel.Position.Y + "," + blockSel.Position.Z); tree = slot.Itemstack.Attributes.GetOrAddTreeAttribute("workChest"); tree.SetInt("x", blockSel.Position.X); tree.SetInt("y", blockSel.Position.Y); tree.SetInt("z", blockSel.Position.Z); ((byEntity as EntityPlayer)?.Player as IServerPlayer)?.SendMessage(GlobalConstants.InfoLogChatGroup, Lang.Get("temporalhack:work-chest"), EnumChatType.Notification); } return; } } else { if (byEntity.Controls.Sprint && !(entitySel?.Entity is EntityLocust)) { handling = EnumHandHandling.PreventDefault; if (slot.Itemstack.Attributes.GetBool("recordMode")) { slot.Itemstack.Attributes.SetBool("recordMode", false); ((byEntity as EntityPlayer)?.Player as IServerPlayer)?.SendMessage(GlobalConstants.InfoLogChatGroup, Lang.Get("temporalhack:work-itemcacheoff"), EnumChatType.Notification); } else { slot.Itemstack.Attributes.SetBool("recordMode", true); ((byEntity as EntityPlayer)?.Player as IServerPlayer)?.SendMessage(GlobalConstants.InfoLogChatGroup, Lang.Get("temporalhack:work-itemcacheon"), EnumChatType.Notification); } } } }
/// <summary> /// /// </summary> /// <param name="position"></param> public Particle(Vec3d position) { _position = position; }
/// <summary> /// Replace X value /// </summary> /// <param name="v3"></param> /// <param name="x"></param> /// <returns></returns> public static Vec3d SetX(this Vec3d v3, decimal x) { return(new Vec3d(x, v3.Y, v3.Z)); }
/// <summary> /// /// </summary> /// <param name="other"></param> public Particle(Particle other) { _position = other._position; _velocity = other._velocity; _mass = other._mass; }
/// <summary> /// Replace Z value /// </summary> /// <param name="v3"></param> /// <param name="z"></param> /// <returns></returns> public static Vec3d SetZ(this Vec3d v3, decimal z) { return(new Vec3d(v3.X, v3.Y, z)); }
/// <inheritdoc /> public void ApplyForce(Vec3d delta) { _forceSum += delta; }
/// <summary> /// /// </summary> /// <param name="point"></param> /// <param name="radius"></param> /// <returns></returns> public static double Sphere(Vec3d point, double radius) { return(point.Length - radius); }
/// <inheritdoc /> public void ApplyMove(Vec3d delta, double weight) { _moveSum += delta * weight; _moveWeightSum += weight; }
public void TickEvery25ms(float dt) { if (ws.api.Side == EnumAppSide.Client) { clientUpdate(dt); } else { double nowTotalHours = ws.api.World.Calendar.TotalHours; int i = 0; while (nowTotalHours - LastUpdateTotalHours > 1 && i++ < 1000) { TickEveryInGameHourServer(LastUpdateTotalHours); LastUpdateTotalHours++; } var rnd = ws.api.World.Rand; float targetLightninMinTemp = CurWeatherEvent.State.LightningMinTemp; if (rnd.NextDouble() < CurWeatherEvent.State.LightningRate) { ClimateCondition nowcond = ws.api.World.BlockAccessor.GetClimateAt(regionCenterPos, EnumGetClimateMode.ForSuppliedDateValues, ws.api.World.Calendar.TotalDays); if (nowcond.Temperature >= targetLightninMinTemp && nowcond.RainCloudOverlay > 0.15) { Vec3d pos = regionCenterPos.ToVec3d().Add(-200 + rnd.NextDouble() * 400, ws.api.World.SeaLevel, -200 + rnd.NextDouble() * 400); ws.SpawnLightningFlash(pos); } } } if (Transitioning) { float speed = ws.api.World.Calendar.SpeedOfTime / 60f; Weight += dt / TransitionDelay * speed; if (Weight > 1) { Transitioning = false; Weight = 1; } } else { if (ws.autoChangePatterns && ws.api.Side == EnumAppSide.Server && ws.api.World.Calendar.TotalHours > NewWePattern.State.ActiveUntilTotalHours) { TriggerTransition(); } } if (ws.autoChangePatterns && ws.api.Side == EnumAppSide.Server) { bool sendPacket = false; if (ws.api.World.Calendar.TotalHours > CurWindPattern.State.ActiveUntilTotalHours) { CurWindPattern = WindPatterns[Rand.NextInt(WindPatterns.Length)]; CurWindPattern.OnBeginUse(); sendPacket = true; } if (ws.api.World.Calendar.TotalHours > CurWeatherEvent.State.ActiveUntilTotalHours || CurWeatherEvent.ShouldStop(weatherData.climateCond.Rainfall, weatherData.climateCond.Temperature)) { CurWeatherEvent = RandomWeatherEvent(); CurWeatherEvent.OnBeginUse(); sendPacket = true; } if (sendPacket) { wsServer.SendWeatherStateUpdate(new WeatherState() { RegionX = regionX, RegionZ = regionZ, NewPattern = NewWePattern.State, OldPattern = OldWePattern.State, WindPattern = CurWindPattern.State, WeatherEvent = CurWeatherEvent?.State, TransitionDelay = TransitionDelay, Transitioning = Transitioning, Weight = Weight, LcgCurrentSeed = Rand.currentSeed, LcgMapGenSeed = Rand.mapGenSeed, LcgWorldSeed = Rand.worldSeed }); } } NewWePattern.Update(dt); OldWePattern.Update(dt); CurWindPattern.Update(dt); CurWeatherEvent.Update(dt); float curWindSpeed = weatherData.curWindSpeed.X; float targetWindSpeed = (float)GetWindSpeed(ws.api.World.SeaLevel); curWindSpeed += GameMath.Clamp((targetWindSpeed - curWindSpeed) * dt, -0.001f, 0.001f); weatherData.curWindSpeed.X = curWindSpeed; quarterSecAccum += dt; if (quarterSecAccum > 0.25f) { regionCenterPos.Y = ws.api.World.BlockAccessor.GetRainMapHeightAt(regionCenterPos); if (regionCenterPos.Y == 0) { regionCenterPos.Y = ws.api.World.SeaLevel; // Map chunk might not be loaded. In that case y will be 0. } ClimateCondition nowcond = ws.api.World.BlockAccessor.GetClimateAt(regionCenterPos); if (nowcond != null) { weatherData.climateCond = nowcond; } quarterSecAccum = 0; } weatherData.BlendedPrecType = CurWeatherEvent.State.PrecType; }
public override void LoadData(ref AnimatTools.DataObjects.Simulation dsSim, ref AnimatTools.DataObjects.Physical.PhysicalStructure doStructure, ref AnimatTools.Interfaces.StdXml oXml) { base.LoadData (ref dsSim, ref doStructure, ref oXml); oXml.IntoElem(); m_vGraphicsBoxSize = Util.LoadVec3d(ref oXml, "GraphicsBoxSize", this); oXml.OutOfElem(); //out of body }
public static extern void core_Mat_push_back_Vec3d(IntPtr self, Vec3d v);
public virtual void SetSize(float width, float height, float depth) { if(m_d3dMesh != null) { m_d3dMesh.Dispose(); m_d3dMesh = null; } if(m_mshSelectedBoundingBox != null) { this.m_mshSelectedBoundingBox.Dispose(); this.m_mshSelectedBoundingBox = null; } if(m_mshCB != null) { this.m_mshCB.Dispose(); this.m_mshCB = null; } if(m_mshLB != null) { this.m_mshLB.Dispose(); this.m_mshLB = null; } m_vGraphicsBoxSize = new Vec3d(null); m_vGraphicsBoxSize.X = width; m_vGraphicsBoxSize.Y = height; m_vGraphicsBoxSize.Z = depth; m_d3dMesh = Util_DX.CreateBox(this.Device, width, height, depth); //m_d3dMesh = Mesh.Box(this.Device, width, height, depth); float fltScale = (this.MaxDimension * 0.15f); if(fltScale > 0.3f) fltScale = 0.3f; m_mshSelectedBoundingBox = Mesh.Box(Device, (float)(m_vGraphicsBoxSize.X + fltScale),(float)(m_vGraphicsBoxSize.Y + fltScale), (float)(m_vGraphicsBoxSize.Z + fltScale)); RefreshSelectionBoxSizes(); }
private void ribbonButton53_Click(object sender, EventArgs e) { if (featurePolygon == null) { Vec3d vec1 = new Vec3d(); vec1.set(0, 40, 0); Vec3d vec2 = new Vec3d(); vec2.set(-60, 40, 0); Vec3d vec3 = new Vec3d(); vec3.set(-60, 60, 0); Vec3d vec4 = new Vec3d(); vec4.set( 0, 60, 0 ); PolygonGeometry polygon = new PolygonGeometry(); polygon.push_back( vec1 ); polygon.push_back( vec2 ); polygon.push_back( vec3 ); polygon.push_back( vec4 ); Feature feature = new Feature(); feature.setGeometry(polygon); featurePolygon = new FeaturePrimitive(); featurePolygon.setFeature( feature ); m_earthRoot.addChild( featurePolygon ); } }
protected override void CloneInternal(AnimatTools.Framework.DataObject doOriginal, bool bCutData, AnimatTools.Framework.DataObject doRoot) { base.CloneInternal (doOriginal, bCutData, doRoot); Box doOrigBody = (Box) doOriginal; m_vGraphicsBoxSize = new Vec3d(this, doOrigBody.m_vGraphicsBoxSize.X, doOrigBody.m_vGraphicsBoxSize.Y, doOrigBody.m_vGraphicsBoxSize.Z); m_snHeight = (AnimatTools.Framework.ScaledNumber) doOrigBody.m_snHeight.Clone(this, bCutData, doRoot); m_snWidth = (AnimatTools.Framework.ScaledNumber) doOrigBody.m_snWidth.Clone(this, bCutData, doRoot); m_snLength = (AnimatTools.Framework.ScaledNumber) doOrigBody.m_snLength.Clone(this, bCutData, doRoot); }
public static extern void calib3d_RQDecomp3x3_Mat(IntPtr src, IntPtr mtxR, IntPtr mtxQ, IntPtr qx, IntPtr qy, IntPtr qz, out Vec3d outVal);
OrderedDictionary <BlockPos, float> GetNearblyMultibreakables(IWorldAccessor world, BlockPos pos, Vec3d hitPos) { OrderedDictionary <BlockPos, float> positions = new OrderedDictionary <BlockPos, float>(); for (int dx = -1; dx <= 1; dx++) { for (int dy = -1; dy <= 1; dy++) { for (int dz = -1; dz <= 1; dz++) { if (dx == 0 && dy == 0 && dz == 0) { continue; } BlockPos dpos = pos.AddCopy(dx, dy, dz); if (CanMultiBreak(world.BlockAccessor.GetBlock(dpos))) { positions.Add(dpos, hitPos.SquareDistanceTo(dpos.X + 0.5, dpos.Y + 0.5, dpos.Z + 0.5)); } } } } return(positions); }
public virtual bool TestReceptiveFieldIntersection(int x, int y, ref Vec3d vVertex) { if(m_d3dReceptiveFieldPoint != null) { //a temporary intersect information for the selected bounding box IntersectInformation iiTmp = new IntersectInformation(); Vec3d vSelVertex = new Vec3d(null, 0, 0, 0); float fltSelDistance = -1; //First find all of the vertex points that are intersected. foreach(Vec3d vPoint in m_aryReceptiveFields) { Matrix mWorld = Matrix.Translation((float) vPoint.X, (float) vPoint.Y, (float) vPoint.Z) * CombinedTransformationMatrix * Device.Transform.World1; if(Util_DX.TestIntersectWithMouse(m_d3dReceptiveFieldPoint,Device.Viewport, Device.Transform.Projection, Device.Transform.View, mWorld, x, y, out iiTmp)) { if(fltSelDistance < 0 || iiTmp.Dist < fltSelDistance) { fltSelDistance = iiTmp.Dist; vSelVertex = vPoint; } } } if(fltSelDistance > 0) { vVertex = vSelVertex; return true; } } return false; }
/// <summary> /// /// </summary> /// <param name="countX"></param> /// <param name="countY"></param> /// <param name="origin"></param> /// <param name="scale"></param> public GridField3d <T> Create(int countX, int countY, int countZ, Vec3d origin, Vec3d scale) { var result = Create(countX, countY, countZ); result.Origin = origin; result.Scale = scale; return(result); }
public override void SaveData(ref AnimatTools.DataObjects.Simulation dsSim, ref AnimatTools.DataObjects.Physical.PhysicalStructure doStructure, ref AnimatTools.Interfaces.StdXml oXml) { base.SaveData (ref dsSim, ref doStructure, ref oXml); Vector3 v3Rot = Util_DX.DecomposeXYZRotationMatrix(this.CombinedTransformationMatrix); Vector3 rot = m_v3Rotation; rot.Normalize(); AnimatTools.Framework.Vec3d v = new Vec3d(null, rot.X, rot.Y, rot.Z); oXml.IntoElem(); //oXml.AddChildElement("Stiffness", this.Stiffness.ActualValue); //oXml.AddChildElement("Damping", this.Damping.ActualValue); oXml.AddChildElement("ConstraintHalfAngle",m_fHalfAngle); m_v3Axis.TransformCoordinate(Matrix.RotationX(Geometry.DegreeToRadian(180)) * Matrix.RotationY(Geometry.DegreeToRadian(180)) * Matrix.RotationZ(Geometry.DegreeToRadian(180)) * Matrix.RotationX(v3Rot.X)* Matrix.RotationY(v3Rot.Y) * Matrix.RotationZ(v3Rot.Z)); Vec3d vRotationAxis = new Vec3d(null,m_v3Axis.X, m_v3Axis.Y, m_v3Axis.Z); Util.SaveVector(ref oXml, "ConstraintAxis", vRotationAxis); oXml.OutOfElem(); m_v3Axis = new Vector3(0,0,1); }
public override bool ContinueExecute(float dt) { Vec3d pos = targetPoi.Position; pathTraverser.CurrentTarget.X = pos.X; pathTraverser.CurrentTarget.Y = pos.Y; pathTraverser.CurrentTarget.Z = pos.Z; Cuboidd targetBox = entity.SelectionBox.ToDouble().Translate(entity.ServerPos.X, entity.ServerPos.Y, entity.ServerPos.Z); double distance = targetBox.ShortestDistanceFrom(pos); float minDist = MinDistanceToTarget(); if (distance <= minDist) { pathTraverser.Stop(); if (animMeta != null) { entity.AnimManager.StopAnimation(animMeta.Code); } EntityBehaviorMultiplyBase bh = entity.GetBehavior <EntityBehaviorMultiplyBase>(); if (bh != null && !bh.ShouldEat) { return(false); } if (targetPoi.IsSuitableFor(entity, entityDiet) != true) { return(false); } if (eatAnimMeta != null && !eatAnimStarted) { entity.AnimManager.StartAnimation((targetPoi is LooseItemFoodSource && eatAnimMetaLooseItems != null) ? eatAnimMetaLooseItems : eatAnimMeta); eatAnimStarted = true; } eatTimeNow += dt; if (targetPoi is LooseItemFoodSource foodSource) { entity.World.SpawnCubeParticles(entity.ServerPos.XYZ, foodSource.ItemStack, 0.25f, 1, 0.25f + 0.5f * (float)entity.World.Rand.NextDouble()); } if (eatTimeNow > eatTime * 0.75f && !soundPlayed) { soundPlayed = true; if (eatSound != null) { entity.World.PlaySoundAt(eatSound, entity, null, true, 16, 1); } } if (eatTimeNow >= eatTime) { ITreeAttribute tree = entity.WatchedAttributes.GetTreeAttribute("hunger"); if (tree == null) { entity.WatchedAttributes["hunger"] = tree = new TreeAttribute(); } if (doConsumePortion) { float sat = targetPoi.ConsumeOnePortion(); quantityEaten += sat; tree.SetFloat("saturation", sat + tree.GetFloat("saturation", 0)); entity.WatchedAttributes.SetDouble("lastMealEatenTotalHours", entity.World.Calendar.TotalHours); entity.WatchedAttributes.MarkPathDirty("hunger"); } else { quantityEaten = 1; } failedSeekTargets.Remove(targetPoi); return(false); } } else { if (!pathTraverser.Active) { float rndx = (float)entity.World.Rand.NextDouble() * 0.3f - 0.15f; float rndz = (float)entity.World.Rand.NextDouble() * 0.3f - 0.15f; if (!pathTraverser.NavigateTo(targetPoi.Position.AddCopy(rndx, 0, rndz), moveSpeed, MinDistanceToTarget() - 0.15f, OnGoalReached, OnStuck, false, 500, 1)) { return(false); } } } if (nowStuck && entity.World.ElapsedMilliseconds > stuckatMs + eatTime * 1000) { return(false); } return(true); }
/// <summary> /// finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern. /// </summary> /// <param name="objectPoints">In the new interface it is a vector of vectors of calibration pattern points in the calibration pattern coordinate space. /// The outer vector contains as many elements as the number of the pattern views. If the same calibration pattern is shown in each view and /// it is fully visible, all the vectors will be the same. Although, it is possible to use partially occluded patterns, or even different patterns /// in different views. Then, the vectors will be different. The points are 3D, but since they are in a pattern coordinate system, then, /// if the rig is planar, it may make sense to put the model to a XY coordinate plane so that Z-coordinate of each input object point is 0. /// In the old interface all the vectors of object points from different views are concatenated together.</param> /// <param name="imagePoints">In the new interface it is a vector of vectors of the projections of calibration pattern points. /// imagePoints.Count() and objectPoints.Count() and imagePoints[i].Count() must be equal to objectPoints[i].Count() for each i.</param> /// <param name="imageSize">Size of the image used only to initialize the intrinsic camera matrix.</param> /// <param name="cameraMatrix">Output 3x3 floating-point camera matrix. /// If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be /// initialized before calling the function.</param> /// <param name="distCoeffs">Output vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements.</param> /// <param name="rvecs">Output vector of rotation vectors (see Rodrigues() ) estimated for each pattern view. That is, each k-th rotation vector /// together with the corresponding k-th translation vector (see the next output parameter description) brings the calibration pattern /// from the model coordinate space (in which object points are specified) to the world coordinate space, that is, a real position of the /// calibration pattern in the k-th pattern view (k=0.. M -1)</param> /// <param name="tvecs">Output vector of translation vectors estimated for each pattern view.</param> /// <param name="flags">Different flags that may be zero or a combination of the CalibrationFlag values</param> /// <param name="criteria">Termination criteria for the iterative optimization algorithm.</param> /// <returns></returns> public static double CalibrateCamera( IEnumerable<IEnumerable<Point3d>> objectPoints, IEnumerable<IEnumerable<Point2d>> imagePoints, Size imageSize, double[,] cameraMatrix, double[] distCoeffs, out Vec3d[] rvecs, out Vec3d[] tvecs, CalibrationFlag flags = CalibrationFlag.Zero, TermCriteria? criteria = null) { if (objectPoints == null) throw new ArgumentNullException("objectPoints"); if (objectPoints == null) throw new ArgumentNullException("objectPoints"); if (cameraMatrix == null) throw new ArgumentNullException("cameraMatrix"); if (distCoeffs == null) throw new ArgumentNullException("distCoeffs"); TermCriteria criteria0 = criteria.GetValueOrDefault( new TermCriteria(CriteriaType.Iteration | CriteriaType.Epsilon, 30, Double.Epsilon)); using (var op = new ArrayAddress2<Point3d>(objectPoints)) using (var ip = new ArrayAddress2<Point2d>(imagePoints)) using (var rvecsVec = new VectorOfMat()) using (var tvecsVec = new VectorOfMat()) { double ret = NativeMethods.calib3d_calibrateCamera_vector( op.Pointer, op.Dim1Length, op.Dim2Lengths, ip.Pointer, ip.Dim1Length, ip.Dim2Lengths, imageSize, cameraMatrix, distCoeffs, distCoeffs.Length, rvecsVec.CvPtr, tvecsVec.CvPtr, (int)flags, criteria0); Mat[] rvecsM = rvecsVec.ToArray(); Mat[] tvecsM = tvecsVec.ToArray(); rvecs = EnumerableEx.SelectToArray(rvecsM, m => m.Get<Vec3d>(0)); tvecs = EnumerableEx.SelectToArray(tvecsM, m => m.Get<Vec3d>(0)); return ret; } }
public static Vec3d FindScaleFactor(Vec3d vFirst, Vec3d vSecond) { Vec3d vSizeDiff = new Vec3d(null, 0, 0, 0); vSizeDiff.X = vFirst.X/vSecond.X; vSizeDiff.Y = vFirst.Y/vSecond.Y; vSizeDiff.Z = vFirst.Z/vSecond.Z; return vSizeDiff; }