public static Vector2 Div(this Vector2 vector, Vector2 otherVector, Axes axis)
{
vector.x = axis.Contains(Axes.X) ? vector.x / otherVector.x : vector.x;
vector.y = axis.Contains(Axes.Y) ? vector.y / otherVector.y : vector.y;
return vector;
}
// Update is called once per frame
void Update()
{
//bool enabled = Input.GetKey(key);
if (axes == null || axes.horizontal == null || axes.horizontal.Length == 0)
axes = FetchAxis0();
if (axes != null)
{
Vector3 vec = this.transform.localEulerAngles;
float v = ResolveAxis(axes.vertical);
float h = ResolveAxis(axes.horizontal);
float z = ResolveAxis(axes.other);
vec.x = Mathf.Clamp(v*0.7f + h * orientation, -1f, 1f) * 35f + 3.2f;
vec.y = Mathf.Clamp(z,-1f,1f) * -25f + 180f;
this.transform.localEulerAngles = vec;
float f = Mathf.Max( Mathf.Max(ResolveAxis(axes.acceleration) , 0f), Mathf.Max(Mathf.Max(Mathf.Abs(h),Mathf.Abs(v)),Mathf.Abs(z)));
if (sys != null)
{
sys.enableEmission = f != 0f;
sys.startLifetime = f * maxLifetime;
}
if (force != null)
{
force.relativeForce = new Vector3(0,0,maxForce * f);
}
}
}
/// <summary>
/// Get the acceleration of one axis in Gs.
/// </summary>
/// <param name="axis">The axis to read from.</param>
/// <returns>Acceleration of the ADXL345 in Gs.</returns>
public override double GetAcceleration(Axes axis)
{
byte[] transferBuffer = new byte[3];
transferBuffer[0] = (byte)((AddressRead | AddressMultiByte | DataRegister) + (byte)axis);
m_spi.Transaction(transferBuffer, transferBuffer, 3);
return BitConverter.ToInt16(transferBuffer, 1) * GsPerLSB;
}
public static float Average(this Vector4 vector, Axes axis)
{
float average = 0;
int axisCount = 0;
if (axis.Contains(Axes.X)) {
average += vector.x;
axisCount += 1;
}
if (axis.Contains(Axes.Y)) {
average += vector.y;
axisCount += 1;
}
if (axis.Contains(Axes.Z)) {
average += vector.z;
axisCount += 1;
}
if (axis.Contains(Axes.W)) {
average += vector.w;
axisCount += 1;
}
return average / axisCount;
}
public static float Distance(this Vector3 vector, Vector3 target, Axes axes)
{
float distance = 0f;
switch (axes)
{
case Axes.X:
distance = Mathf.Abs(vector.x - target.x);
break;
case Axes.Y:
distance = Mathf.Abs(vector.y - target.y);
break;
case Axes.Z:
distance = Mathf.Abs(vector.z - target.z);
break;
case Axes.XY:
distance = Vector2.Distance(vector, target);
break;
case Axes.XZ:
distance = Vector2.Distance(new Vector2(vector.x, vector.z), new Vector2(target.x, target.z));
break;
case Axes.YZ:
distance = Vector2.Distance(new Vector2(vector.y, vector.z), new Vector2(target.y, target.z));
break;
case Axes.XYZ:
distance = Vector3.Distance(vector, target);
break;
}
return distance;
}
public static float Average(this Vector3 vector, Axes axes)
{
float average = 0f;
int axisCount = 0;
if ((axes & Axes.X) != 0)
{
average += vector.x;
axisCount += 1;
}
if ((axes & Axes.Y) != 0)
{
average += vector.y;
axisCount += 1;
}
if ((axes & Axes.Z) != 0)
{
average += vector.z;
axisCount += 1;
}
return average / axisCount;
}
public static Vector2 Lerp(this Vector2 vector, Vector2 target, float time, Axes axis)
{
vector.x = axis.Contains(Axes.X) && Mathf.Abs(target.x - vector.x) > epsilon ? Mathf.Lerp(vector.x, target.x, time) : vector.x;
vector.y = axis.Contains(Axes.Y) && Mathf.Abs(target.y - vector.y) > epsilon ? Mathf.Lerp(vector.y, target.y, time) : vector.y;
return vector;
}
public static Vector3 Div(this Vector3 vector, Vector3 otherVector, Axes axis)
{
vector.x = axis.Contains(Axes.X) ? vector.x / otherVector.x : vector.x;
vector.y = axis.Contains(Axes.Y) ? vector.y / otherVector.y : vector.y;
vector.z = axis.Contains(Axes.Z) ? vector.z / otherVector.z : vector.z;
return vector;
}
/// <summary>
/// Sets the value of the Y axe.
/// </summary>
public Vector3 SetY (float y)
{
if (y != value.y)
{
value.y = y;
axes |= Axes.Y;
}
return value;
}
public static Vector4 Div(this Vector4 vector, Vector4 otherVector, Axes axis)
{
vector.x = axis.Contains(Axes.X) ? vector.x / otherVector.x : vector.x;
vector.y = axis.Contains(Axes.Y) ? vector.y / otherVector.y : vector.y;
vector.z = axis.Contains(Axes.Z) ? vector.z / otherVector.z : vector.z;
vector.w = axis.Contains(Axes.W) ? vector.w / otherVector.w : vector.w;
return vector;
}
/// <summary>
/// Sets the value of the X axe.
/// </summary>
public Vector3 SetX (float x)
{
if (x != value.x)
{
value.x = x;
axes |= Axes.X;
}
return value;
}
#pragma warning restore 649
private NodeSet CreateNodeTest (Axes axis, object nodeTest, ArrayList plist)
{
NodeSet test = CreateNodeTest (axis, nodeTest);
if (plist != null) {
for (int i = 0; i < plist.Count; i++)
test = new ExprFilter (test,
(Expression) plist [i]);
}
return test;
}
public static Vector2 Ceil(this Vector2 vector, Axes axes)
{
if ((axes & Axes.X) != 0)
vector.x = Mathf.Ceil(vector.x);
if ((axes & Axes.Y) != 0)
vector.y = Mathf.Ceil(vector.y);
return vector;
}
public static Vector2 Lerp(this Vector2 vector, Vector2 target, float time, Axes axes)
{
if ((axes & Axes.X) != 0 && Mathf.Abs(target.x - vector.x) > _epsilon)
vector.x = Mathf.Lerp(vector.x, target.x, time);
if ((axes & Axes.Y) != 0 && Mathf.Abs(target.y - vector.y) > _epsilon)
vector.y = Mathf.Lerp(vector.y, target.y, time);
return vector;
}
public static void AccelerateTowards(this Rigidbody2D rigidbody, Vector2 targetAcceleration, float speed, InterpolationModes interpolation, Axes axis = Axes.XY)
{
switch (interpolation) {
case InterpolationModes.Quadratic:
rigidbody.SetVelocity(rigidbody.velocity.Lerp(targetAcceleration, Time.fixedDeltaTime * speed, axis), axis);
break;
case InterpolationModes.Linear:
rigidbody.SetVelocity(rigidbody.velocity.LerpLinear(targetAcceleration, Time.fixedDeltaTime * speed, axis), axis);
break;
}
}
public static void AccelerateTowards(this Rigidbody2D rigidbody, Vector2 targetSpeed, float acceleration, float deltaTime, InterpolationModes interpolation = InterpolationModes.Quadratic, Axes axes = Axes.XY)
{
switch (interpolation)
{
case InterpolationModes.Quadratic:
rigidbody.SetVelocity(rigidbody.velocity.Lerp(targetSpeed, deltaTime * acceleration, axes), axes);
break;
case InterpolationModes.Linear:
rigidbody.SetVelocity(rigidbody.velocity.LerpLinear(targetSpeed, deltaTime * acceleration, axes), axes);
break;
}
}
public static Axes Resolve(Axes axis1, Axes axis2)
{
if (axis1 == axis2)
throw new ArgumentException("Cannot resolve duplicate axes.");
if ((axis1 == Axes.X || axis1 == Axes.Y) && (axis2 == Axes.X || axis2 == Axes.Y))
return Axes.Z;
else if ((axis1 == Axes.X || axis1 == Axes.Z) && (axis2 == Axes.X || axis2 == Axes.Z))
return Axes.Y;
else
return Axes.X;
}
// ShowAxis
private static void ShowAxis( ref Axes axis, string label )
{
GUILayout.BeginHorizontal();
axis.enabled = EditorGUILayout.Toggle( axis.enabled, GUILayout.Width( 15f ) );
GUILayout.Label( "Axis " + label, GUILayout.Width( 50f ) );
GUI.enabled = axis.enabled;
axis.Name = EditorGUILayout.TextField( axis.Name, GUILayout.Width( 100f ) );
GUILayout.Space( 10f );
axis.inverse = EditorGUILayout.Toggle( axis.inverse, GUILayout.Width( 15f ) );
GUILayout.Label( "Inverse", GUILayout.Width( 55f ) );
GUI.enabled = true;
GUILayout.EndHorizontal();
}
/// <summary>
/// Construct a new generic constraint.
/// </summary>
/// <param name="bodyA">The first constrained body.</param>
/// <param name="bodyB">The second constrained body.</param>
/// <param name="basis">The world-space frame of the second body against which the first body will be constrained. This value
/// must contain the initial position and orientation of the second body at the time the constraint was created.</param>
/// <param name="limitedPosAxes">Specifies which axes around which to constrain position.</param>
/// <param name="minPos">The minimum distances between the two bodies along each axis.</param>
/// <param name="maxPos">The maximum distances between the two bodies along each axis.</param>
/// <param name="limitedRotAxes">Specifies which axes around which to constrain rotation.</param>
/// <param name="minAngles">The minimum relative angles, in radians, around each axis.</param>
/// <param name="maxAngles">The maximum relative angles, in radians, around each axis.</param>
public GenericConstraint(RigidBody bodyA, RigidBody bodyB, Frame basis, Axes limitedPosAxes,
Vector3 minPos, Vector3 maxPos, Axes limitedRotAxes, Vector3 minAngles, Vector3 maxAngles)
: base(bodyA, bodyB)
{
Frame.Transform(ref basis, ref bodyA.WorldInverse, out _bodyBasisA);
Frame.Transform(ref basis, ref bodyB.WorldInverse, out _bodyBasisB);
_limitedPosAxes = limitedPosAxes;
_limitedRotAxes = limitedRotAxes;
_minPos = minPos;
_maxPos = maxPos;
_minAngles = minAngles;
_maxAngles = maxAngles;
}
public PhysicalHeliState(Quaternion orientation, Vector3 pos, Vector3 velocity, Vector3 acceleration)
{
Orientation = orientation;
Position = pos;
Velocity = velocity;
Acceleration = acceleration;
Matrix orientationMatrix = Matrix.CreateFromQuaternion(orientation);
Axes = VectorHelper.GetAxes(orientation);
PitchAngle = VectorHelper.GetPitchAngle(orientationMatrix);
RollAngle = VectorHelper.GetRollAngle(orientationMatrix);
HeadingAngle = VectorHelper.GetHeadingAngle(orientationMatrix);
}
public void Reflect(Axes axis)
{
switch (axis)
{
case Axes.X:
ReflectX();
break;
case Axes.Y:
ReflectY();
break;
case Axes.Z:
ReflectZ();
break;
}
}
private NodeTest CreateNodeTest (Axes axis, object test)
{
if (test is XPathNodeType)
return new NodeTypeTest (axis,
(XPathNodeType) test, null);
else if (test is string || test == null)
return new NodeTypeTest (axis,
XPathNodeType.ProcessingInstruction,
(string) test);
XmlQualifiedName q = (XmlQualifiedName) test;
if (q == XmlQualifiedName.Empty)
return new NodeTypeTest (axis);
else
return new NodeNameTest (axis, q, Context);
}
public static Vector4 Ceil(this Vector4 vector, Axes axes)
{
if ((axes & Axes.X) != 0)
vector.x = Mathf.Ceil(vector.x);
if ((axes & Axes.Y) != 0)
vector.y = Mathf.Ceil(vector.y);
if ((axes & Axes.Z) != 0)
vector.z = Mathf.Ceil(vector.z);
if ((axes & Axes.W) != 0)
vector.w = Mathf.Ceil(vector.w);
return vector;
}
/// <summary>
/// Creates an instance of Options1.
/// </summary>
/// <param name="value">Value of TubeSize.</param>
/// <param name="axes">States, if value is x (half width of rectangle) or y (half height of rectangle).</param>
/// /// <remarks>Default values: <para>
/// Use relative values for calculation of TubeSize: Relativity = Relativity.Relative <para/>
/// Delimiter = ';' <para/>
/// Separator = '.' <para/>
/// Don't save log file: log = new Log()<para/>
/// Don't save image: reportFolder = ""<para/>
/// Don't show window: showWindow = false<para/>
/// Show all (valid and invalid): ShowValidity = Validity.All<para/>
/// Always use normal drawing methods, never fast drawing methods: drawFastAbove = 0<para/>
/// Always draw points: drawPointsBelow = Int32.MaxValue
/// </para></remarks>
public Options1(double value, Axes axes)
{
this.val = value;
this.axes = axes;
relativity = Relativity.Relative;
baseX = Double.NaN;
baseY = Double.NaN;
ratio = Double.NaN;
log = new Log();
reportFolder = "";
showWindow = false;
showValidity = Validity.All;
drawFastAbove = 0;
drawPointsBelow = Int32.MaxValue;
formerBaseAndRatio = false;
drawLabelNumber = false;
}
/// <summary>
/// Returns a new physical state where the values represent the error in the estimated state to
/// the given true state. I.e. position = estimatedPosition - truePosition.
/// </summary>
/// <param name="trueState"></param>
/// <param name="estimatedState"></param>
/// <returns></returns>
public static PhysicalHeliState GetError(PhysicalHeliState trueState, PhysicalHeliState estimatedState)
{
var axesError = new Axes
{
Forward = estimatedState.Axes.Forward - trueState.Axes.Forward,
Right = estimatedState.Axes.Right - trueState.Axes.Right,
Up = estimatedState.Axes.Up - trueState.Axes.Up
};
// var rotationError = new Matrix {Forward = axesError.Forward, Right = axesError.Right, Up = axesError.Up};
// TODO Verify this works, since axes were originally used to compute state instead of orientation (but should equivalent)
return new PhysicalHeliState(
Quaternion.Identity, // TODO Not sure how to represent rotation error in quaternion representation
estimatedState.Position - trueState.Position,
estimatedState.Velocity - trueState.Velocity,
estimatedState.Acceleration - trueState.Acceleration);
}
public static Quaternion Round(this Quaternion quaternion, float step, Axes axes)
{
if (step <= 0)
return quaternion;
if ((axes & Axes.X) != 0)
quaternion.x = quaternion.x.Round(step);
if ((axes & Axes.Y) != 0)
quaternion.y = quaternion.y.Round(step);
if ((axes & Axes.Z) != 0)
quaternion.z = quaternion.z.Round(step);
if ((axes & Axes.W) != 0)
quaternion.w = quaternion.w.Round(step);
return quaternion;
}
public static float Distance(this Vector2 vector, Vector2 target, Axes axes)
{
float distance = 0f;
switch (axes)
{
case Axes.X:
distance = Mathf.Abs(vector.x - target.x);
break;
case Axes.Y:
distance = Mathf.Abs(vector.y - target.y);
break;
case Axes.XY:
distance = Vector2.Distance(vector, target);
break;
}
return distance;
}
public override float GetAxis( Axes axis )
{
switch( axis )
{
case Axes.LeftStickX:
return GetAxis( "LeftStickX" );
case Axes.LeftStickY:
return GetAxis( "LeftStickY" );
case Axes.RightStickX:
return GetAxis( "RightStickX" );
case Axes.RightStickY:
return GetAxis( "RightStickY" );
case Axes.LeftTrigger:
return GetAxis( "LeftTrigger" );
case Axes.RightTrigger:
return GetAxis( "RightTrigger" );
default:
return 0f;
}
}
/// <summary>
/// Returns value from Vector based on axis
/// </summary>
/// <param name="values">Vector to get axis from</param>
/// <param name="axis">Axis to get (values.x, values.y, values.z)</param>
/// <returns></returns>
public static float GetAxes(Vector3 values, Axes axis)
{
return(values[(int)axis]);
}
/// <summary>Creates an axis reader for the specified object</summary>
/// <param name="joystick">Joystick providing the control object</param>
/// <param name="axis">Axis a reader will be created for</param>
/// <param name="control">Control description for the axis</param>
/// <returns>A new axis reader for the specified axis</returns>
private static IAxisReader createAxisReader(
Joystick joystick, Axes axis, DeviceObjectInstance control
)
{
int id = (int)control.ObjectType;
ObjectProperties properties = joystick.GetObjectPropertiesById(id);
int min = properties.LowerRange;
int max = properties.UpperRange;
switch (axis)
{
case Axes.X:
{
return(new XAxisReader(min, max));
}
case Axes.Y:
{
return(new YAxisReader(min, max));
}
case Axes.Z:
{
return(new ZAxisReader(min, max));
}
case Axes.VelocityX:
{
return(new VelocityXAxisReader(min, max));
}
case Axes.VelocityY:
{
return(new VelocityYAxisReader(min, max));
}
case Axes.VelocityZ:
{
return(new VelocityZAxisReader(min, max));
}
case Axes.AccelerationX:
{
return(new AccelerationXAxisReader(min, max));
}
case Axes.AccelerationY:
{
return(new AccelerationYAxisReader(min, max));
}
case Axes.AccelerationZ:
{
return(new AccelerationZAxisReader(min, max));
}
case Axes.ForceX:
{
return(new ForceXAxisReader(min, max));
}
case Axes.ForceY:
{
return(new ForceYAxisReader(min, max));
}
case Axes.ForceZ:
{
return(new ForceZAxisReader(min, max));
}
case Axes.RotationX:
{
return(new RotationXAxisReader(min, max));
}
case Axes.RotationY:
{
return(new RotationYAxisReader(min, max));
}
case Axes.RotationZ:
{
return(new RotationZAxisReader(min, max));
}
case Axes.AngularVelocityX:
{
return(new AngularVelocityXAxisReader(min, max));
}
case Axes.AngularVelocityY:
{
return(new AngularVelocityYAxisReader(min, max));
}
case Axes.AngularVelocityZ:
{
return(new AngularVelocityZAxisReader(min, max));
}
case Axes.AngularAccelerationX:
{
return(new AngularAccelerationXAxisReader(min, max));
}
case Axes.AngularAccelerationY:
{
return(new AngularAccelerationYAxisReader(min, max));
}
case Axes.AngularAccelerationZ:
{
return(new AngularAccelerationZAxisReader(min, max));
}
case Axes.TorqueX:
{
return(new TorqueXAxisReader(min, max));
}
case Axes.TorqueY:
{
return(new TorqueYAxisReader(min, max));
}
case Axes.TorqueZ:
{
return(new TorqueZAxisReader(min, max));
}
default:
{
return(null);
}
}
}
public GraphData(TimeSpan startTime, string title,
ChartConfig chartConfig)
{
_startTime = startTime;
this.Title = title;
_clipMax = chartConfig.ClipMax;
LinearAcceleration = new LineSeries()
{
Title = "LinearAccelereation",
YAxisKey = "LinearAccelereation",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0xff, 0, 0),
};
AngularVelocity = new LineSeries()
{
Title = "AngularVelocity",
YAxisKey = "AngularVelocity",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0, 0xff, 0),
};
Angle = new LineSeries()
{
Title = "Angle",
YAxisKey = "Angle",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0, 0, 0xff),
};
Axes.Add(new LinearAxis
{
Key = "LinearAccelereation",
Position = AxisPosition.Left,
Minimum = chartConfig.LinearAccelerationMin,
Maximum = chartConfig.LinearAccelerationMax,
});
Axes.Add(new LinearAxis
{
Key = "AngularVelocity",
Position = AxisPosition.Left,
Minimum = chartConfig.AngularVelocityMin,
Maximum = chartConfig.AngularVelocityMax,
});
Axes.Add(new LinearAxis
{
Key = "Angle",
Position = AxisPosition.Left,
Minimum = chartConfig.AngleMin,
Maximum = chartConfig.AngleMax,
});
//Axes.Add(new LinearAxis
//{
// Position = AxisPosition.Left,
// Minimum = Math.Min(Math.Min(chartConfig.LinearAccelerationMin, chartConfig.AngularVelocityMin), chartConfig.AngleMin),
// Maximum = Math.Max(Math.Max(chartConfig.LinearAccelerationMax, chartConfig.AngularVelocityMax), chartConfig.AngleMax),
//});
this.IsLegendVisible = true;
this.Series.Add(LinearAcceleration);
this.Series.Add(AngularVelocity);
this.Series.Add(Angle);
//this.Series.Add(new FunctionSeries(Math.Cos, 0, 10, 0.1, "cos(x)"));
}
/// <summary>
/// Adds a plan instruction for simultaneous controll of two axes.
/// The instruction type has to be same for the axes.
/// </summary>
/// <param name="instructionX">instruction for the x axis.</param>
/// <param name="instructionY">instruction for the y axis.</param>
public void AddXY(StepInstrution instructionX, StepInstrution instructionY)
{
_plan.Add(Axes.XY(instructionX, instructionY));
}
protected bool Equals(ControllerState other)
{
return(Axes.SequenceEqual(other.Axes) && Buttons.SequenceEqual(other.Buttons) && Hats.SequenceEqual(other.Hats));
}
/// <summary>
/// Rotates a group of entities by a specified angle around a specified axis.
/// </summary>
/// <param name="entitiesToRotate">The group of entities that are to be rotated.</param>
/// <param name="rotationAxis">The axis around which the entities are to be rotated.</param>
/// <param name="rotationAngle">The angle by which the entities are to be rotated.</param>
/// <param name="copiesToCreate">The number of copies to create of the original entities.</param>
/// <param name="rotationOrigin">The origin of the rotation axis.</param>
/// <returns>A list of entities created by the operation. If numberOfCopies is 0, an .empty list is returned.</returns>
public static List <PSEntity> RotateEntities(
List <IPSRotateable> entitiesToRotate,
Axes rotationAxis,
DG.Degree rotationAngle,
int copiesToCreate,
DG.Point rotationOrigin = null)
{
// Get PowerSHAPE instance
_powerSHAPE = ((PSEntity)entitiesToRotate.First()).PowerSHAPE;
// Add all IRotatables
((PSEntity)entitiesToRotate.First()).AddToSelection(true);
int numberOfEntities = entitiesToRotate.Count();
for (int i = 1; i <= numberOfEntities - 1; i++)
{
((PSEntity)entitiesToRotate[i]).AddToSelection(false);
}
// Carry out operation
_powerSHAPE.DoCommand("EDIT ROTATE");
// Determine whether a copy is to be created
if (copiesToCreate == 0)
{
_powerSHAPE.DoCommand("NOKEEP");
}
else
{
_powerSHAPE.DoCommand("KEEP");
_powerSHAPE.DoCommand("COPIES " + copiesToCreate);
}
// If a different rotation origin has been defined, set it within PowerSHAPE
if (rotationOrigin != null)
{
_powerSHAPE.DoCommand("AXIS");
_powerSHAPE.DoCommand(rotationOrigin.ToString());
}
// Set the active plane, which determines the axis of rotation
_powerSHAPE.SetActivePlane(rotationAxis.AxisToPlane());
// Enter rotation angle
_powerSHAPE.DoCommand("ANGLE " + rotationAngle);
if (_powerSHAPE.Version >= new Version("11.2"))
{
_powerSHAPE.DoCommand("APPLY", "DISMISS");
}
else
{
_powerSHAPE.DoCommand("CANCEL");
}
// If no copies were made, return an empty list
if (copiesToCreate == 0)
{
return(new List <PSEntity>());
}
// If copies were made, add them to their appropriate collections and return new entities
List <PSEntity> copiedEntities = new List <PSEntity>();
foreach (PSEntity copiedEntity in _powerSHAPE.ActiveModel.CreatedItems)
{
_powerSHAPE.ActiveModel.Add(copiedEntity);
copiedEntities.Add(copiedEntity);
}
return(copiedEntities);
}
public static Vector3 PositionHandle(PositionHandleIDs handleIDs, Vector3 position, Axes enabledAxes = Axes.XYZ)
{
var activeGrid = Grid.ActiveGrid;
var rotation = Quaternion.LookRotation(activeGrid.Forward, activeGrid.Up);
return(PositionHandle(handleIDs, new[] { position }, position, rotation, enabledAxes)[0]);
}
public static Vector3 PositionHandleOffset(PositionHandleIDs handleIDs, Vector3 position, Axes enabledAxes = Axes.XYZ)
{
return(PositionHandle(handleIDs, position, enabledAxes) - position);
}
public static Vector3 Edge2DHandleOffset(int id, Vector3 from, Vector3 to, Vector3 slideDir1, Vector3 slideDir2, CapFunction capFunction = null, Axes axes = Axes.None, Vector3?snappingSteps = null, bool setCursor = true, bool renderEdge = true)
{
var midPoint = (from + to) * 0.5f;
var handleDir = Vector3.Cross(slideDir1, slideDir2);
return(SceneHandles.Edge2DHandleOffset(id, from, to, midPoint, handleDir, slideDir1, slideDir2, 0, capFunction, axes, snappingSteps, setCursor: setCursor, renderEdge: renderEdge));
}
public static Axes Combine(StepInstrution x, StepInstrution y, StepInstrution z)
{
return(Axes.UVXY(y, x, y, z));
}
public static Vector3[] PositionHandle(Vector3[] points, Vector3 position, Quaternion rotation, Axes enabledAxes = Axes.XYZ)
{
var handleIDs = new PositionHandleIDs();
SetPositionHandleIDs(ref handleIDs);
return(PositionHandle(handleIDs, points, position, rotation, enabledAxes));
}
public static Vector3[] PositionHandle(PositionHandleIDs handleIDs, Vector3[] points, Vector3 position, Quaternion rotation, Axes enabledAxes = Axes.XYZ)
{
var xAxisId = handleIDs.xAxisId;
var yAxisId = handleIDs.yAxisId;
var zAxisId = handleIDs.zAxisId;
var xzPlaneId = handleIDs.xzPlaneId;
var xyPlaneId = handleIDs.xyPlaneId;
var yzPlaneId = handleIDs.yzPlaneId;
var centerId = handleIDs.centerId;
var isStatic = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
var prevDisabled = SceneHandles.disabled;
var hotControl = GUIUtility.hotControl;
var xAxisIsHot = (xAxisId == hotControl);
var yAxisIsHot = (yAxisId == hotControl);
var zAxisIsHot = (zAxisId == hotControl);
var xzAxisIsHot = (xzPlaneId == hotControl);
var xyAxisIsHot = (xyPlaneId == hotControl);
var yzAxisIsHot = (yzPlaneId == hotControl);
var centerIsHot = (centerId == hotControl);
var isControlHot = xAxisIsHot || yAxisIsHot || zAxisIsHot || xzAxisIsHot || xyAxisIsHot || yzAxisIsHot || centerIsHot;
var handleSize = UnityEditor.HandleUtility.GetHandleSize(position);
var originalColor = SceneHandles.color;
var activeAxes = Snapping.ActiveAxes;
UnityEditor.HandleUtility.AddControl(centerId, UnityEditor.HandleUtility.DistanceToCircle(position, handleSize * 0.055f));
var evt = Event.current;
var type = evt.GetTypeForControl(centerId);
switch (type)
{
case EventType.MouseDown:
{
if (GUIUtility.hotControl != 0)
{
break;
}
if ((UnityEditor.HandleUtility.nearestControl != centerId || evt.button != 0) &&
(GUIUtility.keyboardControl != centerId || evt.button != 2))
{
break;
}
GUIUtility.hotControl = GUIUtility.keyboardControl = centerId;
evt.Use();
EditorGUIUtility.SetWantsMouseJumping(1);
break;
}
case EventType.MouseDrag:
{
if (GUIUtility.hotControl != centerId)
{
break;
}
break;
}
case EventType.MouseUp:
{
if (GUIUtility.hotControl == centerId && (evt.button == 0 || evt.button == 2))
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
evt.Use();
Snapping.ActiveAxes = Axes.XYZ;
EditorGUIUtility.SetWantsMouseJumping(0);
SceneView.RepaintAll();
}
break;
}
}
//,.,.., look at 2018.1 how the position handle works w/ colors
var xAxisDisabled = isStatic || prevDisabled || ((enabledAxes & Axes.X) == 0) || Snapping.AxisLocking[0] || (isControlHot && !xAxisIsHot && !xzAxisIsHot && !xyAxisIsHot);
var yAxisDisabled = isStatic || prevDisabled || ((enabledAxes & Axes.Y) == 0) || Snapping.AxisLocking[1] || (isControlHot && !yAxisIsHot && !xyAxisIsHot && !yzAxisIsHot);
var zAxisDisabled = isStatic || prevDisabled || ((enabledAxes & Axes.Z) == 0) || Snapping.AxisLocking[2] || (isControlHot && !zAxisIsHot && !xzAxisIsHot && !yzAxisIsHot);
var xzPlaneDisabled = isStatic || prevDisabled || ((enabledAxes & Axes.XZ) != Axes.XZ) || (Snapping.AxisLocking[0] || Snapping.AxisLocking[2]) || (isControlHot && !xzAxisIsHot);
var xyPlaneDisabled = isStatic || prevDisabled || ((enabledAxes & Axes.XY) != Axes.XY) || (Snapping.AxisLocking[0] || Snapping.AxisLocking[1]) || (isControlHot && !xyAxisIsHot);
var yzPlaneDisabled = isStatic || prevDisabled || ((enabledAxes & Axes.YZ) != Axes.YZ) || (Snapping.AxisLocking[1] || Snapping.AxisLocking[2]) || (isControlHot && !yzAxisIsHot);
var currentFocusControl = SceneHandleUtility.focusControl;
var xAxisIndirectlyFocused = (currentFocusControl == xyPlaneId || currentFocusControl == xzPlaneId);
var yAxisIndirectlyFocused = (currentFocusControl == xyPlaneId || currentFocusControl == yzPlaneId);
var zAxisIndirectlyFocused = (currentFocusControl == xzPlaneId || currentFocusControl == yzPlaneId);
var xAxisIndirectlyActive = activeAxes == Axes.XY || activeAxes == Axes.XZ;
var yAxisIndirectlyActive = activeAxes == Axes.XY || activeAxes == Axes.YZ;
var zAxisIndirectlyActive = activeAxes == Axes.XZ || activeAxes == Axes.YZ;
var xAxisSelected = xAxisIndirectlyFocused || xAxisIndirectlyActive || activeAxes == Axes.X;
var yAxisSelected = yAxisIndirectlyFocused || yAxisIndirectlyActive || activeAxes == Axes.Y;
var zAxisSelected = zAxisIndirectlyFocused || zAxisIndirectlyActive || activeAxes == Axes.Z;
var xzAxiSelected = activeAxes == Axes.XZ;
var xyAxiSelected = activeAxes == Axes.XZ;
var yzAxiSelected = activeAxes == Axes.YZ;
var xAxisColor = SceneHandles.StateColor(SceneHandles.xAxisColor, xAxisDisabled, xAxisSelected);
var yAxisColor = SceneHandles.StateColor(SceneHandles.yAxisColor, yAxisDisabled, yAxisSelected);
var zAxisColor = SceneHandles.StateColor(SceneHandles.zAxisColor, zAxisDisabled, zAxisSelected);
var xzPlaneColor = SceneHandles.StateColor(SceneHandles.yAxisColor, xzPlaneDisabled, xzAxiSelected);
var xyPlaneColor = SceneHandles.StateColor(SceneHandles.zAxisColor, xyPlaneDisabled, xyAxiSelected);
var yzPlaneColor = SceneHandles.StateColor(SceneHandles.xAxisColor, yzPlaneDisabled, yzAxiSelected);
SceneHandles.disabled = xAxisDisabled;
SceneHandles.color = xAxisColor;
points = Slider1DHandle(xAxisId, Axis.X, points, position, rotation * Vector3.right, Snapping.MoveSnappingSteps.x, handleSize, ArrowHandleCap, selectLockingAxisOnClick: true);
SceneHandles.disabled = yAxisDisabled;
SceneHandles.color = yAxisColor;
points = Slider1DHandle(yAxisId, Axis.Y, points, position, rotation * Vector3.up, Snapping.MoveSnappingSteps.y, handleSize, ArrowHandleCap, selectLockingAxisOnClick: true);
SceneHandles.disabled = zAxisDisabled;
SceneHandles.color = zAxisColor;
points = Slider1DHandle(zAxisId, Axis.Z, points, position, rotation * Vector3.forward, Snapping.MoveSnappingSteps.z, handleSize, ArrowHandleCap, selectLockingAxisOnClick: true);
SceneHandles.disabled = xzPlaneDisabled;
SceneHandles.color = xzPlaneColor;
points = PlanarHandle(xzPlaneId, PlaneAxes.XZ, points, position, rotation, handleSize * 0.3f, selectLockingAxisOnClick: true);
SceneHandles.disabled = xyPlaneDisabled;
SceneHandles.color = xyPlaneColor;
points = PlanarHandle(xyPlaneId, PlaneAxes.XY, points, position, rotation, handleSize * 0.3f, selectLockingAxisOnClick: true);
SceneHandles.disabled = yzPlaneDisabled;
SceneHandles.color = yzPlaneColor;
points = PlanarHandle(yzPlaneId, PlaneAxes.YZ, points, position, rotation, handleSize * 0.3f, selectLockingAxisOnClick: true);
switch (type)
{
case EventType.Repaint:
{
SceneHandles.color = SceneHandles.StateColor(SceneHandles.centerColor, false, centerId == SceneHandleUtility.focusControl);
SceneHandles.RenderBorderedCircle(position, handleSize * 0.05f);
break;
}
}
SceneHandles.disabled = prevDisabled;
SceneHandles.color = originalColor;
return(points);
}
public virtual XPathNodeIterator SelectAncestors(XPathNodeType type, bool matchSelf)
{
Axes axis = (matchSelf) ? Axes.AncestorOrSelf : Axes.Ancestor;
return(SelectTest(new NodeTypeTest(axis, type)));
}
public TestRulesetContainer(Axes scrollingAxes, WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(null, beatmap, isForCurrentRuleset)
{
this.scrollingAxes = scrollingAxes;
}
/// <summary>Retrieves the state of the specified axis</summary>
/// <param name="axis">Axis whose state will be retrieved</param>
/// <returns>The state of the specified axis</returns>
public float GetAxis(Axes axis)
{
switch (axis)
{
case Axes.X:
{
return(this.X);
}
case Axes.Y:
{
return(this.Y);
}
case Axes.Z:
{
return(this.Z);
}
case Axes.VelocityX:
{
return(this.VelocityX);
}
case Axes.VelocityY:
{
return(this.VelocityY);
}
case Axes.VelocityZ:
{
return(this.VelocityZ);
}
case Axes.AccelerationX:
{
return(this.AccelerationX);
}
case Axes.AccelerationY:
{
return(this.AccelerationY);
}
case Axes.AccelerationZ:
{
return(this.AccelerationZ);
}
case Axes.ForceX:
{
return(this.ForceX);
}
case Axes.ForceY:
{
return(this.ForceY);
}
case Axes.ForceZ:
{
return(this.ForceZ);
}
case Axes.RotationX:
{
return(this.RotationX);
}
case Axes.RotationY:
{
return(this.RotationY);
}
case Axes.RotationZ:
{
return(this.RotationZ);
}
case Axes.AngularVelocityX:
{
return(this.AngularVelocityX);
}
case Axes.AngularVelocityY:
{
return(this.AngularVelocityY);
}
case Axes.AngularVelocityZ:
{
return(this.AngularVelocityZ);
}
case Axes.AngularAccelerationX:
{
return(this.AngularAccelerationX);
}
case Axes.AngularAccelerationY:
{
return(this.AngularAccelerationY);
}
case Axes.AngularAccelerationZ:
{
return(this.AngularAccelerationZ);
}
case Axes.TorqueX:
{
return(this.TorqueX);
}
case Axes.TorqueY:
{
return(this.TorqueY);
}
case Axes.TorqueZ:
{
return(this.TorqueZ);
}
default:
{
throw new ArgumentOutOfRangeException("axis", "Invalid axis");
}
}
}
public static Vector3 PositionHandle(Vector3 position, Quaternion rotation, Axes enabledAxes = Axes.XYZ)
{
return(PositionHandle(new[] { position }, position, rotation, enabledAxes)[0]);
}
public ControllerState(List <double> axes, List <bool> buttons, List <Hat> hats)
{
Axes.AddRange(axes);
Buttons.AddRange(buttons);
Hats.AddRange(hats);
}
private void DrawGridGraphics(Camera cam, Axes camAxis, Color col)
{
previousColor = Handles.color;
Handles.color = col;
// !-- TODO: Update this stuff only when necessary. Currently it runs evvverrrryyy frame
Vector3 bottomLeft = SnapToFloor(cam.ScreenToWorldPoint(Vector2.zero));
Vector3 bottomRight = SnapToFloor(cam.ScreenToWorldPoint(new Vector2(cam.pixelWidth, 0f)));
Vector3 topLeft = SnapToFloor(cam.ScreenToWorldPoint(new Vector2(0f, cam.pixelHeight)));
Vector3 topRight = SnapToFloor(cam.ScreenToWorldPoint(new Vector2(cam.pixelWidth, cam.pixelHeight)));
Vector3 axis = VectorWithAxes(camAxis);
float width = Vector3.Distance(bottomLeft, bottomRight);
float height = Vector3.Distance(bottomRight, topRight);
// Shift lines to 1m forward of the camera
bottomLeft += axis * 2;
topRight += axis * 2;
bottomRight += axis * 2;
topLeft += axis * 2;
/**
* Draw Vertical Lines
* Add two because we want the grid to cover the entire screen.
*/
Vector3 start = bottomLeft - cam.transform.up * (height + snapValue * 2);
Vector3 end = bottomLeft + cam.transform.up * (height + snapValue * 2);
float _snapVal = snapValue;
int segs = (int)Mathf.Ceil(width / _snapVal) + 2;
float n = 2;
while (segs > MAX_LINES)
{
_snapVal = _snapVal * n;
segs = (int)Mathf.Ceil(width / _snapVal);
n++;
}
for (int i = -1; i < segs; i++)
{
Handles.DrawLine(
start + (i * (cam.transform.right * _snapVal)),
end + (i * (cam.transform.right * _snapVal)));
}
/**
* Draw Horizontal Lines
*/
start = topLeft - cam.transform.right * (width + snapValue * 2);
end = topLeft + cam.transform.right * (width + snapValue * 2);
segs = (int)Mathf.Ceil(height / _snapVal) + 2;
n = 1;
while (segs > MAX_LINES)
{
_snapVal = _snapVal * n;
n++;
segs = (int)Mathf.Ceil(height / _snapVal);
}
for (int i = -1; i < segs; i++)
{
Handles.DrawLine(
start + (i * (-cam.transform.up * _snapVal)),
end + (i * (-cam.transform.up * _snapVal)));
}
#if PRO
if (drawAngles)
{
Vector3 cen = SnapValue(((topRight + bottomLeft) / 2f));
float half = (width > height) ? width : height;
float opposite = Mathf.Tan(Mathf.Deg2Rad * angleValue) * half;
Vector3 up = cam.transform.up * opposite;
Vector3 right = cam.transform.right * half;
Vector3 bottomLeftAngle = cen - (up + right);
Vector3 topRightAngle = cen + (up + right);
Vector3 bottomRightAngle = cen + (right - up);
Vector3 topLeftAngle = cen + (up - right);
// y = 1x+1
Handles.DrawLine(bottomLeftAngle, topRightAngle);
// y = -1x-1
Handles.DrawLine(topLeftAngle, bottomRightAngle);
}
#endif
Handles.color = previousColor;
}
/// <summary>
/// Adds a plan instruction for simultaneous controll of all axes.
/// The instruction type has to be same for the axes.
/// </summary>
/// <param name="instructionU">instruction for the u axis.</param>
/// <param name="instructionV">instruction for the v axis.</param>
/// <param name="instructionX">instruction for the x axis.</param>
/// <param name="instructionY">instruction for the y axis.</param>
public void AddUVXY(StepInstrution instructionU, StepInstrution instructionV, StepInstrution instructionX, StepInstrution instructionY)
{
_plan.Add(Axes.UVXY(instructionU, instructionV, instructionX, instructionY));
}
private static void GameOnDraw(EventArgs args)
{
var colorQ = MainMenu.Draw.GetColor("color.q");
var widthQ = MainMenu.Draw.GetWidth("width.q");
var colorW = MainMenu.Draw.GetColor("color.w");
var widthW = MainMenu.Draw.GetWidth("width.w");
var colorE = MainMenu.Draw.GetColor("color.e");
var widthE = MainMenu.Draw.GetWidth("width.e");
var colorR = MainMenu.Draw.GetColor("color.r");
var widthR = MainMenu.Draw.GetWidth("width.r");
if (!Value.Use("draw.disable"))
{
if (Value.Use("draw.q") && ((Value.Use("draw.ready") && _q.IsReady()) || !Value.Use("draw.ready")))
{
if (GetBestAxe != null)
{
_axeLocation.Color = colorQ;
_axeLocation.Radius = widthQ;
_axeLocation.Draw(GetBestAxe.Object.Position);
}
foreach (
var axe in
Axes.Where(x => x.Object.NetworkId != (GetBestAxe != null ? GetBestAxe.Object.NetworkId : 0))
)
{
_axeLocation.Color = colorQ;
_axeLocation.Radius = widthQ;
_axeLocation.Draw(axe.Object.Position);
}
}
if (Value.Use("draw.w") && ((Value.Use("draw.ready") && _w.IsReady()) || !Value.Use("draw.ready")))
{
new Circle
{
Color = colorW,
Radius = _w.Range,
BorderWidth = widthW
}.Draw(Player.Instance.Position);
}
if (Value.Use("draw.e") && ((Value.Use("draw.ready") && _e.IsReady()) || !Value.Use("draw.ready")))
{
new Circle
{
Color = colorE,
Radius = _e.Range,
BorderWidth = widthE
}.Draw(Player.Instance.Position);
}
if (Value.Use("draw.r") && ((Value.Use("draw.ready") && _r.IsReady()) || !Value.Use("draw.ready")))
{
new Circle
{
Color = colorR,
Radius = _q.Range,
BorderWidth = widthR
}.Draw(Player.Instance.Position);
}
if (Value.Use("draw.axe.catch") &&
((Value.Use("draw.ready") && _q.IsReady()) || !Value.Use("draw.ready")))
{
new Circle
{
Color = colorQ,
Radius = Value.Get("misc.axe.range"),
BorderWidth = widthQ
}.Draw(Game.CursorPos);
}
}
}
public AxisSpecifier(Axes axis)
{
this._axis = axis;
}
public override int GetHashCode()
{
return(Axes.GetHashCode());
}
/// <summary>Returns the axis index from a value in the axis enumeration</summary>
/// <param name="axis">Axis enumeration values whose index will be returned</param>
/// <returns>The index of the specified axis enumeration value</returns>
private static int indexFromAxis(Axes axis)
{
switch (axis)
{
case Axes.X:
{
return(0);
}
case Axes.Y:
{
return(1);
}
case Axes.Z:
{
return(2);
}
case Axes.VelocityX:
{
return(3);
}
case Axes.VelocityY:
{
return(4);
}
case Axes.VelocityZ:
{
return(5);
}
case Axes.AccelerationX:
{
return(6);
}
case Axes.AccelerationY:
{
return(7);
}
case Axes.AccelerationZ:
{
return(8);
}
case Axes.ForceX:
{
return(9);
}
case Axes.ForceY:
{
return(10);
}
case Axes.ForceZ:
{
return(11);
}
case Axes.RotationX:
{
return(12);
}
case Axes.RotationY:
{
return(13);
}
case Axes.RotationZ:
{
return(14);
}
case Axes.AngularVelocityX:
{
return(15);
}
case Axes.AngularVelocityY:
{
return(16);
}
case Axes.AngularVelocityZ:
{
return(17);
}
case Axes.AngularAccelerationX:
{
return(18);
}
case Axes.AngularAccelerationY:
{
return(19);
}
case Axes.AngularAccelerationZ:
{
return(20);
}
case Axes.TorqueX:
{
return(21);
}
case Axes.TorqueY:
{
return(22);
}
case Axes.TorqueZ:
{
return(23);
}
default:
{
return(-1);
}
}
}
/// <summary>
/// glb をパースして、UnityObject化、さらにAsset化する
/// </summary>
/// <param name="scriptedImporter"></param>
/// <param name="context"></param>
/// <param name="reverseAxis"></param>
protected static void Import(ScriptedImporter scriptedImporter, AssetImportContext context, Axes reverseAxis, RenderPipelineTypes renderPipeline)
{
#if VRM_DEVELOP
Debug.Log("OnImportAsset to " + scriptedImporter.assetPath);
#endif
//
// Import(create unity objects)
//
// 2 回目以降の Asset Import において、 Importer の設定で Extract した UnityEngine.Object が入る
var extractedObjects = scriptedImporter.GetExternalObjectMap()
.Where(x => x.Value != null)
.ToDictionary(kv => new SubAssetKey(kv.Value.GetType(), kv.Key.name), kv => kv.Value);
IMaterialDescriptorGenerator materialGenerator = GetMaterialGenerator(renderPipeline);
using (var data = new AutoGltfFileParser(scriptedImporter.assetPath).Parse())
using (var loader = new ImporterContext(data, extractedObjects, materialGenerator: materialGenerator))
{
// Configure TextureImporter to Extracted Textures.
foreach (var textureInfo in loader.TextureDescriptorGenerator.Get().GetEnumerable())
{
TextureImporterConfigurator.Configure(textureInfo, loader.TextureFactory.ExternalTextures);
}
loader.InvertAxis = reverseAxis;
var loaded = loader.Load();
loaded.ShowMeshes();
loaded.TransferOwnership((k, o) =>
{
context.AddObjectToAsset(k.Name, o);
});
var root = loaded.Root;
GameObject.DestroyImmediate(loaded);
context.AddObjectToAsset(root.name, root);
context.SetMainObject(root);
}
}
public static Vector3 SnapPoint(Vector3 position, Axes enabledAxes = Axes.XYZ)
{
return(SnapPoint(position, Grid.defaultGrid, enabledAxes));
}
public static void Main(string[] args)
{
Application
ExcelApp = null;
Workbook
Workbook = null;
Sheets
Sheets = null,
Charts = null;
Worksheet
Sheet = null;
Chart
Chart = null;
Series
Series = null;
Axes
Axes = null;
Axis
Axis = null;
Range
Range = null,
Range2 = null;
object
tmpObject;
try
{
try
{
string
CurrentDirectory = System.IO.Directory.GetCurrentDirectory();
CurrentDirectory = CurrentDirectory.Substring(0, CurrentDirectory.LastIndexOf("bin", CurrentDirectory.Length - 1));
string
//InputFileName = CurrentDirectory + "test.xls",
InputFileName = "d:\\result.xlsx",
OutputDbf = CurrentDirectory + "xls2dbf.dbf";
try
{
ExcelApp = (Application)Marshal.GetActiveObject("Excel.Application");
}
catch (COMException eException)
{
if (eException.ErrorCode == -2147221021)
{
ExcelApp = new Application();
}
}
ExcelApp.Visible = true;
ExcelApp.DisplayAlerts = false;
ExcelApp.UserControl = false;
#if TEST_DATE
Workbook = ExcelApp.Workbooks.Add(Type.Missing);
Sheet = (Worksheet)Workbook.ActiveSheet;
Sheet.Columns.get_Range("A1", "A1").ColumnWidth = 3;
Sheet.get_Range("A1", Type.Missing).Value = "01.01.2001";
tmpObject = Sheet.get_Range("A1", Type.Missing).Value;
Workbook.Close(Type.Missing, Type.Missing, Type.Missing);
#endif
Workbook = ExcelApp.Workbooks.Open(InputFileName, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
#if TEST_SAVE_AS
if (File.Exists(OutputDbf))
{
File.Delete(OutputDbf);
}
Workbook.SaveAs(OutputDbf, XlFileFormat.xlDBF4, Type.Missing, Type.Missing, Type.Missing, Type.Missing, XlSaveAsAccessMode.xlNoChange, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
#endif
Sheets = Workbook.Worksheets;
Sheet = (Worksheet)Workbook.ActiveSheet;
double
points = ExcelApp.CentimetersToPoints(1.93d);
points = ExcelApp.CentimetersToPoints(2.70d);
points = ExcelApp.CentimetersToPoints(3.55d);
int
MaxRow = Sheet.Cells.SpecialCells(XlCellType.xlCellTypeLastCell, Type.Missing).Row,
MaxCol = Sheet.Cells.SpecialCells(XlCellType.xlCellTypeLastCell, Type.Missing).Column;
Range = Sheet.get_Range("A1", Type.Missing);
Range = Range.get_End(XlDirection.xlToRight);
Range = Range.get_End(XlDirection.xlDown);
string
CurrAddress = Range.get_Address(false, false, XlReferenceStyle.xlA1, Type.Missing, Type.Missing);
Range = Sheet.get_Range("A1", CurrAddress);
CurrAddress = ColNoToName(MaxCol) + Convert.ToString(MaxRow);
Range = Sheet.get_Range("A1", CurrAddress);
object[,]
values = (object[, ])Range.Value2;
int
MaxI = values.GetLength(0), // Row
MaxJ = values.GetLength(1); // Col
string
tmpString = string.Empty;
for (int i = 1; i <= MaxI; ++i) // Row
{
for (int j = 1; j <= MaxJ; ++j) // Col
{
tmpString += "[" + i + "," + j + "]=" + (values[i, j] != null ? values[i, j] : "null");
if (j <= MaxJ - 1)
{
tmpString += "\t";
}
}
tmpString += Environment.NewLine;
}
Console.WriteLine(tmpString);
Range = Sheet.get_Range("A10", "E18");
//Range.Formula=values;
Range.Value = values;
Range = Sheet.get_Range(Sheet.Cells[1, 1], Sheet.Cells[10, 10]);
tmpObject = ((Range)Range.get_Item(1, 1)).Value;
Sheet.get_Range("A23", Type.Missing).Value = "A23";
tmpString = Convert.ToString(Sheet.get_Range("A23", Type.Missing).Value);
Sheet.get_Range("A24", "C24").Merge(true);
for (int _i = 1; _i <= 10; ++_i)
{
Sheet.get_Range("F" + _i, Type.Missing).Value = _i;
}
Sheet.get_Range("F11", Type.Missing).Formula = "=яслл(F1:F10)";
Sheet.get_Range("F11", Type.Missing).Orientation = 30;
Sheet.get_Range("F11", Type.Missing).Font.Bold = true;
Sheet.get_Range("F11", Type.Missing).Font.Size = 25;
Range = Sheet.get_Range("F2", Type.Missing);
tmpObject = -4121; // 0xFFFFEFE7; /* xlShiftDown */
Range.Rows.Insert(tmpObject);
Range.Rows.Insert(Type.Missing);
Sheet.get_Range("F2", Type.Missing).Value = 999;
Sheet = (Worksheet)Sheets.get_Item(2);
Sheet.Activate();
string
CellDirect,
CellObject;
#region bool
CellDirect = "E1";
CellObject = "E2";
tmpString = "bool";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F1";
CellObject = "F2";
Sheet.get_Range(CellDirect, Type.Missing).Value = true;
bool
tmpBool = true;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpBool;
#endregion
#region byte
CellDirect = "E3";
CellObject = "E4";
tmpString = "byte";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F3";
CellObject = "F4";
Sheet.get_Range(CellDirect, Type.Missing).Value = 255;
byte
tmpByte = 255;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpByte;
#endregion
#region sbyte
CellDirect = "E5";
CellObject = "E6";
tmpString = "sbyte";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F5";
CellObject = "F6";
Sheet.get_Range(CellDirect, Type.Missing).Value = 127;
sbyte
tmpSByte = 127;
// !!!
Sheet.get_Range(CellObject, Type.Missing).Value = (int)tmpSByte;
#endregion
#region short
CellDirect = "E7";
CellObject = "E8";
tmpString = "short";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F7";
CellObject = "F8";
Sheet.get_Range(CellDirect, Type.Missing).Value = 32767;
short
tmpShort = 32767;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpShort;
#endregion
#region ushort
CellDirect = "E9";
CellObject = "E10";
tmpString = "ushort";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F9";
CellObject = "F10";
Sheet.get_Range(CellDirect, Type.Missing).Value = 65535;
ushort
tmpUShort = 65535;
// !!!
Sheet.get_Range(CellObject, Type.Missing).Value = (int)tmpUShort;
#endregion
#region int
CellDirect = "E11";
CellObject = "E12";
tmpString = "int";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F11";
CellObject = "F12";
Sheet.get_Range(CellDirect, Type.Missing).Value = 2147483647;
int
tmpInt = 2147483647;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpInt;
#endregion
#region uint
CellDirect = "E13";
CellObject = "E14";
tmpString = "uint";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F13";
CellObject = "F14";
// !!!
Sheet.get_Range(CellDirect, Type.Missing).Value = (double)4294967295U;
uint
tmpUInt = 4294967295U;
// !!!
Sheet.get_Range(CellObject, Type.Missing).Value = (double)tmpUInt;
#endregion
#region long
CellDirect = "E15";
CellObject = "E16";
tmpString = "long";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F15";
CellObject = "F16";
Sheet.get_Range(CellDirect, Type.Missing).Value = (double)999999999999999L;
//Sheet.get_Range(CellDirect,Type.Missing).Value=9223372036854775807L;
long
tmpLong = 999999999999999L; //9223372036854775807L;
Sheet.get_Range(CellObject, Type.Missing).Value = (double)tmpLong;
#endregion
#region ulong
CellDirect = "E17";
CellObject = "E18";
tmpString = "ulong";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F17";
CellObject = "F18";
//Sheet.get_Range(CellDirect,Type.Missing).Value=18446744073709551615UL;
ulong
tmpULong = 18446744073709551615UL;
//Sheet.get_Range(CellObject,Type.Missing).Value=tmpULong;
#endregion
#region DateTime
CellDirect = "E19";
CellObject = "E20";
tmpString = "DateTime";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F19";
CellObject = "F20";
Sheet.get_Range(CellDirect, Type.Missing).Value = DateTime.Now;
DateTime
tmpDateTime = DateTime.Now;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpDateTime;
#endregion
#region TimeSpan
CellDirect = "E21";
CellObject = "E22";
tmpString = "TimeSpan";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F21";
CellObject = "F22";
tmpDateTime = new DateTime(0L);
// !!!
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpDateTime + (new TimeSpan(1, 2, 3));
TimeSpan
tmpTimeSpan = new TimeSpan(1, 2, 3);
// !!!
tmpDateTime = new DateTime(0L);
tmpDateTime += tmpTimeSpan;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpDateTime;
#endregion
#region float
CellDirect = "E23";
CellObject = "E24";
tmpString = "float";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F23";
CellObject = "F24";
Sheet.get_Range(CellDirect, Type.Missing).Value = 9999.9999F;
float
tmpFloat = 9999.9999F;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpFloat;
#endregion
#region double
CellDirect = "E25";
CellObject = "E26";
tmpString = "double";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F25";
CellObject = "F26";
Sheet.get_Range(CellDirect, Type.Missing).Value = 1.7E+3;
double
tmpDouble = 1.7E+3;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpDouble;
#endregion
#region decimal
CellDirect = "E27";
CellObject = "E28";
tmpString = "decimal";
Sheet.get_Range(CellDirect, Type.Missing).Value = tmpString;
Sheet.get_Range(CellObject, Type.Missing).Value = tmpString;
CellDirect = "F27";
CellObject = "F28";
// !!!
Sheet.get_Range(CellDirect, Type.Missing).Value = (double)999999999.99m;
decimal
tmpDecimal = 999999999.99m;
// !!!
Sheet.get_Range(CellObject, Type.Missing).Value = (double)tmpDecimal;
#endregion
Sheet = (Worksheet)Sheets.get_Item(3);
Range = Sheet.get_Range("A1", "A5");
Range.Value = "Some Value";
Range2 = Sheet.get_Range("A11", "A15");
Range.Copy(Range2);
Range = Sheet.get_Range("B1", "B5");
Range.Value = "Some Value";
Range.Copy(Type.Missing);
Range2 = Sheet.get_Range("B11", "B15");
Sheet.Paste(Range2, Type.Missing);
Range2 = Sheet.get_Range("B20", Type.Missing);
Sheet.Activate();
Range2.Select();
Sheet.Paste(Type.Missing, Type.Missing);
#if TEST_CHART
Sheet = (Excel.Worksheet)Sheets.get_Item(3);
Sheet.Activate();
for (int Col = 1; Col <= 20; ++Col)
{
Sheet.get_Range("A" + Col, Type.Missing).Value = Col;
Sheet.get_Range("B" + Col, Type.Missing).Formula = "=sin(A" + Col + ")";
Sheet.get_Range("C" + Col, Type.Missing).Formula = "=cos(A" + Col + ")";
Sheet.get_Range("D" + Col, Type.Missing).Formula = "=B" + Col + "+C" + Col;
}
Sheets.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);
Charts = ExcelApp.Charts;
Chart = (Excel.Chart)Charts.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);
//Chart.Type=65; // xlLineMarkers
Chart.Type = 4; // xlLine
Chart.SetSourceData(Sheet.get_Range("B1", "C20"), 2 /*xlColumns*/);
Chart = Chart.Location(XlChartLocation.xlLocationAsObject, "кХЯР4");
Series = ((Excel.SeriesCollection)Chart.SeriesCollection(Type.Missing)).NewSeries();
MaxI = ((Excel.SeriesCollection)Chart.SeriesCollection(Type.Missing)).Count;
Range = Sheet.get_Range("A1", "A20");
for (int i = MaxI; i > 0; --i)
{
((Excel.Series)Chart.SeriesCollection(i)).XValues = Range;
switch (i)
{
case 1:
{
((Excel.Series)Chart.SeriesCollection(i)).Name = "sin";
break;
}
case 2:
{
((Excel.Series)Chart.SeriesCollection(i)).Name = "cos";
break;
}
}
}
Range = Sheet.get_Range("D1", "D20");
Series.Values = Range;
Series.Name = "sin+cos";
Chart.HasTitle = true;
Chart.ChartTitle.Caption = "Name of Chart";
Axis = (Excel.Axis)Chart.Axes(1 /*xlCategory*/, XlAxisGroup.xlPrimary);
Axis.HasTitle = true;
Axis.CategoryNames = "Name of Category";
Axis = (Excel.Axis)Chart.Axes(2 /*xlValue*/, XlAxisGroup.xlPrimary);
Axis.HasTitle = true;
Chart.HasLegend = true;
Chart.Legend.Position = XlLegendPosition.xlLegendPositionBottom;
#endif
ExcelApp.Quit();
}
catch (COMException eException)
{
string
tmp = eException.GetType().FullName + Environment.NewLine + "ErrorCode: " + eException.ErrorCode + Environment.NewLine + "Message: " + eException.Message + Environment.NewLine + "StackTrace:" + Environment.NewLine + eException.StackTrace;
Console.WriteLine(tmp);
}
catch (ArgumentException eException)
{
string
tmp = eException.GetType().FullName + Environment.NewLine + "ParamName: " + eException.ParamName + Environment.NewLine + "Message: " + eException.Message + Environment.NewLine + "StackTrace:" + Environment.NewLine + eException.StackTrace;
Console.WriteLine(tmp);
}
catch (Exception eException)
{
string
tmp = eException.GetType().FullName + Environment.NewLine + "Message: " + eException.Message + Environment.NewLine + "StackTrace:" + Environment.NewLine + eException.StackTrace;
Console.WriteLine(tmp);
}
}
finally
{
if (Axes != null)
{
Marshal.ReleaseComObject(Axes);
Axes = null;
}
if (Axis != null)
{
Marshal.ReleaseComObject(Axis);
Axis = null;
}
if (Series != null)
{
Marshal.ReleaseComObject(Series);
Series = null;
}
if (Chart != null)
{
Marshal.ReleaseComObject(Chart);
Chart = null;
}
if (Charts != null)
{
Marshal.ReleaseComObject(Charts);
Charts = null;
}
if (Range2 != null)
{
Marshal.ReleaseComObject(Range2);
Range2 = null;
}
if (Range != null)
{
Marshal.ReleaseComObject(Range);
Range = null;
}
if (Sheets != null)
{
Marshal.ReleaseComObject(Sheets);
Sheets = null;
}
if (Sheet != null)
{
Marshal.ReleaseComObject(Sheet);
Sheet = null;
}
if (Workbook != null)
{
Marshal.ReleaseComObject(Workbook);
Workbook = null;
}
if (ExcelApp != null)
{
ExcelApp.Quit();
Marshal.ReleaseComObject(ExcelApp);
ExcelApp = null;
}
//GC.Collect();
GC.GetTotalMemory(true);
}
}
private Axis FindModelAxis(AxisBase a)
{
return(Axes.FirstOrDefault(axis => axis.ModelAxis == a));
}
public virtual XPathNodeIterator SelectDescendants(XPathNodeType type, bool matchSelf)
{
Axes axis = (matchSelf) ? Axes.DescendantOrSelf : Axes.Descendant;
return(SelectTest(new NodeTypeTest(axis, type)));
}
public static Vector4 SetValues(this Vector4 vector, Vector4 values, Axes axis)
{
vector.x = axis.Contains(Axes.X) ? values.x : vector.x;
vector.y = axis.Contains(Axes.Y) ? values.y : vector.y;
vector.z = axis.Contains(Axes.Z) ? values.z : vector.z;
vector.w = axis.Contains(Axes.W) ? values.w : vector.w;
return vector;
}
public void Reset()
{
Series.Clear();
Axes.Clear();
Annotations.Clear();
}
public static Vector4 Div(this Vector4 vector, Vector3 otherVector, Axes axis)
{
return vector.Div((Vector4)otherVector, axis);
}
void DrawRotation()
{
GUILayout.BeginHorizontal();
{
bool reset = GUILayout.Button("R", GUILayout.Width(20f));
Vector3 visible = (serializedObject.targetObject as Transform).localEulerAngles;
visible.x = WrapAngle(visible.x);
visible.y = WrapAngle(visible.y);
visible.z = WrapAngle(visible.z);
Axes changed = CheckDifference(mRot);
Axes altered = Axes.None;
GUILayoutOption opt = GUILayout.MinWidth(30f);
if (FloatField("X", ref visible.x, (changed & Axes.X) != 0, false, opt))
{
altered |= Axes.X;
}
if (FloatField("Y", ref visible.y, (changed & Axes.Y) != 0, false, opt))
{
altered |= Axes.Y;
}
if (FloatField("Z", ref visible.z, (changed & Axes.Z) != 0, false, opt))
{
altered |= Axes.Z;
}
if (reset)
{
mRot.quaternionValue = Quaternion.identity;
}
else if (altered != Axes.None)
{
RegisterUndo("Change Rotation", serializedObject.targetObjects);
foreach (Object obj in serializedObject.targetObjects)
{
Transform t = obj as Transform;
Vector3 v = t.localEulerAngles;
if ((altered & Axes.X) != 0)
{
v.x = visible.x;
}
if ((altered & Axes.Y) != 0)
{
v.y = visible.y;
}
if ((altered & Axes.Z) != 0)
{
v.z = visible.z;
}
t.localEulerAngles = v;
}
}
}
GUILayout.EndHorizontal();
}
