public override void Use(SculptState state, Deformer deformer)
{
deformer.UpdateMask(state);
var mask = deformer.Selection;
var deformation = deformer.Deformation;
Vector3 avgNormal = Vector3.zero;
for (int i = 0; i < deformer.SelectionCount; i++)
{
avgNormal += SculptMesh.Normals[mask[i]];
}
avgNormal.Normalize();
float amp = strength * state.strength;
float inv = state.drawingInverted ? -1f : 1f;
for (int i = 0; i < deformer.SelectionCount; ++i)
{
deformation[i] = amp * inv * avgNormal;
}
deformer.ApplyDeformation();
}
//=========================================================================================
/// <summary>
/// データを識別するハッシュコードを作成して返す
/// </summary>
/// <returns></returns>
public override int GetDataHash()
{
int hash = 0;
hash += Deformer.GetDataHash();
return(hash);
}
public override void Use(SculptState state, Deformer deformer)
{
if (state.drawingDown)
{
deformer.UpdateMask(state);
prevPosition = state.position;
}
if (deformer.SelectionCount == 0)
{
return;
}
var delta = state.worldToLocal * state.position - state.worldToLocal * prevPosition;
var deformation = deformer.Deformation;
for (int i = 0; i < deformer.SelectionCount; ++i)
{
deformation[i] = delta;
}
prevPosition = state.position;
deformer.ApplyDeformation();
}
void Start()
{
graceFrames = maxGraceFrames;
sprite = transform.Find("AtlasSprite");
spriteController = sprite.GetComponent <atlasSpriteController>();
anim = GetComponentInChildren <Animator>();
deformer = GetComponentInChildren <Deformer>();
controller = GetComponent <characterController>();
particleMaker = GetComponent <particleMaker>();
boxCollider = GetComponent <BoxCollider2D>();
steps = GetComponentInChildren <stepSounds>();
hanger = transform.Find("AtlasSprite/Hanger");
colliderStartSize = boxCollider.size;
colliderStartOffset = boxCollider.offset;
sortingOrder = sprite.GetComponent <SpriteRenderer>().sortingOrder;
gravity = gameManager.Instance.gravity; //-(2 * jumpHeight) / Mathf.Pow(timeToJumpApex, 2);
jumpVelocity = Mathf.Abs(gravity) * timeToJumpApex;
float djgravity = -(2 * doubleJumpHeight) / Mathf.Pow(timeToJumpApex, 2);
doubleJumpVelocity = Mathf.Abs(djgravity) * timeToDoubleJumpApex;
setLastSafePosition();
warpToCurrentDoor();
if (created)
{
Destroy(gameObject);
}
created = true;
DontDestroyOnLoad(gameObject);
}
public override void Use(SculptState state, Deformer deformer)
{
deformer.UpdateMask(state);
var mask = deformer.Selection;
var edgeRecorder = new HashSet <int>();
Vector3[] deformation = deformer.Deformation;
for (int i = 0; i < deformer.SelectionCount; i++)
{
var vert = SculptMesh.Topology.Vertices[mask[i]];
var force = new Vector3();
foreach (var edge in vert.Edges)
{
var other = edge.GetOtherVertex(vert);
var p0 = SculptMesh.Points[vert.Id];
var p1 = SculptMesh.Points[other.Id];
var delta = p1 - p0;
force += delta;
}
deformation[i] = strength * state.strength * force;
}
deformer.ApplyDeformation();
}
public void OnTriggerStay(Collider other)
{
//Debug.Log("OnTriggerStay");
// these are reversed so this is from the perspective of the touching object/Deformer
Vector3 source = other.collider.transform.position; // the touching object/Deformer
GameObject target = this.gameObject; // ourselves as target
lastDeformerDeformer = other.gameObject.GetComponent<Deformer>();
lastDeformerCollider = other;
RaycastHit hit = GetSurfacePoint(source, target, Color.red);
if (!hit.point.Equals(null))
{
//keep the distance during collision so if we move out of distance release
distanceSave = Vector3.Distance(hit.point, source);
attached = true;
lastHit = hit;
lastVertexIdx = MeshDeform.GetNearestVertIdx(mf.transform.InverseTransformPoint(hit.point), mf.mesh.vertices);
// Color[] clrs = mf.mesh.colors;
// // set colors that we hit depending on pushing or pulling
// if (c.handDetector.open)
// clrs[lastVertexIdx] = Color.cyan;
// else
// clrs[lastVertexIdx] = Color.white;
// mf.mesh.colors = clrs;
//Debug.Log("attaching: " + hit.collider.name + ", distance: " + distanceSave);
}
}
public override object ConvertTo(ITypeDescriptorContext context,
CultureInfo culture,
object value,
System.Type destinationType)
{
if (destinationType == typeof(System.String) &&
value is Deformer)
{
Deformer deformer = (Deformer)value;
return(deformer.ToString());
}
return(base.ConvertTo(context, culture, value, destinationType));
}
// Start is called before the first frame update
void Start()
{
health = GetComponent <healthController>();
anim = GetComponentInChildren <Animator>();
controller = GetComponent <characterController>();
deformer = GetComponentInChildren <Deformer>();
facing = (int)transform.localScale.x;
setFacing();
gravity = gameManager.Instance.gravity;
maxFallVel = gameManager.Instance.maxFallVel;
state = State.Movement;
act = (readyToPounce) ? 0 : actionCoolDown;
}
// Start is called before the first frame update
void Start()
{
cc = GetComponent <characterController>();
hc = GetComponent <healthController>();
anim = GetComponentInChildren <Animator>();
deformer = GetComponentInChildren <Deformer>();
while (startDir == 0)
{
startDir = Random.Range(-1, 1);
}
velocity = Vector3.right * startDir;
}
private void Start()
{
anim = GetComponent <Animator>();
deformer = GetComponent <Deformer>();
col = GetComponent <BoxCollider2D>();
Vector2 scenePos = AtlasSceneManager.getPlayerCoords();
if (scenePos.x >= 6 && scenePos.x <= 12 && scenePos.y >= -1 && scenePos.y <= 4)
{
setDry();
}
AtlasEventManager.Instance.onFlagSet += setDry;
}
void HandleInput()
{
Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit2D hit = Physics2D.Raycast(inputRay.origin, inputRay.direction);
//RaycastHit hit;
if (hit)
{
Deformer deformer = hit.collider.GetComponent <Deformer>();
if (deformer)
{
Vector2 point = hit.point;
deformer.AddDeformingForce(point, force);
}
}
}
// Start is called before the first frame update
protected virtual void Start()
{
anim = GetComponentInChildren <Animator>();
controller = GetComponent <characterController>();
deformer = GetComponentInChildren <Deformer>();
boxCollider = GetComponent <BoxCollider2D>();
healthCtrl = GetComponent <healthController>();
sprite = transform.Find("sprite");
gravity = gameManager.Instance.gravity;
maxFallVel = gameManager.Instance.maxFallVel;
state = new StateMachine("Movement");
state.addStates("Hurt", "Wait", "Attack");
intangibleStates = state.findStates("Hurt", "Wait");
state.setState("Movement");
}
// Start is called before the first frame update
void Start()
{
fillParent = GetComponentInChildren <CanvasGroup>();
if (fillParent)
{
fillParent.alpha = 0;
}
slider = GetComponentInChildren <Slider>();
deformer = GetComponent <Deformer>();
if (!deformer)
{
deformer = GetComponentInChildren <Deformer>();
}
hitpoints = maxHitpoints;
}
public static List <Bone> GetBoneHierarchy(FBXTreeNode node, FBXFile fbx)
{
var bones = new List <Bone>();
var modelNodes = node.Children.Where(a => a.Node.Name == "Model");
foreach (var child in modelNodes)
{
var model = new Model(child.Node, fbx);
if (model.ModelType == Model.FBXModelType.LimbNode || (model.ModelType == Model.FBXModelType.None && !model.HasGeometry))
{
var children = GetBoneHierarchy(child, fbx);
var t = model.LclTranslation;
var r = model.LclRotation.ToRadians().QuaternionFromEuler(EulerOrder.XYZ);
var s = model.LclScaling;
var deformerId = fbx.Connections.Where(a => a.Src == model.Id && fbx.FindChild(a.Dst).Name == "Deformer").FirstOrDefault();
var globalInverseMatrix = new float[] { }.IdentityMatrix();
if (deformerId != null)
{
var deformer = new Deformer(fbx.FindChild(deformerId.Dst));
}
var bone = new Bone()
{
Id = model.Id.ToString(),
Parent = (node.Node != null) ? node.Node.Id.ToString() : "",
Children = children.Select(a => a.Id).ToList(),
JointMatrix = new float[] { }.MatrixCompose(t, r, s),
Name = model.Name
};
bone.Keyframes = GetBoneKeyFrames(bone, fbx);
bones.Add(bone);
bones.AddRange(children);
}
}
return(bones);
}
public IEnumerator ModifyMesh()
{
var timer = new Timer("modify-mesh");
var menu = new Menu(ToolType.Move);
var deformer = new Deformer(sculptMesh);
var state = new SculptState {
position = Vector3.up * .5f,
worldToLocal = sculptMesh.Wrapper.MeshTransform.worldToLocalMatrix
};
timer.PrintTime(() => {
deformer.UpdateMask(state);
}, "Select vertices");
Vector3 offset = Vector3.up * Random.value;
int pickId = Random.Range(0, deformer.Selection.Length);
var vec = sculptMesh.Points[deformer.Selection[pickId]];
var weight = deformer.Weights[pickId];
timer.PrintTime(() => {
var deformation = deformer.Deformation;
for (int i = 0; i < deformer.SelectionCount; ++i)
{
deformation[i] = offset;
}
}, "Create deform field");
timer.PrintTime(() => sculptMesh.UpdateMeshData(), "Update mesh data");
Debug.Log($"{deformer.SelectionCount} vertices modified out of {sculptMesh.Points.Length}.\n");
timer.PrintTotalTime();
timer.SaveCsv();
Assert.Less(timer.TotalTime, 100);
Assert.AreEqual(sculptMesh.Points[deformer.Selection[pickId]], vec + weight * offset);
yield return(null);
}
public virtual void Init(SculptMesh sculptMesh, Menu menu)
{
MeshWrapper = sculptMesh.Wrapper;
Menu = menu;
deformer = new Deformer(sculptMesh);
mirrorDeformer = new Deformer(sculptMesh);
tools = new ToolCollection(sculptMesh);
mirrorTools = new ToolCollection(sculptMesh);
uiComponents.ForEach(ui => ui.Init(Menu));
stateStack = new Stack <SculptState>();
running = true;
new Thread(
new ThreadStart(SculptLoop)
).Start();
}
void handleTornado()
{
canTornado = false;
canBroom = true;
canDoubleJump = true;
anim.SetBool("inTornado", true);
velocity = Vector3.zero;
transform.position = Vector3.SmoothDamp(transform.position, currentTornado.position, ref velocitySmoothing, 0.05f);
if (AtlasInputManager.getKeyPressed("Jump"))
{
firstJump();
anim.SetBool("inTornado", false);
returnToMovement();
Deformer nadoDeformer = currentTornado.GetComponent <Deformer>();
if (nadoDeformer)
{
nadoDeformer.startDeform(new Vector3(0.75f, 2.0f, 1.0f), 0.1f);
SoundManager.Instance.playClip("LevelObjects/EnterTornado", 1);
}
currentTornado = null;
}
if (AtlasInputManager.getKeyPressed("Down"))
{
movingPlatform mp = currentTornado.GetComponent <movingPlatform>();
if (mp)
{
velocity.x = mp.getVelocity().x;
}
Deformer nadoDeformer = currentTornado.GetComponent <Deformer>();
if (nadoDeformer)
{
nadoDeformer.startDeform(new Vector3(2.0f, 0.25f, 1.0f), 0.1f);
}
anim.SetBool("inTornado", false);
returnToMovement();
currentTornado = null;
SoundManager.Instance.playClip("LevelObjects/EnterTornado", -1);
}
}
private void OnTriggerEnter2D(Collider2D other)
{
List <Collider2D> hitters = new List <Collider2D>();
other.GetContacts(hitters);
//Because the hitboxes appear as children, we have to filter AllyHitboxes out
//Otherwise you could get hurt by whacking brambles or something
//We can probably use this to implement hitlag when hurting things..
foreach (Collider2D h in hitters)
{
if (h.tag == "AllyHitbox")
{
continue;
}
//if (other.transform.tag == "ResetDamaging" && !invulnerable)
//{
// if (graceFrames > 0)
// {
// graceFrames--;
// }
// else
// {
// resetPosition = true;
// }
//}
if (intangibleStates.Contains(state))
{
return;
}
//if (other.gameObject.layer == LayerMask.NameToLayer("Danger") && !invulnerable)
//{
// if (other.CompareTag("ResetDamaging") && graceFrames > 0) return;
// startBonk(1, resetPosition);
// return;
//}
if (other.tag == "Tornado" && canTornado)
{
resetAnimator();
SoundManager.Instance.playClip("LevelObjects/EnterTornado");
canTornado = false;
state = State.Tornado;
currentTornado = other.transform;
Deformer nadoDeformer = other.GetComponent <Deformer>();
if (nadoDeformer)
{
nadoDeformer.startDeform(new Vector3(1.75f, .75f, 1.0f), 0.1f);
}
}
if (other.CompareTag("Door"))
{
if (other.GetComponent <doorController>().enterable)
{
currentDoor = other.GetComponent <doorController>();
}
}
if (other.tag == "Follower")
{
followController other_fc = other.GetComponent <followController>();
if (!other_fc.canCollect)
{
return;
}
int numFollowers = 0;
other_fc.following = getFollower(GetComponent <followController>());
other_fc.following.followedBy = other_fc;
other_fc.canCollect = false;
followController getFollower(followController fc)
{
if (!fc.followedBy)
{
return(fc);
}
else
{
numFollowers++;
return(getFollower(fc.followedBy));
}
}
SoundManager.Instance.playClip("Collectibles/starShard", numFollowers);
}
if (other.CompareTag("BroomCollectible") && state == State.Broom && hanger.childCount == 0)
{
other.transform.parent = hanger;
other.transform.position = hanger.position - Vector3.up * 0.15f;
other.SendMessage("BroomPickUp");
}
if (other.CompareTag("Water"))
{
steps.isSubmerged = true;
}
}
}
private void Start()
{
deformer = GetComponent <Deformer>();
}
public abstract void Use(SculptState state, Deformer deformer);
private bool StartMoving()
{
// find closest selected vertex
this.GrabContext();
OpenGLProjector projector = new OpenGLProjector();
Mesh m = currMeshRecord.Mesh;
Deformer deformer = currMeshRecord.Deformer;
Rectangle viewport = new Rectangle(0, 0, this.Width, this.Height);
double eps = Program.toolsProperty.DepthTolerance;
double minDis = double.MaxValue;
int minIndex = -1;
for (int i = 0, j = 0; i < m.VertexCount; i++, j += 3)
{
if (m.Flag[i] == 0)
{
continue;
}
Vector3d v3d = projector.Project(m.VertexPos, j);
Vector2d v = new Vector2d(v3d.x, v3d.y);
if (viewport.Contains((int)v.x, (int)v.y) == false)
{
continue;
}
if (projector.GetDepthValue((int)v.x, (int)v.y) - v3d.z < eps)
{
continue;
}
double dis = (v - mouseDownPosition).Length();
if (dis < minDis)
{
minDis = dis;
minIndex = i;
}
}
if (minIndex == -1)
{
this.handleFlag = -1;
this.handleIndex.Clear();
this.oldHandlePos.Clear();
return(false);
}
// find boundary box
int flag = m.Flag[minIndex];
this.handleFlag = flag;
this.handleIndex.Clear();
this.oldHandlePos.Clear();
Vector3d c = new Vector3d(0, 0, 0);
int count = 0;
{
for (int i = 0; i < m.VertexCount; i++)
{
if (m.Flag[i] == flag)
{
Vector3d p = new Vector3d(m.VertexPos, i * 3);
c += p;
this.handleIndex.Add(i);
this.oldHandlePos.Add(p);
count++;
}
}
}
c /= (double)count;
this.handleCenter = new Vector4d(c, 0);
this.projectedCenter = projector.Project(handleCenter.x, handleCenter.y, handleCenter.z);
return(true);
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
this.currMousePosition = new Vector2d(e.X, this.Height - e.Y);
this.mouseDownPosition = currMousePosition;
this.isMouseDown = true;
switch (Program.currentMode)
{
case Program.EnumOperationMode.Viewing:
switch (e.Button)
{
case MouseButtons.Left: ball.Click(currMousePosition, Trackball.MotionType.Rotation); break;
case MouseButtons.Middle: ball.Click(currMousePosition / this.scaleRatio, Trackball.MotionType.Pan); break;
case MouseButtons.Right: ball.Click(currMousePosition, Trackball.MotionType.Scale); break;
}
break;
case Program.EnumOperationMode.Selection:
break;
case Program.EnumOperationMode.Moving:
if (this.StartMoving() == true)
{
Vector2d p = mouseDownPosition - new Vector2d(projectedCenter.x, projectedCenter.y);
p.x += 100;
p.y += 100;
switch (e.Button)
{
case MouseButtons.Right: movingBall.Click(p, Trackball.MotionType.Rotation); break;
case MouseButtons.Left: movingBall.Click(p / this.scaleRatio, Trackball.MotionType.Pan); break;
case MouseButtons.Middle: movingBall.Click(p, Trackball.MotionType.Scale); break;
}
if (currMeshRecord.Deformer != null)
{
currMeshRecord.Deformer.MouseDown();
}
this.Refresh();
}
break;
case Program.EnumOperationMode.PickSkeNode:
if (skeHandleIndex != -1)
{
this.GrabContext();
OpenGLProjector projector = new OpenGLProjector();
Deformer deformer = currMeshRecord.Deformer;
this.skeHandleCenter = new Vector4d(skeHandlepos, 0);
this.projectedCenter = projector.Project(skeHandlepos);
Vector2d p = mouseDownPosition - new Vector2d(projectedCenter.x, projectedCenter.y);
p.x += 100;
p.y += 100;
switch (e.Button)
{
case MouseButtons.Left: movingBall.Click(p / this.scaleRatio, Trackball.MotionType.Pan); break;
}
if (currMeshRecord.Deformer != null)
{
currMeshRecord.Deformer.MouseDown();
}
this.Refresh();
}
break;
}
}
