public static MatrixTransform3D Rotate3D(Transform3D transform, double x, double y, double z, Point3D center, Vector3D up, Vector3D look, RotationType type)
{
if (type != RotationType.LockAxisY)
{
up = transform.Transform(up);
}
if (type != RotationType.LockAxisZ)
{
look = transform.Transform(look);
}
center = transform.Transform(center);
Vector3D axisX = Vector3D.CrossProduct(up, look);
Matrix3D matrix = new Matrix3D();
matrix.RotateAt(new Quaternion(axisX, x), center);
matrix.RotateAt(new Quaternion(up, y), center);
matrix.RotateAt(new Quaternion(look, z), center);
MatrixTransform3D mOriginTransform = transform as MatrixTransform3D;
//mOriginTransform.Matrix.RotateAt(
try
{
return new MatrixTransform3D(Matrix3D.Multiply(mOriginTransform.Matrix, matrix));
}
catch (Exception err)
{
Exceptions.LogOnly(err);
return null;
}
}
// *** METHODS ***
/// <summary>
/// Rotates the point around a particular axis
/// </summary>
/// <param name="type">Rotation axis</param>
/// <param name="angleInDeg">Angle to be rotated</param>
public void Rotate(RotationType type, double angleInDeg)
{
// Rotation matrix: http://de.wikipedia.org/wiki/Drehmatrix
var rad = angleInDeg * Math.PI / 180;
var cosa = Math.Cos(rad);
var sina = Math.Sin(rad);
var x = this.X;
var y = this.Y;
var z = this.Z;
switch (type)
{
case RotationType.X:
this.Y = y * cosa - z * sina;
this.Z = y * sina + z * cosa;
break;
case RotationType.Y:
this.X = z * sina + x * cosa;
this.Z = z * cosa - x * sina;
break;
case RotationType.Z:
this.X = x * cosa - y * sina;
this.Y = x * sina + y * cosa;
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
//GC.Collect();
}
public static Matrix3D CalcRotationMatrix(double x, double y, double z, Point3D center, Vector3D up, Vector3D look, Transform3D transform, RotationType type)
{
//Transform3DGroup trm = new Transform3DGroup();
//trm.Children.Add(transform);
Vector3D realup = transform.Transform(up);
if (type != RotationType.LockAxisY)
{
up = realup;
}
if (type != RotationType.LockAxisZ)
{
look = transform.Transform(look);
}
center = transform.Transform(center);
Vector3D axisX = Vector3D.CrossProduct(up, look);
Matrix3D matrix = new Matrix3D();
//Quaternion q = new Quaternion();
//q.
double ang = AngleBetween(realup, YAxis) + x;
if (ang >= 90)
{
x = 90 - ang;
}
matrix.RotateAt(new Quaternion(axisX, x), center);
matrix.RotateAt(new Quaternion(up, y), center);
matrix.RotateAt(new Quaternion(look, z), center);
return matrix;
}
// Update is called once per frame
void Update ()
{
//Sólo si no se está rotando en este momento
if(rotationType != RotationType.none)
{
//Cantidad a rotar
float quantityRotation = Time.deltaTime * speedRotation;
//Cantidad acumulada
accumulatedRotation += quantityRotation;
//¿Nos hemos pasado de 90?
if(accumulatedRotation > ROTATION_QUANTITY)
{
//Descontamos quantityRotation
accumulatedRotation -= quantityRotation;
//Calculamos lo que falta para 90
quantityRotation = ROTATION_QUANTITY - accumulatedRotation;
//Rotamos
Rotate(quantityRotation);
//El próximo Update ya no se rota
rotationType = RotationType.none;
}
else
{
//Rotamos
Rotate(quantityRotation);
}
}
}
protected BlockFace()
{
TileNumber = 0;
Flat = false;
Flip = false;
Rotation = RotationType.RotateNone;
}
// *** METHODS ***
/// <summary>
/// Rotates the point around a particular axis
/// </summary>
/// <param name="type">Rotation axis</param>
/// <param name="angleInDeg">Angle to be rotated</param>
public void Rotate(RotationType type, double angleInDeg)
{
// Rotation matrix: http://de.wikipedia.org/wiki/Drehmatrix
double rad = angleInDeg * Math.PI / 180;
double cosa = Math.Cos(rad);
double sina = Math.Sin(rad);
Point3D old = new Point3D(this.X, this.Y, this.Z);
switch (type)
{
case RotationType.X:
this.Y = old.Y * cosa - old.Z * sina;
this.Z = old.Y * sina + old.Z * cosa;
break;
case RotationType.Y:
this.X = old.Z * sina + old.X * cosa;
this.Z = old.Z * cosa - old.X * sina;
break;
case RotationType.Z:
this.X = old.X * cosa - old.Y * sina;
this.Y = old.X * sina + old.Y * cosa;
break;
}
}
/// <summary>
/// Gets the coordinates for the texture acording to its rotation and flip.
/// </summary>
/// <remarks>The return values are stored 0->BottonLeft; 1->BottonRight; 2->TopRight; 3->TopLeft</remarks>
/// <param name="tileID">The ID of the texture.</param>
/// <param name="rotation">The rotation to aply to the texture.</param>
/// <param name="flip">If the Texture must be fliped.</param>
/// <returns>A array with 4 positions where each position represent one of the vertices od the texture, it will be a square with 64px.</returns>
public Vector2[] GetNormalTexture(UInt32 tileID, RotationType rotation, Boolean flip)
{
var texturePosition = new Vector2[4];
CompactRectangle tex = tileAtlas[(int)tileID];
var texTopLeft = new Vector2((tex.X + 1) * pixelPerWidth, (tex.Y + 1) * pixelPerHeight);
var texTopRight = new Vector2((tex.X + tex.Width - 1) * pixelPerWidth, (tex.Y + 1) * pixelPerHeight);
var texBottomLeft = new Vector2((tex.X + 1) * pixelPerWidth, (tex.Y + tex.Height - 1) * pixelPerHeight);
var texBottomRight = new Vector2((tex.X + tex.Width - 1) * pixelPerWidth, (tex.Y + tex.Height - 1) * pixelPerHeight);
if (flip)
{
Vector2 helper = texTopLeft;
texTopLeft = texTopRight;
texTopRight = helper;
helper = texBottomLeft;
texBottomLeft = texBottomRight;
texBottomRight = helper;
if (rotation == RotationType.Rotate90) //special cases.
{
rotation = RotationType.Rotate270;
}
else if (rotation == RotationType.Rotate270)
{
rotation = RotationType.Rotate90;
}
}
switch (rotation)
{
case RotationType.RotateNone:
texturePosition[0] = texBottomLeft;
texturePosition[1] = texBottomRight;
texturePosition[2] = texTopRight;
texturePosition[3] = texTopLeft;
break;
case RotationType.Rotate90:
texturePosition[3] = texBottomLeft;
texturePosition[0] = texBottomRight;
texturePosition[1] = texTopRight;
texturePosition[2] = texTopLeft;
break;
case RotationType.Rotate180:
texturePosition[2] = texBottomLeft;
texturePosition[3] = texBottomRight;
texturePosition[0] = texTopRight;
texturePosition[1] = texTopLeft;
break;
case RotationType.Rotate270:
texturePosition[1] = texBottomLeft;
texturePosition[2] = texBottomRight;
texturePosition[3] = texTopRight;
texturePosition[0] = texTopLeft;
break;
}
return texturePosition;
}
public void transform_images(RotationType rotate, FlippingType flip)
{
var image = Image.Load("TestImages/Backdrop.jpg");
var watch = Stopwatch.StartNew();
image = image.Transform(rotate, flip);
Trace.WriteLine($"{ rotate }-{ flip }: { watch.ElapsedMilliseconds}ms");
image.VerifyAndSave($"TestResult/Transformed/{ rotate }-{ flip }.jpg");
}
// *** METHODS ***
/// <summary>
/// Rotates the point around a particular axis
/// </summary>
/// <param name="type">Rotation axis</param>
/// <param name="angle">Angle to be rotated</param>
/// <param name="center">Center point of rotation</param>
public Cube3D Rotate(RotationType type, double angle, Point3D center)
{
//Deep Clone
var faces = new List<Face3D>();
foreach (var f2 in from f in this.Faces let edges = f.Vertices.Select(p => new Point3D(p.X, p.Y, p.Z)).ToList() select new Face3D(edges, f.Color, f.Position, f.MasterPosition))
{
f2.Vertices.ToList().ForEach(e => { e.X -= center.X; e.Y -= center.Y; e.Z -= center.Z; });
f2.Rotate(type, angle);
f2.Vertices.ToList().ForEach(e => { e.X += center.X; e.Y += center.Y; e.Z += center.Z; });
faces.Add(f2);
}
return new Cube3D(faces, this.Position, this.Location, this.Scale);
}
internal static Image Transform(Image source, RotationType rotationType, FlippingType flippingType)
{
Image target;
switch (rotationType)
{
case RotationType.None:
{
byte[] targetPixels = source.Pixels;
byte[] sourcePixels = new byte[targetPixels.Length];
Array.Copy(targetPixels, sourcePixels, targetPixels.Length);
target = new Image(source.Width, source.Height, sourcePixels);
}
break;
case RotationType.Rotate90:
{
target = Rotate90(source);
}
break;
case RotationType.Rotate180:
{
target = Rotate180(source);
}
break;
case RotationType.Rotate270:
{
target = Rotate270(source);
}
break;
default:
{
target = source.Clone();
}
break;
}
switch (flippingType)
{
case FlippingType.Vertical:
FlipX(target);
break;
case FlippingType.Horizontal:
FlipY(target);
break;
}
return target;
}
/// <summary>
/// Transforms the specified image by flipping and rotating it. First the image
/// will be rotated, then the image will be flipped. A new image will be returned. The original image
/// will not be changed.
/// </summary>
/// <param name="source">The image, which should be transformed.</param>
/// <param name="target">The new transformed image.</param>
/// <param name="rotationType">Type of the rotation.</param>
/// <param name="flippingType">Type of the flipping.</param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="source"/> is null (Nothing in Visual Basic).</para>
/// <para>- or -</para>
/// <para><paramref name="target"/> is null (Nothing in Visual Basic).</para>
/// </exception>
internal static void Transform(ImageBase source, ImageBase target, RotationType rotationType, FlippingType flippingType)
{
Contract.Requires<ArgumentNullException>(source != null, "Source image cannot be null.");
Contract.Requires<ArgumentException>(source.IsFilled, "Source image has not been loaded.");
Contract.Requires<ArgumentNullException>(target != null, "Target image cannot be null.");
switch (rotationType)
{
case RotationType.None:
{
byte[] targetPixels = source.Pixels;
byte[] sourcePixels = new byte[targetPixels.Length];
Array.Copy(targetPixels, sourcePixels, targetPixels.Length);
target.SetPixels(source.PixelWidth, source.PixelHeight, sourcePixels);
}
break;
case RotationType.Rotate90:
{
Rotate90(source, target);
}
break;
case RotationType.Rotate180:
{
Rotate180(source, target);
}
break;
case RotationType.Rotate270:
{
Rotate270(source, target);
}
break;
default:
throw new InvalidOperationException();
}
switch (flippingType)
{
case FlippingType.FlipX:
FlipX(target);
break;
case FlippingType.FlipY:
FlipY(target);
break;
}
}
/// <summary>
/// Rotate the specified towards.
/// El parámetro towards lo pasa el botón
/// </summary>
/// <param name="towards">Towards.</param>
public void SetRotataionType(string towards)
{
//Sólo si no se está rotando en este momento
if(rotationType == RotationType.none)
{
if(towards == "left")
rotationType = RotationType.left;
else if(towards == "right")
rotationType = RotationType.right;
else if(towards == "up")
rotationType = RotationType.up;
else if(towards == "down")
rotationType = RotationType.down;
accumulatedRotation = 0;
}
}
private double getRotationValue(RotationType typeR)
{
string text = range[0, 32].Text;
if (typeR == RotationType.Y)
{
text = range[0, 33].Text;
}
else if (typeR == RotationType.Z)
{
text = range[0, 34].Text;
}
if (string.IsNullOrEmpty(text.Trim()))
{
//this.writeError("未填写,默认为0", "板件绕" + typeR.ToString() + "旋转角度");
return 0;
}
return GetDoubleValue(text, "板件绕" + typeR.ToString() + "旋转角度", false, errors);
}
public CurveHolderNew(CurveHolderNew source)
{
name = source.name;
anglex = new AnimationCurve(source.anglex.keys);
angley = new AnimationCurve(source.angley.keys);
anglez = new AnimationCurve(source.anglez.keys);
posx = new AnimationCurve(source.posx.keys);
posy = new AnimationCurve(source.posy.keys);
posz = new AnimationCurve(source.posz.keys);
rotx = new AnimationCurve(source.rotx.keys);
roty = new AnimationCurve(source.roty.keys);
rotz = new AnimationCurve(source.rotz.keys);
rotw = new AnimationCurve(source.rotw.keys);
mType = source.mType;
rType = source.rType;
if (source.animationStateData != null)
{
animationStateData = new List <string> (source.animationStateData);
}
isLocal = source.isLocal;
}
private double getRotationValue(RotationType typeR)
{
string text = range[0, 32].Text;
if (typeR == RotationType.Y)
{
text = range[0, 33].Text;
}
else if (typeR == RotationType.Z)
{
text = range[0, 34].Text;
}
if (string.IsNullOrEmpty(text.Trim()))
{
//this.writeError("未填写,默认为0", "板件绕" + typeR.ToString() + "旋转角度");
return(0);
}
return(GetDoubleValue(text, "板件绕" + typeR.ToString() + "旋转角度", false, errors));
}
float GetDegreesDistance(RotationType rotType, float initDeg, float destDeg)
{
float _destDeg = ( (int)destDeg )%360;
int rounds = ( (int)_destDeg )/360;
int remain = ( (int)_destDeg )%360;
if( remain <= 0 )
remain = 360 + remain;
float distance = initDeg - remain;
MZMove.RotationType resultRotType = ( distance >= 0 )? MZMove.RotationType.CW : MZMove.RotationType.CCW;
distance = Mathf.Abs( distance );
if( rotType != resultRotType )
distance = 360 - distance;
distance = distance*( ( rotType == MZMove.RotationType.CCW )? 1 : -1 );
distance += 360*rounds;
return distance;
}
protected override void OnMouseDown(MouseEventArgs e) {
base.OnMouseDown(e);
mouseWas = e.Location;
switch(e.Button) {
case System.Windows.Forms.MouseButtons.Left:
rotationType = RotationType.Model;
break;
case System.Windows.Forms.MouseButtons.Right:
rotationType = RotationType.Camera;
break;
default:
rotationType = RotationType.None;
break;
}
}
public ElementCloud()
{
this.Background = Brushes.Transparent;
canvas = new Canvas()
{
VerticalAlignment = VerticalAlignment.Stretch,
HorizontalAlignment = HorizontalAlignment.Stretch
};
this.Children.Add(canvas);
rotateTransform = new RotateTransform3D();
SizeChanged += OnPageSizeChanged;
rotationType = RotationType.Mouse;
rotateDirection = new Point(100, 0);
slowDownCounter = 500;
elementsCollection = new List<ElementCloudItem>();
scaleRatio = 0.09;
opacityRatio = 1.3;
}
/// <summary>
/// Represents a face (left, right, top, bottom, lid) of a block.
/// </summary>
/// <param name="value">Base ushort value of this face.</param>
protected BlockFace(ushort value)
{
if (value == 0)
{
return;
}
//parse ushort value
//Bits 0-9: Tile number
uint tile = 0;
for (var i = 0; i < 10; i++)
{
tile = tile + (value & (uint)Math.Pow(2, i));
}
TileNumber = tile;
Flat = BitHelper.CheckBit(value, 12); //Bit 12
Flip = BitHelper.CheckBit(value, 13); //Bit 13
var bit14 = BitHelper.CheckBit(value, 14);
var bit15 = BitHelper.CheckBit(value, 15);
if (!bit14 && !bit15)
{
Rotation = RotationType.RotateNone;
}
if (bit14 && !bit15)
{
Rotation = RotationType.Rotate90;
}
if (!bit14 && bit15)
{
Rotation = RotationType.Rotate180;
}
if (bit14 && bit15)
{
Rotation = RotationType.Rotate270;
}
}
/// <summary>
/// Returns the index of the next direction based on
/// the current direction index and the rotation type.
/// </summary>
/// <param name="currentDirection"></param>
/// <param name="rotation"></param>
/// <returns></returns>
private static int GetNextDirection(int currentDirection, RotationType rotation)
{
int directionsCount = directions.Length;
if (rotation == RotationType.Right)
{
// get the index of the next element in the array
return (currentDirection + 1) % directionsCount;
}
else // RotationType.Left
{
if (currentDirection == 0)
{
return directionsCount - 1;
}
else
{
// get the index of the previous element in the array
return currentDirection - 1;
}
}
}
/// <summary>
/// Returns the index of the next direction based on
/// the current direction index and the rotation type.
/// </summary>
/// <param name="currentDirection"></param>
/// <param name="rotation"></param>
/// <returns></returns>
private static int GetNextDirection(int currentDirection, RotationType rotation)
{
int directionsCount = directions.Length;
if (rotation == RotationType.Right)
{
// get the index of the next element in the array
return((currentDirection + 1) % directionsCount);
}
else // RotationType.Left
{
if (currentDirection == 0)
{
return(directionsCount - 1);
}
else
{
// get the index of the previous element in the array
return(currentDirection - 1);
}
}
}
protected virtual IConverter GetConverter(RotationType type)
{
switch (type)
{
case RotationType.ImproveXYPlanes:
{
return(new XYConverter());
}
case RotationType.ImproveXZPlanes:
{
return(new XZConverter());
}
case RotationType.Simplex:
{
return(new SimplexConverter());
}
}
return(new NoneConverter());
}
private Color GetColorWithRotation(Texture2D tex, int x, int y, RotationType rotation)
{
int tempX = x;
int tempY = y;
switch (rotation)
{
case RotationType.None:
break;
case RotationType.ClockWise:
tempX = CELLSIZE - tempY - 1;
tempY = x;
break;
case RotationType.AntiClockWise:
tempX = tempY;
tempY = CELLSIZE - x - 1;
break;
case RotationType.OppositesUpDown:
tempY = CELLSIZE - tempY - 1;
break;
case RotationType.OppositesLeftRight:
tempX = CELLSIZE - tempX - 1;
break;
case RotationType.DuiJiaoRightTop:
if ((tempX + tempY) != CELLSIZE - 1)
{
tempX = CELLSIZE - tempY;
tempY = CELLSIZE - x;
}
break;
}
return(tex.GetPixel(tempX, tempY));
}
/// <summary>
/// Gets the coordinates for the texture acording to its rotation and flip.
/// </summary>
/// <remarks>The return values are stored 0->BottonLeft; 1->BottonRight; 2->TopRight; 3->TopLeft</remarks>
/// <param name="tileID">The ID of the texture.</param>
/// <param name="rotation">The rotation to aply to the texture.</param>
/// <param name="flip">If the Texture must be fliped.</param>
/// <param name="position">The position of the texture inside the 64px texture.</param>
/// <param name="vertical">Is a vertical Rectangle.</param>
/// <returns>A array with 4 positions where each position represent one of the vertices od the texture, it will be a rectangle 64pxX24px.</returns>
public Vector2[] GetRectangleTexture(UInt32 tileID, RotationType rotation, Boolean flip, RectangleTexturePosition position)
{
Vector2[] texture = GetNormalTexture(tileID, rotation, flip);
switch (position)
{
case RectangleTexturePosition.Botton:
return(bottomRectangle(texture, rotation));
case RectangleTexturePosition.Top:
return(topRectangle(texture, rotation));
case RectangleTexturePosition.CenterHorizontal:
break;
case RectangleTexturePosition.Left:
return(leftRectangle(texture, rotation));
case RectangleTexturePosition.Right:
return(rightRectangle(texture, rotation));
}
throw new NotImplementedException();
}
private Orientation Transform(FaceColor newUp,
FaceColor newRight,
FaceColor newFront,
RotationType upRotationType,
RotationType rightRotationType,
RotationType frontRotationType,
RotationType downRotationType,
RotationType leftRotationType,
RotationType backRotationType)
{
var up = Colors.Forwards[newUp];
var right = Colors.Forwards[newRight];
var front = Colors.Forwards[newFront];
return(new Orientation(up, right, front,
Move(Directions[newUp], upRotationType),
Move(Directions[newRight], rightRotationType),
Move(Directions[newFront], frontRotationType),
Move(Directions[GetOpposite(newUp)], downRotationType),
Move(Directions[GetOpposite(newRight)], leftRotationType),
Move(Directions[GetOpposite(newFront)], backRotationType)
));
}
/// <summary>
/// Post the players score to the given social leaderboard.
/// Pass leaderboard config data to dynamically create if necessary.
/// You can optionally send a user-defined json string of data
/// with the posted score. This string could include information
/// relevant to the posted score.
/// </summary>
/// <remarks>
/// Service Name - SocialLeaderboard
/// Service Operation - PostScoreDynamic
/// </remarks>
/// <param name="in_leaderboardId">
/// The leaderboard to post to
/// </param>
/// <param name="in_score">
/// The score to post
/// </param>
/// <param name="in_data">
/// Optional user-defined data to post with the score
/// </param>
/// <param name="in_leaderboardType">
/// leaderboard type
/// </param>
/// <param name="in_rotationType">
/// Type of rotation
/// </param>
/// <param name="in_rotationReset">
/// Date to reset the leaderboard (Date is converted to "dd-mm-yyyy hh:ss" format)
/// </param>
/// <param name="in_retainedCount">
/// Hpw many rotations to keep
/// </param>
/// <param name="in_success">
/// The success callback.
/// </param>
/// <param name="in_failure">
/// The failure callback.
/// </param>
/// <param name="in_cbObject">
/// The user object sent to the callback.
/// </param>
/// <returns> The JSON returned in the callback is as follows:
/// {
/// "status":200,
/// "data":{
/// }
/// }
/// </returns>
public void PostScoreToDynamicLeaderboard(
string in_leaderboardId,
long in_score,
string in_jsonData,
SocialLeaderboardType in_leaderboardType,
RotationType in_rotationType,
DateTime?in_rotationReset,
int in_retainedCount,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = in_leaderboardId;
data[OperationParam.SocialLeaderboardServiceScore.Value] = in_score;
if (Util.IsOptionalParameterValid(in_jsonData))
{
Dictionary <string, object> customData = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonData);
data[OperationParam.SocialLeaderboardServiceData.Value] = customData;
}
data[OperationParam.SocialLeaderboardServiceLeaderboardType.Value] = in_leaderboardType.ToString();
data[OperationParam.SocialLeaderboardServiceRotationType.Value] = in_rotationType.ToString();
if (in_rotationReset.HasValue)
{
data[OperationParam.SocialLeaderboardServiceRotationReset.Value] = in_rotationReset.Value.ToString("d-MM-yyyy HH:mm");
}
data[OperationParam.SocialLeaderboardServiceRetainedCount.Value] = in_retainedCount;
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.SocialLeaderboard, ServiceOperation.PostScoreDynamic, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
public RotationType GetRotationType(HunterTalents t)
{
RotationType curRotationType = RotationType.Custom;
if (t != null)
{
if (t.HighestTree == (int)Specialization.BeastMastery)
{
// Beast Mastery
curRotationType = Rotation.RotationType.BeastMastery;
}
else if (t.HighestTree == (int)Specialization.Marksmanship)
{
// Marksmanship
curRotationType = Rotation.RotationType.Marksmanship;
}
if (t.HighestTree == (int)Specialization.Survival)
{
// Survival
curRotationType = Rotation.RotationType.Survival;
}
}
return(curRotationType);
}
/// <summary>
/// Post the players score to the given social leaderboard.
/// Pass leaderboard config data to dynamically create if necessary.
/// You can optionally send a user-defined json string of data
/// with the posted score. This string could include information
/// relevant to the posted score.
/// </summary>
/// <remarks>
/// Service Name - leaderboard
/// Service Operation - PostScoreDynamic
/// </remarks>
/// <param name="leaderboardId">
/// The leaderboard to post to
/// </param>
/// <param name="score">
/// The score to post
/// </param>
/// <param name="data">
/// Optional user-defined data to post with the score
/// </param>
/// <param name="leaderboardType">
/// leaderboard type
/// </param>
/// <param name="rotationType">
/// Type of rotation
/// </param>
/// <param name="rotationReset">
/// Date to reset the leaderboard UTC
/// </param>
/// <param name="retainedCount">
/// How many rotations to keep
/// </param>
/// <param name="success">
/// The success callback.
/// </param>
/// <param name="failure">
/// The failure callback.
/// </param>
/// <param name="cbObject">
/// The user object sent to the callback.
/// </param>
public void PostScoreToDynamicLeaderboard(
string leaderboardId,
long score,
string jsonData,
SocialLeaderboardType leaderboardType,
RotationType rotationType,
DateTime?rotationReset,
int retainedCount,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
var data = new Dictionary <string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId;
data[OperationParam.SocialLeaderboardServiceScore.Value] = score;
if (Util.IsOptionalParameterValid(jsonData))
{
var customData = JsonReader.Deserialize <Dictionary <string, object> >(jsonData);
data[OperationParam.SocialLeaderboardServiceData.Value] = customData;
}
data[OperationParam.SocialLeaderboardServiceLeaderboardType.Value] = leaderboardType.ToString();
data[OperationParam.SocialLeaderboardServiceRotationType.Value] = rotationType.ToString();
if (rotationReset.HasValue)
{
data[OperationParam.SocialLeaderboardServiceRotationResetTime.Value] = Util.DateTimeToUnixTimestamp(rotationReset.Value);
}
data[OperationParam.SocialLeaderboardServiceRetainedCount.Value] = retainedCount;
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.PostScoreDynamic, data, callback);
_client.SendRequest(sc);
}
static dynamic Decode(BinaryReader reader, int version, Type ensure = null, bool root = false)
{
Type t = DecodeID(reader);
if (ensure != null && ensure != t)
{
throw new InvalidDataException();
}
if (t == typeof(Preferences) && root)
{
Preferences.AlwaysOnTop = reader.ReadBoolean();
Preferences.CenterTrackContents = reader.ReadBoolean();
if (version >= 9)
{
Preferences.LaunchpadStyle = (LaunchpadStyles)reader.ReadInt32();
}
if (version >= 14)
{
Preferences.LaunchpadGridRotation = reader.ReadInt32() > 0;
}
Preferences.AutoCreateKeyFilter = reader.ReadBoolean();
Preferences.AutoCreatePageFilter = reader.ReadBoolean();
if (version >= 11)
{
Preferences.AutoCreatePattern = reader.ReadBoolean();
}
Preferences.FadeSmoothness = reader.ReadDouble();
Preferences.CopyPreviousFrame = reader.ReadBoolean();
if (version >= 7)
{
Preferences.CaptureLaunchpad = reader.ReadBoolean();
}
Preferences.EnableGestures = reader.ReadBoolean();
if (version >= 7)
{
Preferences.PaletteName = reader.ReadString();
Preferences.CustomPalette = new Palette((from i in Enumerable.Range(0, 128) select(Color) Decode(reader, version)).ToArray());
Preferences.ImportPalette = (Palettes)reader.ReadInt32();
Preferences.Theme = (Themes)reader.ReadInt32();
}
if (version >= 10)
{
Preferences.Backup = reader.ReadBoolean();
Preferences.Autosave = reader.ReadBoolean();
}
if (version >= 12)
{
Preferences.UndoLimit = reader.ReadBoolean();
}
if (version <= 0)
{
Preferences.DiscordPresence = true;
reader.ReadBoolean();
}
else
{
Preferences.DiscordPresence = reader.ReadBoolean();
}
Preferences.DiscordFilename = reader.ReadBoolean();
ColorHistory.Set(
(from i in Enumerable.Range(0, reader.ReadInt32()) select(Color) Decode(reader, version)).ToList()
);
if (version >= 2)
{
MIDI.Devices = (from i in Enumerable.Range(0, reader.ReadInt32()) select(Launchpad) Decode(reader, version)).ToList();
}
if (version >= 15)
{
Preferences.Recents = (from i in Enumerable.Range(0, reader.ReadInt32()) select reader.ReadString()).ToList();
Preferences.CrashName = reader.ReadString();
Preferences.CrashPath = reader.ReadString();
}
if (version >= 16)
{
Preferences.CheckForUpdates = reader.ReadBoolean();
}
if (version >= 17)
{
Preferences.BaseTime = reader.ReadInt64();
}
return(null);
}
else if (t == typeof(Copyable))
{
return(new Copyable()
{
Contents = (from i in Enumerable.Range(0, reader.ReadInt32()) select(ISelect) Decode(reader, version)).ToList()
});
}
else if (t == typeof(Project))
{
int bpm = reader.ReadInt32();
int page = reader.ReadInt32();
List <Track> tracks = (from i in Enumerable.Range(0, reader.ReadInt32()) select(Track) Decode(reader, version)).ToList();
string author = "";
long time = 0;
long started = 0;
if (version >= 17)
{
author = reader.ReadString();
time = reader.ReadInt64();
started = reader.ReadInt64();
}
return(new Project(bpm, page, tracks, author, time, started));
}
else if (t == typeof(Track))
{
Chain chain = (Chain)Decode(reader, version);
Launchpad lp = (Launchpad)Decode(reader, version);
string name = reader.ReadString();
bool enabled = true;
if (version >= 8)
{
enabled = reader.ReadBoolean();
}
return(new Track(chain, lp, name)
{
Enabled = enabled
});
}
else if (t == typeof(Chain))
{
List <Device> devices = (from i in Enumerable.Range(0, reader.ReadInt32()) select(Device) Decode(reader, version)).ToList();
string name = reader.ReadString();
bool enabled = true;
if (version >= 6)
{
enabled = reader.ReadBoolean();
}
return(new Chain(devices, name)
{
Enabled = enabled
});
}
else if (t == typeof(Device))
{
bool collapsed = false;
if (version >= 5)
{
collapsed = reader.ReadBoolean();
}
bool enabled = true;
if (version >= 5)
{
enabled = reader.ReadBoolean();
}
Device ret = (Device)Decode(reader, version);
ret.Collapsed = collapsed;
ret.Enabled = enabled;
return(ret);
}
else if (t == typeof(Launchpad))
{
string name = reader.ReadString();
if (name == "")
{
return(MIDI.NoOutput);
}
InputType format = InputType.DrumRack;
if (version >= 2)
{
format = (InputType)reader.ReadInt32();
}
RotationType rotation = RotationType.D0;
if (version >= 9)
{
rotation = (RotationType)reader.ReadInt32();
}
foreach (Launchpad lp in MIDI.Devices)
{
if (lp.Name == name)
{
if (lp.GetType() == typeof(Launchpad))
{
lp.InputFormat = format;
lp.Rotation = rotation;
}
return(lp);
}
}
Launchpad ret;
if (name.Contains("Virtual Launchpad "))
{
ret = new VirtualLaunchpad(name);
}
else if (name.Contains("Ableton Connector "))
{
ret = new AbletonLaunchpad(name);
}
else
{
ret = new Launchpad(name, format, rotation);
}
MIDI.Devices.Add(ret);
return(ret);
}
else if (t == typeof(Group))
{
return(new Group(
(from i in Enumerable.Range(0, reader.ReadInt32()) select(Chain) Decode(reader, version)).ToList(),
reader.ReadBoolean()? (int?)reader.ReadInt32() : null
));
}
else if (t == typeof(Choke))
{
return(new Choke(
reader.ReadInt32(),
(Chain)Decode(reader, version)
));
}
else if (t == typeof(Clear))
{
return(new Clear(
(ClearType)reader.ReadInt32()
));
}
else if (t == typeof(ColorFilter))
{
return(new ColorFilter(
reader.ReadDouble(),
reader.ReadDouble(),
reader.ReadDouble(),
reader.ReadDouble(),
reader.ReadDouble(),
reader.ReadDouble()
));
}
else if (t == typeof(Copy))
{
Time time;
if (version <= 2)
{
time = new Time(
reader.ReadBoolean(),
Decode(reader, version),
reader.ReadInt32()
);
}
else
{
time = Decode(reader, version);
}
double gate;
if (version <= 13)
{
gate = (double)reader.ReadDecimal();
}
else
{
gate = reader.ReadDouble();
}
return(new Copy(
time,
gate,
(CopyType)reader.ReadInt32(),
(GridType)reader.ReadInt32(),
reader.ReadBoolean(),
(from i in Enumerable.Range(0, reader.ReadInt32()) select(Offset) Decode(reader, version)).ToList()
));
}
else if (t == typeof(Delay))
{
Time time;
if (version <= 2)
{
time = new Time(
reader.ReadBoolean(),
Decode(reader, version),
reader.ReadInt32()
);
}
else
{
time = Decode(reader, version);
}
double gate;
if (version <= 13)
{
gate = (double)reader.ReadDecimal();
}
else
{
gate = reader.ReadDouble();
}
return(new Delay(time, gate));
}
else if (t == typeof(Fade))
{
Time time;
if (version <= 2)
{
time = new Time(
reader.ReadBoolean(),
Decode(reader, version),
reader.ReadInt32()
);
}
else
{
time = Decode(reader, version);
}
double gate;
if (version <= 13)
{
gate = (double)reader.ReadDecimal();
}
else
{
gate = reader.ReadDouble();
}
FadePlaybackType playmode = (FadePlaybackType)reader.ReadInt32();
int count;
List <Color> colors = (from i in Enumerable.Range(0, count = reader.ReadInt32()) select(Color) Decode(reader, version)).ToList();
List <double> positions = (from i in Enumerable.Range(0, count) select(version <= 13)? (double)reader.ReadDecimal() : reader.ReadDouble()).ToList();
return(new Fade(time, gate, playmode, colors, positions));
}
else if (t == typeof(Flip))
{
return(new Flip(
(FlipType)reader.ReadInt32(),
reader.ReadBoolean()
));
}
else if (t == typeof(Hold))
{
Time time;
if (version <= 2)
{
time = new Time(
reader.ReadBoolean(),
Decode(reader, version),
reader.ReadInt32()
);
}
else
{
time = Decode(reader, version);
}
double gate;
if (version <= 13)
{
gate = (double)reader.ReadDecimal();
}
else
{
gate = reader.ReadDouble();
}
return(new Hold(
time,
gate,
reader.ReadBoolean(),
reader.ReadBoolean()
));
}
else if (t == typeof(KeyFilter))
{
bool[] filter;
if (version <= 18)
{
List <bool> oldFilter = (from i in Enumerable.Range(0, 100) select reader.ReadBoolean()).ToList();
oldFilter.Insert(99, false);
filter = oldFilter.ToArray();
}
else
{
filter = (from i in Enumerable.Range(0, 101) select reader.ReadBoolean()).ToArray();
}
return(new KeyFilter(filter));
}
else if (t == typeof(Layer))
{
int target = reader.ReadInt32();
BlendingType blending = BlendingType.Normal;
if (version >= 5)
{
if (version == 5)
{
blending = (BlendingType)reader.ReadInt32();
if ((int)blending == 2)
{
blending = BlendingType.Mask;
}
}
else
{
blending = (BlendingType)reader.ReadInt32();
}
}
int range = 200;
if (version >= 21)
{
range = reader.ReadInt32();
}
return(new Layer(target, blending, range));
}
else if (t == typeof(Move))
{
return(new Move(
Decode(reader, version),
(GridType)reader.ReadInt32(),
reader.ReadBoolean()
));
}
else if (t == typeof(Multi))
{
return(new Multi(
Decode(reader, version),
(from i in Enumerable.Range(0, reader.ReadInt32()) select(Chain) Decode(reader, version)).ToList(),
reader.ReadBoolean()? (int?)reader.ReadInt32() : null,
(MultiType)reader.ReadInt32()
));
}
else if (t == typeof(Output))
{
return(new Output(
reader.ReadInt32()
));
}
else if (t == typeof(PageFilter))
{
return(new PageFilter(
(from i in Enumerable.Range(0, 100) select reader.ReadBoolean()).ToArray()
));
}
else if (t == typeof(Paint))
{
return(new Paint(
Decode(reader, version)
));
}
else if (t == typeof(Pattern))
{
int repeats = 1;
if (version >= 11)
{
repeats = reader.ReadInt32();
}
double gate;
if (version <= 13)
{
gate = (double)reader.ReadDecimal();
}
else
{
gate = reader.ReadDouble();
}
List <Frame> frames = (from i in Enumerable.Range(0, reader.ReadInt32()) select(Frame) Decode(reader, version)).ToList();
PlaybackType mode = (PlaybackType)reader.ReadInt32();
bool chokeenabled = false;
int choke = 8;
if (version <= 10)
{
chokeenabled = reader.ReadBoolean();
if (version <= 0)
{
if (chokeenabled)
{
choke = reader.ReadInt32();
}
}
else
{
choke = reader.ReadInt32();
}
}
bool infinite = false;
if (version >= 4)
{
infinite = reader.ReadBoolean();
}
int?rootkey = null;
if (version >= 12)
{
rootkey = reader.ReadBoolean()? (int?)reader.ReadInt32() : null;
}
bool wrap = false;
if (version >= 13)
{
wrap = reader.ReadBoolean();
}
int expanded = reader.ReadInt32();
Pattern ret = new Pattern(repeats, gate, frames, mode, infinite, rootkey, wrap, expanded);
if (chokeenabled)
{
return(new Choke(choke, new Chain(new List <Device>()
{
ret
})));
}
return(ret);
}
else if (t == typeof(Preview))
{
return(new Preview());
}
else if (t == typeof(Rotate))
{
return(new Rotate(
(RotateType)reader.ReadInt32(),
reader.ReadBoolean()
));
}
else if (t == typeof(Switch))
{
int page = reader.ReadInt32();
if (18 <= version && version <= 21 && reader.ReadBoolean())
{
return(new Group(new List <Chain>()
{
new Chain(new List <Device>()
{
new Switch(page), new Clear(ClearType.Multi)
}, "Switch Reset")
}));
}
return(new Switch(page));
}
else if (t == typeof(Tone))
{
return(new Tone(
reader.ReadDouble(),
reader.ReadDouble(),
reader.ReadDouble(),
reader.ReadDouble(),
reader.ReadDouble()
));
}
else if (t == typeof(Color))
{
return(new Color(
reader.ReadByte(),
reader.ReadByte(),
reader.ReadByte()
));
}
else if (t == typeof(Frame))
{
Time time;
if (version <= 2)
{
time = new Time(
reader.ReadBoolean(),
Decode(reader, version),
reader.ReadInt32()
);
}
else
{
time = Decode(reader, version);
}
Color[] screen;
if (version <= 19)
{
List <Color> oldScreen = (from i in Enumerable.Range(0, 100) select(Color) Decode(reader, version)).ToList();
oldScreen.Insert(99, new Color(0));
screen = oldScreen.ToArray();
}
else
{
screen = (from i in Enumerable.Range(0, 101) select(Color) Decode(reader, version)).ToArray();
}
return(new Frame(time, screen));
}
else if (t == typeof(Length))
{
return(new Length(
reader.ReadInt32()
));
}
else if (t == typeof(Offset))
{
return(new Offset(
reader.ReadInt32(),
reader.ReadInt32()
));
}
else if (t == typeof(Time))
{
return(new Time(
reader.ReadBoolean(),
Decode(reader, version),
reader.ReadInt32()
));
}
throw new InvalidDataException();
}
void Start()
{
_sprite = GetComponent <SpriteRenderer>();
_audio = GetComponent <AudioSource>();
_rotationType = RotationType.ClickTwo;
}
/// <summary>
/// Post the players score to the given social leaderboard.
/// Pass leaderboard config data to dynamically create if necessary.
/// You can optionally send a user-defined json string of data
/// with the posted score. This string could include information
/// relevant to the posted score.
/// </summary>
/// <remarks>
/// Service Name - SocialLeaderboard
/// Service Operation - PostScoreDynamic
/// </remarks>
/// <param name="in_leaderboardId">
/// The leaderboard to post to
/// </param>
/// <param name="in_score">
/// The score to post
/// </param>
/// <param name="in_data">
/// Optional user-defined data to post with the score
/// </param>
/// <param name="in_leaderboardType">
/// leaderboard type
/// </param>
/// <param name="in_rotationType">
/// Type of rotation
/// </param>
/// <param name="in_rotationReset">
/// Date to reset the leaderboard
/// </param>
/// <param name="in_retainedCount">
/// Hpw many rotations to keep
/// </param>
/// <param name="in_success">
/// The success callback.
/// </param>
/// <param name="in_failure">
/// The failure callback.
/// </param>
/// <param name="in_cbObject">
/// The user object sent to the callback.
/// </param>
/// <returns> The JSON returned in the callback is as follows:
/// {
/// "status":200,
/// "data":{
/// }
/// }
/// </returns>
public void PostScoreToDynamicLeaderboard(
string in_leaderboardId,
long in_score,
string in_jsonData,
SocialLeaderboardType in_leaderboardType,
RotationType in_rotationType,
DateTime? in_rotationReset,
int in_retainedCount,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary<string, object> data = new Dictionary<string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = in_leaderboardId;
data[OperationParam.SocialLeaderboardServiceScore.Value] = in_score;
if (Util.IsOptionalParameterValid(in_jsonData))
{
Dictionary<string, object> customData = JsonReader.Deserialize<Dictionary<string, object>>(in_jsonData);
data[OperationParam.SocialLeaderboardServiceData.Value] = customData;
}
data[OperationParam.SocialLeaderboardServiceLeaderboardType.Value] = in_leaderboardType.ToString();
data[OperationParam.SocialLeaderboardServiceRotationType.Value] = in_rotationType.ToString();
if (in_rotationReset.HasValue)
data[OperationParam.SocialLeaderboardServiceRotationReset.Value] = in_rotationReset.Value.ToString("d-MM-yyyy HH:mm");
data[OperationParam.SocialLeaderboardServiceRetainedCount.Value] = in_retainedCount;
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.SocialLeaderboard, ServiceOperation.PostScoreDynamic, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
public override string GetRotateAnim(MotionType motionType, RotationType rotationType)
{
return(null);
}
public void Rotate(RotationType rotation)
{
transform.Rotate(Vector3.up, ((int)rotation) * 90);
ColorsData = ColorsData.Rotate(rotation);
}
/// <summary>
/// �f�V���A���C�Y���ꂽ��]����I�u�W�F�N�g��擾����
/// </summary>
/// <param name="type">��]����^</param>
/// <param name="bytes">�V���A���C�Y�ς݉�]����f�[�^</param>
/// <param name="offset">���[�V�����f�[�^�̊J�n�ʒu</param>
/// <param name="nextOffset">���̃��[�V�����f�[�^�̊J�n�ʒu</param>
/// <returns>���s����]����I�u�W�F�N�g</returns>
public static RotationBase2D GetDeserializedRotation(RotationType type, byte[] bytes, int offset, out int nextOffset)
{
// ��]����I�u�W�F�N�g�쐬
var rotation = CreateInstance(type);
// ��]����f�[�^�̃f�V���A���C�Y
nextOffset = rotation.Deserialize(bytes, offset);
return rotation;
}
/// <summary>
/// �f�V���A���C�Y���ꂽ��]����I�u�W�F�N�g��擾����
/// </summary>
/// <param name="type">��]����^</param>
/// <param name="bytes">�V���A���C�Y�ς݉�]����f�[�^</param>
/// <returns>���s����]����I�u�W�F�N�g</returns>
public static RotationBase2D GetDeserializedRotation(RotationType type, byte[] bytes)
{
// ��]����I�u�W�F�N�g�쐬
var rotation = CreateInstance(type);
if ( bytes != null ) {
// ��]����f�[�^�̃f�V���A���C�Y
rotation.Deserialize(bytes, 0);
}
return rotation;
}
public LineInfo(int ID)
{
this.ID = ID;
this.Position = 0.5d;
this.RotationType = RotationType.Default;
}
public Drawable TransformRotateSimple(RotationType rotate_type,
bool auto_center,
int center_x, int center_y,
bool clip_result)
{
return new Drawable(gimp_drawable_transform_rotate_simple
(ID, rotate_type, auto_center, center_x, center_y,
clip_result));
}
static extern Int32 gimp_drawable_transform_rotate_simple(Int32 drawable_ID,
RotationType rotate_type,
bool auto_center,
int center_x,
int center_y,
bool clip_result);
// *** METHODS ***
/// <summary>
/// Rotates the point around a particular axis
/// </summary>
/// <param name="type">Rotation axis</param>
/// <param name="angleInDeg">Angle to be rotated</param>
public void Rotate(RotationType type, double angleInDeg)
{
this.Vertices.ToList().ForEach(v => v.Rotate(type, angleInDeg));
}
static extern bool gimp_image_rotate(Int32 image_ID, RotationType rotate_type);
public TileIndex tileIndex = new TileIndex(); // the tile's location on the board
public LineTile(LineTileType lineTileType, RotationType rotationType)
{
this.lineTileType = lineTileType;
this.rotationType = rotationType;
// set up sprite
switch (lineTileType)
{
case LineTileType.Nub:
sprite = new FSprite("lineTileNub");
break;
case LineTileType.Line:
sprite = new FSprite("lineTileLine");
break;
case LineTileType.Corner:
sprite = new FSprite("lineTileCorner");
break;
case LineTileType.Threeway:
sprite = new FSprite("lineTileThreeway");
break;
case LineTileType.Cross:
sprite = new FSprite("lineTileCross");
break;
default:
throw new FutileException("invalid line tile type");
}
AddChild(sprite);
// set up sprite rotation
switch (rotationType)
{
case RotationType.Rotation0:
sprite.rotation = 0;
break;
case RotationType.Rotation90:
sprite.rotation = 90;
break;
case RotationType.Rotation180:
sprite.rotation = 180;
break;
case RotationType.Rotation270:
sprite.rotation = 270;
break;
default:
throw new FutileException("invalid rotation type");
}
// set up bitmask by doing bitwise OR with each side that is included in the shape
// so for example, a tile that has all four sides solid (e.g. the cross tile) would be
// 1 | 2 | 4 | 8 = 15, which is the same as 0001 | 0010 | 0100 | 1000 = 1111 in binary
if (lineTileType == LineTileType.Nub)
{
if (rotationType == RotationType.Rotation0)
{
bitmask = kBitmaskTop;
}
if (rotationType == RotationType.Rotation90)
{
bitmask = kBitmaskRight;
}
if (rotationType == RotationType.Rotation180)
{
bitmask = kBitmaskBottom;
}
if (rotationType == RotationType.Rotation270)
{
bitmask = kBitmaskLeft;
}
}
if (lineTileType == LineTileType.Line)
{
if (rotationType == RotationType.Rotation0 || rotationType == RotationType.Rotation180)
{
bitmask = kBitmaskTop | kBitmaskBottom;
}
if (rotationType == RotationType.Rotation90 || rotationType == RotationType.Rotation270)
{
bitmask = kBitmaskRight | kBitmaskLeft;
}
}
if (lineTileType == LineTileType.Corner)
{
if (rotationType == RotationType.Rotation0)
{
bitmask = kBitmaskTop | kBitmaskRight;
}
if (rotationType == RotationType.Rotation90)
{
bitmask = kBitmaskRight | kBitmaskBottom;
}
if (rotationType == RotationType.Rotation180)
{
bitmask = kBitmaskBottom | kBitmaskLeft;
}
if (rotationType == RotationType.Rotation270)
{
bitmask = kBitmaskLeft | kBitmaskTop;
}
}
if (lineTileType == LineTileType.Threeway)
{
if (rotationType == RotationType.Rotation0)
{
bitmask = kBitmaskTop | kBitmaskRight | kBitmaskBottom;
}
if (rotationType == RotationType.Rotation90)
{
bitmask = kBitmaskRight | kBitmaskBottom | kBitmaskLeft;
}
if (rotationType == RotationType.Rotation180)
{
bitmask = kBitmaskBottom | kBitmaskLeft | kBitmaskTop;
}
if (rotationType == RotationType.Rotation270)
{
bitmask = kBitmaskLeft | kBitmaskTop | kBitmaskRight;
}
}
if (lineTileType == LineTileType.Cross)
{
bitmask = kBitmaskTop | kBitmaskRight | kBitmaskBottom | kBitmaskLeft;
}
}
private string ROT(string str, RotationType typ)
{
StringBuilder sb = new StringBuilder();
switch (typ)
{
case RotationType.None:
return(str);
case RotationType.ROT5:
for (int i = 0; i < str.Length; ++i)
{
if (str[i] >= '0' && str[i] <= '4')
{
sb.Append((char)((int)str[i] + 5));
}
else if (str[i] >= '5' && str[i] <= '9')
{
sb.Append((char)((int)str[i] - 5));
}
else
{
sb.Append(str[i]);
}
}
break;
case RotationType.ROT13:
for (int i = 0; i < str.Length; ++i)
{
if ((str[i] >= 'a' && str[i] <= 'm') || (str[i] >= 'A' && str[i] <= 'M'))
{
sb.Append((char)((int)str[i] + 13));
}
else if ((str[i] >= 'n' && str[i] <= 'z') || (str[i] >= 'N' && str[i] <= 'Z'))
{
sb.Append((char)((int)str[i] - 13));
}
else
{
sb.Append(str[i]);
}
}
break;
case RotationType.ROT18:
for (int i = 0; i < str.Length; ++i)
{
if (str[i] >= '0' && str[i] <= '4')
{
sb.Append((char)((int)str[i] + 5));
}
else if (str[i] >= '5' && str[i] <= '9')
{
sb.Append((char)((int)str[i] - 5));
}
else if ((str[i] >= 'a' && str[i] <= 'm') || (str[i] >= 'A' && str[i] <= 'M'))
{
sb.Append((char)((int)str[i] + 13));
}
else if ((str[i] >= 'n' && str[i] <= 'z') || (str[i] >= 'N' && str[i] <= 'Z'))
{
sb.Append((char)((int)str[i] - 13));
}
else
{
sb.Append(str[i]);
}
}
break;
case RotationType.ROT47:
for (int i = 0; i < str.Length; ++i)
{
if (str[i] >= '!' && str[i] <= 'O')
{
sb.Append((char)((int)str[i] + 47));
}
else if (str[i] >= 'P' && str[i] <= '~')
{
sb.Append((char)((int)str[i] - 47));
}
else
{
sb.Append(str[i]);
}
}
break;
}
return(sb.ToString());
}
private MeshCombineUtility.HiddenFaces CalculateHiddenFaces(MapDataStore.Tile tile, RotationType rotation)
{
MeshCombineUtility.HiddenFaces hiddenFaces = MeshCombineUtility.HiddenFaces.None;
if (rotation == RotationType.None)
{
if (tile.North != null && (tile.North.isWall || tile.North.Hidden))
{
hiddenFaces |= MeshCombineUtility.HiddenFaces.North;
}
if (tile.South != null && (tile.South.isWall || tile.South.Hidden))
{
hiddenFaces |= MeshCombineUtility.HiddenFaces.South;
}
if (tile.East != null && (tile.East.isWall || tile.East.Hidden))
{
hiddenFaces |= MeshCombineUtility.HiddenFaces.East;
}
if (tile.West != null && (tile.West.isWall || tile.West.Hidden))
{
hiddenFaces |= MeshCombineUtility.HiddenFaces.West;
}
}
if (rotation != RotationType.TreeRound && rotation != RotationType.TreeRoundTall)//these two rotations don't give a flat rotation.
{
if (tile.Up != null && (tile.Up.isSolidBase || tile.Up.Hidden))
{
hiddenFaces |= MeshCombineUtility.HiddenFaces.Up;
}
if (tile.Down != null && (tile.Down.isWall || tile.Down.Hidden))
{
hiddenFaces |= MeshCombineUtility.HiddenFaces.Down;
}
}
return(hiddenFaces);
}
public abstract string GetRotateAnim(MotionType motionType, RotationType rotationType);
// *** METHODS ***
/// <summary>
/// Rotates the point around a particular axis
/// </summary>
/// <param name="type">Rotation axis</param>
/// <param name="angleInDeg">Angle to be rotated</param>
public void Rotate(RotationType type, double angleInDeg)
{
this.Vertices.ToList().ForEach(v => v.Rotate(type, angleInDeg));
}
public Voxel(MeshShapeType meshShape, RotationType rotation, bool upsideDown, ushort blockType)
{
ShapeData = CalcShape(meshShape, rotation, upsideDown);
BlockType = blockType;
}
public static Quaternion TranslateRotation(RotationType rotationType, MapDataStore.Tile tile)
{
switch (rotationType)
{
case RotationType.None:
return(Quaternion.identity);
case RotationType.AwayFromWall:
{
Directions wallSides = tile.WallBuildingSides;
Vector2 average = Vector2.zero;
if ((wallSides & Directions.NorthWest) == Directions.NorthWest)
{
average += new Vector2(-1, 1);
}
if ((wallSides & Directions.North) == Directions.North)
{
average += new Vector2(0, 1);
}
if ((wallSides & Directions.NorthEast) == Directions.NorthEast)
{
average += new Vector2(1, 1);
}
if ((wallSides & Directions.West) == Directions.West)
{
average += new Vector2(-1, 0);
}
if ((wallSides & Directions.East) == Directions.East)
{
average += new Vector2(1, -0);
}
if ((wallSides & Directions.SouthWest) == Directions.SouthWest)
{
average += new Vector2(-1, -1);
}
if ((wallSides & Directions.South) == Directions.South)
{
average += new Vector2(0, -1);
}
if ((wallSides & Directions.SouthEast) == Directions.SouthEast)
{
average += new Vector2(1, -1);
}
if (average.magnitude < 0.001)
{
return(Quaternion.Euler(0, 0, 0));
}
float angle = Mathf.Atan2(average.x, average.y) * 180 / Mathf.PI;
float angle90 = Mathf.Round(angle / 90) * 90;
float angle45 = Mathf.Round(angle / 45) * 45;
if (Mathf.Abs(angle90 - angle) < 30)
{
return(Quaternion.Euler(0, angle90, 0));
}
else
{
return(Quaternion.Euler(0, angle45, 0));
}
}
case RotationType.Door:
{
Directions wallSides = tile.WallBuildingSides;
if ((wallSides & (Directions.North | Directions.South | Directions.East | Directions.West)) == (Directions.North | Directions.South | Directions.East | Directions.West))
{
return(Quaternion.identity);
}
if ((wallSides & (Directions.North | Directions.South)) == (Directions.North | Directions.South))
{
return(Quaternion.Euler(0, 90, 0));
}
;
return(Quaternion.identity);
}
case RotationType.Random:
{
if (noise == null)
{
noise = new OpenSimplexNoise();
}
float rot = (float)noise.eval(tile.position.x, tile.position.y, tile.position.z);
return(Quaternion.Euler(0, rot * 360, 0));
}
case RotationType.Random90:
{
if (noise == null)
{
noise = new OpenSimplexNoise();
}
float rot = (float)noise.eval(tile.position.x, tile.position.y, tile.position.z);
rot = Mathf.Round(rot * 4) * 90;
return(Quaternion.Euler(0, rot, 0));
}
case RotationType.TreeFlat:
{
Vector2 treeDir = new Vector2(-tile.positionOnTree.x, tile.positionOnTree.y);
if (treeDir.sqrMagnitude < 0.001)
{
return(Quaternion.identity);
}
float angle = Mathf.Atan2(treeDir.x, treeDir.y) * 180 / Mathf.PI;
return(Quaternion.Euler(0, angle, 0));
}
case RotationType.TreeRound:
{
Vector3 treeDir = new Vector3(-tile.positionOnTree.x, tile.positionOnTree.z, tile.positionOnTree.y);
if (treeDir.sqrMagnitude < 0.001)
{
return(Quaternion.identity);
}
return(Quaternion.LookRotation(treeDir, Vector3.up));
}
case RotationType.TreeRoundTall:
{
if (noise == null)
{
noise = new OpenSimplexNoise();
}
float mainRot = (float)noise.eval(tile.position.x, tile.position.y, tile.position.z);
Vector3 smallRot = new Vector3((float)noise.eval(tile.position.x, tile.position.y, tile.position.z * 17), (float)noise.eval(tile.position.x * 17, tile.position.y, tile.position.z), 0);
Vector3 treeDir = new Vector3(-tile.positionOnTree.x, tile.positionOnTree.z / 2.0f, tile.positionOnTree.y);
if (treeDir.sqrMagnitude < 0.001)
{
return(Quaternion.identity);
}
return(Quaternion.LookRotation(treeDir, Vector3.up) * Quaternion.Euler(smallRot * 15) * Quaternion.AngleAxis(mainRot * 360.0f, Vector3.back));
}
default:
return(Quaternion.identity);
}
}
/// <summary>
/// Transforms the specified image by flipping and rotating it. First the image
/// will be rotated, then the image will be flipped. A new image will be returned. The original image
/// will not be changed.
/// </summary>
/// <param name="source">The image, which should be transformed.</param>
/// <param name="rotationType">Type of the rotation.</param>
/// <param name="flippingType">Type of the flipping.</param>
/// <returns>The new and transformed image.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null
/// (Nothing in Visual Basic).</exception>
public static ExtendedImage Transform(ExtendedImage source, RotationType rotationType, FlippingType flippingType)
{
Contract.Requires<ArgumentNullException>(source != null, "Source image cannot be null.");
Contract.Requires<ArgumentException>(source.IsFilled, "Source image has not been loaded.");
return PerformAction(source, false, (sourceImage, targetImage) => ImageBase.Transform(sourceImage, targetImage, rotationType, flippingType));
}
protected static RotationType RotateEnum(RotationType type, byte rotation)
{
for (int i = 0; i < rotation; i++)
{
switch (type)
{
case RotationType.RotateNone:
type = RotationType.Rotate90;
break;
case RotationType.Rotate90:
type = RotationType.Rotate180;
break;
case RotationType.Rotate180:
type = RotationType.Rotate270;
break;
case RotationType.Rotate270:
type = RotationType.RotateNone;
break;
}
}
return type;
}
// *** METHODS ***
/// <summary>
/// Rotates the point around a particular axis
/// </summary>
/// <param name="type">Rotation axis</param>
/// <param name="angle">Angle to be rotated</param>
/// <param name="center">Center point of rotation</param>
public Cube3D Rotate(RotationType type, double angle, Point3D center)
{
//Deep Clone
List<Face3D> faces = new List<Face3D>();
foreach (Face3D f in Faces)
{
List<Point3D> edges = new List<Point3D>();
foreach (Point3D p in f.Vertices) { edges.Add(new Point3D(p.X, p.Y, p.Z)); }
Face3D f2 = new Face3D(edges, f.Color, f.Position, f.MasterPosition);
f2.Vertices.ToList().ForEach(e => { e.X -= center.X; e.Y -= center.Y; e.Z -= center.Z; });
f2.Rotate(type, angle);
f2.Vertices.ToList().ForEach(e => { e.X += center.X; e.Y += center.Y; e.Z += center.Z; });
faces.Add(f2);
}
return new Cube3D(faces, this.Position, this.Location,this.Scale);
}
public void Rotate(RotationType rotate_type)
{
if (!gimp_image_rotate(ID, rotate_type))
{
throw new GimpSharpException();
}
}
static extern Int32 gimp_item_transform_rotate_simple(Int32 item_ID,
RotationType rotate_type,
bool auto_center,
int center_x,
int center_y);
public CEC2005Function(IContinuousFunction function, double sigma, double lambda, RotationType rotationType, double bias, double horizontalShift, int condition = 1)
{
_initialized = false;
_rotationDecorator = new RotationDecorator(function);
_rotationDecorator.RotationType = rotationType;
Sigma = sigma;
Lambda = lambda;
Bias = bias;
HorizontalShift = horizontalShift;
_rotationDecorator.Condition = condition;
}
/// <summary>
/// Execute a rotation of the whole cube
/// </summary>
/// <param name="type">Defines the axis to be rotated on</param>
/// <param name="direction">Defines the direction of the rotation (true == clockwise)</param>
public void RotateCube(RotationType type, bool direction)
{
switch (type)
{
case RotationType.X:
RotateLayer(new LayerMove(CubeFlag.RightSlice, direction) & new LayerMove(CubeFlag.MiddleSliceSides, direction) & new LayerMove(CubeFlag.LeftSlice, !direction));
break;
case RotationType.Y:
RotateLayer(new LayerMove(CubeFlag.TopLayer, direction) & new LayerMove(CubeFlag.MiddleLayer, direction) & new LayerMove(CubeFlag.BottomLayer, !direction));
break;
case RotationType.Z:
RotateLayer(new LayerMove(CubeFlag.FrontSlice, direction) & new LayerMove(CubeFlag.MiddleSlice, direction) & new LayerMove(CubeFlag.BackSlice, !direction));
break;
}
}
public RotationJob(ref Rotation _rotation, GroupData group, string _name)
{
rotation = _rotation;
type = RotationType.GroupDone;
name = _name;
}
void OnGUI()
{
EditorGUILayout.Space();
int paletteIndex = palettes.IndexOf(palette);
paletteIndex = EditorGUILayout.Popup("Palette", paletteIndex, paletteNames);
palette = paletteIndex < 0 ? null : palettes[paletteIndex];
if (palette == null)
{
return;
}
if (ev.isMouse)
{
mousePos = ev.mousePosition;
Repaint();
}
optionsToggle = EditorGUILayout.Foldout(optionsToggle, "Options");
if (optionsToggle)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginVertical();
raycastMask = LayerMaskField("Raycast Mask", raycastMask);
var par = EditorGUILayout.ObjectField("Parent To", parentTo, typeof(Transform), true) as Transform;
if (par != parentTo)
{
if (par == null || (PrefabUtility.GetCorrespondingObjectFromSource(par) == null && PrefabUtility.GetPrefabObject(par) == null))
{
parentTo = par;
}
}
onlyUpwards = EditorGUILayout.Toggle("Only Up Normals", onlyUpwards);
//Snapping
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Snap");
snap = EditorGUILayout.Toggle(snap, GUILayout.Width(15f));
GUI.enabled = snap;
snapValue = EditorGUILayout.FloatField(snapValue);
snapValue = Mathf.Max(snapValue, 0f);
GUI.enabled = true;
EditorGUILayout.EndHorizontal();
//Rotation mode
rotationMode = (RotationType)EditorGUILayout.EnumPopup("Rotation Mode", rotationMode);
if (rotationMode == RotationType.Random)
{
minRotation = EditorGUILayout.Vector3Field("Min Rotation", minRotation);
maxRotation = EditorGUILayout.Vector3Field("Max Rotation", maxRotation);
}
else if (rotationMode == RotationType.Custom)
{
customRotation = EditorGUILayout.Vector3Field("Rotation", customRotation);
}
//Scale mode
scaleMode = (ScaleType)EditorGUILayout.EnumPopup("Scale Mode", scaleMode);
if (scaleMode == ScaleType.Random)
{
minScale = EditorGUILayout.Vector3Field("Min Scale", minScale);
maxScale = EditorGUILayout.Vector3Field("Max Scale", maxScale);
}
else if (scaleMode == ScaleType.RandomXYZ)
{
minScaleU = EditorGUILayout.FloatField("Min Scale", minScaleU);
maxScaleU = EditorGUILayout.FloatField("Max Scale", maxScaleU);
}
else if (scaleMode == ScaleType.Custom)
{
customScale = EditorGUILayout.Vector3Field("Scale", customScale);
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.Space();
var header = EditorGUILayout.GetControlRect();
GUI.Label(header, "Prefabs", EditorStyles.boldLabel);
header.y += header.height - 1f;
header.height = 1f;
EditorGUI.DrawRect(header, EditorStyles.label.normal.textColor);
GUILayout.Space(2f);
GUI.enabled = selected != null;
if (GUILayout.Button("Stop Placement (ESC)", EditorStyles.miniButton))
{
Deselect();
}
GUI.enabled = true;
if (ev.type == EventType.KeyDown && ev.keyCode == KeyCode.Escape)
{
Deselect();
}
var buttonHeight = EditorGUIUtility.singleLineHeight * 2f;
var heightStyle = GUILayout.Height(buttonHeight);
var lastRect = GUILayoutUtility.GetLastRect();
var scrollMouse = mousePos;
scrollMouse.x -= lastRect.xMin - prefabScroll.x;
scrollMouse.y -= lastRect.yMax - prefabScroll.y;
prefabScroll = EditorGUILayout.BeginScrollView(prefabScroll);
foreach (var prefab in palette.prefabs)
{
if (prefab == null)
{
continue;
}
var rect = EditorGUILayout.GetControlRect(heightStyle);
var bgRect = rect;
bgRect.x -= 1f;
bgRect.y -= 1f;
bgRect.width += 2f;
bgRect.height += 2f;
if (prefab == selected)
{
EditorGUI.DrawRect(bgRect, new Color32(0x42, 0x80, 0xe4, 0xff));
}
else
{
EditorGUIUtility.AddCursorRect(bgRect, MouseCursor.Link);
if (bgRect.Contains(scrollMouse))
{
EditorGUI.DrawRect(bgRect, new Color32(0x42, 0x80, 0xe4, 0x40));
if (ev.type == EventType.MouseDown)
{
EditorApplication.delayCall += () =>
{
selected = prefab;
SceneView.RepaintAll();
};
}
}
}
var iconRect = new Rect(rect.x, rect.y, rect.height, rect.height);
var icon = AssetPreview.GetAssetPreview(prefab);
if (icon != null)
{
GUI.DrawTexture(iconRect, icon, ScaleMode.ScaleToFit, true, 1f, Color.white, Vector4.zero, Vector4.one * 4f);
}
else
{
EditorGUI.DrawRect(iconRect, EditorStyles.label.normal.textColor * 0.25f);
}
var labelRect = rect;
labelRect.x += iconRect.width + 4f;
labelRect.width -= iconRect.width + 4f;
labelRect.height = EditorGUIUtility.singleLineHeight;
labelRect.y += (buttonHeight - labelRect.height) * 0.5f;
var labelStyle = prefab == selected ? EditorStyles.whiteBoldLabel : EditorStyles.label;
GUI.Label(labelRect, prefab.name, labelStyle);
}
EditorGUILayout.Space();
EditorGUILayout.EndScrollView();
if (AssetPreview.IsLoadingAssetPreviews())
{
Repaint();
}
}
public Voxel ChangeShape(MeshShapeType meshShape, RotationType rotation, bool upsideDown)
{
return(new Voxel(meshShape, rotation, upsideDown, BlockType));
}
/// <summary>
/// Execute a rotation of the whole cube
/// </summary>
/// <param name="type">Defines the axis to be rotated on</param>
/// <param name="direction">Defines the direction of the rotation (true == clockwise)</param>
public void RotateCube(RotationType type, bool direction)
{
switch (type)
{
case RotationType.X:
this.RotateLayer(new LayerMove(CubeFlag.RightSlice, direction) & new LayerMove(CubeFlag.MiddleSliceSides, direction) & new LayerMove(CubeFlag.LeftSlice, !direction));
break;
case RotationType.Y:
this.RotateLayer(new LayerMove(CubeFlag.TopLayer, direction) & new LayerMove(CubeFlag.MiddleLayer, direction) & new LayerMove(CubeFlag.BottomLayer, !direction));
break;
case RotationType.Z:
this.RotateLayer(new LayerMove(CubeFlag.FrontSlice, direction) & new LayerMove(CubeFlag.MiddleSlice, direction) & new LayerMove(CubeFlag.BackSlice, !direction));
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public bool AddTypeElement(System.Xml.Linq.XElement elemtype)
{
XAttribute fileAtt = elemtype.Attribute("file");
if (fileAtt == null)
{
//Add error message here
return(false);
}
if (storeContainer.shapeStore != null &&
(elemtype.Attribute("normal") != null ||
elemtype.Attribute("occlusion") != null ||
elemtype.Attribute("alpha") != null
))
{
_normalTexture = new NormalContent();
_normalTexture.ExternalStorage = storeContainer.shapeStore;
if (!_normalTexture.AddTypeElement(elemtype))
{
_normalTexture = null;
}
}
if (storeContainer.specialStore != null &&
(elemtype.Attribute("metallic") != null ||
elemtype.Attribute("illumination") != null
))
{
_specialTexture = new SpecialMapContent();
_specialTexture.ExternalStorage = storeContainer.specialStore;
if (!_specialTexture.AddTypeElement(elemtype))
{
_specialTexture = null;
}
}
if (storeContainer.materialStore != null &&
(elemtype.Attribute("pattern") != null ||
elemtype.Attribute("specular") != null
))
{
_matTexture = new TextureContent();
_matTexture.ExternalStorage = storeContainer.materialStore;
if (!_matTexture.AddTypeElement(elemtype))
{
_matTexture = null;
}
}
if (fileAtt.Value == "NONE")
{
//This means we don't want to actually store a mesh,
//but still want to use the category.
MeshData = new Dictionary <MeshLayer, CPUMesh>();
}
else
{
string filePath = Path.Combine(Path.GetDirectoryName(new Uri(elemtype.BaseUri).LocalPath), fileAtt.Value);
filePath = Path.GetFullPath(filePath);
// Load the OBJ in
var lStream = new FileStream(filePath, FileMode.Open);
var lOBJData = OBJLoader.LoadOBJ(lStream);
lStream.Close();
MeshData = new Dictionary <MeshLayer, CPUMesh>();
Mesh tempMesh = new Mesh();
foreach (MeshLayer layer in Enum.GetValues(typeof(MeshLayer)))
{
MeshLayer translatedLayer;
if (layer == MeshLayer.GrowthCutout1 ||
layer == MeshLayer.GrowthCutout2 ||
layer == MeshLayer.GrowthCutout3)
{
translatedLayer = MeshLayer.GrowthCutout;
}
else if (layer == MeshLayer.GrowthMaterial1 ||
layer == MeshLayer.GrowthMaterial2 ||
layer == MeshLayer.GrowthMaterial3)
{
translatedLayer = MeshLayer.GrowthMaterial;
}
else if (layer == MeshLayer.GrowthTransparent1 ||
layer == MeshLayer.GrowthTransparent2 ||
layer == MeshLayer.GrowthTransparent3)
{
translatedLayer = MeshLayer.GrowthTransparent;
}
else
{
translatedLayer = layer;
}
tempMesh.LoadOBJ(lOBJData, (layer.ToString()));
if (tempMesh == null || tempMesh.vertexCount == 0)
{
continue;
}
tempMesh.name = filePath + "." + layer.ToString();
if (translatedLayer == MeshLayer.GrowthCutout ||
translatedLayer == MeshLayer.GrowthMaterial ||
translatedLayer == MeshLayer.GrowthTransparent)
{
for (int i = (int)translatedLayer; i < (int)translatedLayer + 4; i++)
{
//This is because the tree growths can be in any order
//So we just copy the un-numbered one onto the rest.
MeshData[(MeshLayer)i] = new CPUMesh(tempMesh);
}
}
else
{
MeshData[layer] = new CPUMesh(tempMesh);
}
tempMesh.Clear();
}
lStream = null;
lOBJData = null;
}
XAttribute rotAtt = elemtype.Attribute("rotation");
if (rotAtt == null)
{
rotationType = RotationType.None;
}
else
{
try
{
rotationType = (RotationType)Enum.Parse(typeof(RotationType), rotAtt.Value);
}
catch
{
rotationType = RotationType.None;
Debug.Log("Unknown rotation value: " + rotAtt.Value);
}
}
return(true);
}
// Use this for initialization
void Start ()
{
tr = transform;
rotationType = RotationType.none;
}
