void Awake()
{
mesh = meshFilter.sharedMesh;
dataA = new SpringData[mesh.vertices.Length];
for (int i = 0; i < dataA.Length; i++)
{
dataA[i].cachedWorldPos = meshFilter.transform.TransformPoint(mesh.vertices[i]);
dataA[i].cachedVelocity = Vector3.zero;
}
dataB = new SpringData[mesh.vertices.Length];
for (int i = 0; i < dataB.Length; i++)
{
dataB[i].cachedWorldPos = meshFilter.transform.TransformPoint(mesh.vertices[i]);
dataB[i].cachedVelocity = Vector3.zero;
}
Graphics.ClearRandomWriteTargets();
compute_buffer_Alpha = new ComputeBuffer(dataA.Length, sizeof(float) * 6, ComputeBufferType.Default);
Graphics.SetRandomWriteTarget(1, compute_buffer_Alpha, false);
material.SetBuffer("_myWriteBuffer", compute_buffer_Alpha);
compute_buffer_Alpha.SetData(dataA);
compute_buffer_Beta = new ComputeBuffer(dataB.Length, sizeof(float) * 6, ComputeBufferType.Default);
Graphics.SetRandomWriteTarget(2, compute_buffer_Beta, false);
material.SetBuffer("_myReadBuffer", compute_buffer_Beta);
compute_buffer_Beta.SetData(dataB);
tempData1 = new SpringData[mesh.vertices.Length];
}
public void Execute()
{
var mousePickCollector = new MousePickCollector(1.0f, CollisionWorld.Bodies, NumDynamicBodies);
mousePickCollector.IgnoreTriggers = IgnoreTriggers;
CollisionWorld.CastRay(RayInput, ref mousePickCollector);
if (mousePickCollector.MaxFraction < 1.0f)
{
float fraction = mousePickCollector.Hit.Fraction;
RigidBody hitBody = CollisionWorld.Bodies[mousePickCollector.Hit.RigidBodyIndex];
MTransform bodyFromWorld = Inverse(new MTransform(hitBody.WorldFromBody));
float3 pointOnBody = Mul(bodyFromWorld, mousePickCollector.Hit.Position);
SpringData[0] = new SpringData
{
Entity = hitBody.Entity,
Dragging = 1,
PointOnBody = pointOnBody,
MouseDepth = Near + math.dot(math.normalize(RayInput.End - RayInput.Start), Forward) * fraction * k_MaxDistance,
};
}
else
{
SpringData[0] = new SpringData
{
Dragging = 0
};
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (m_MouseGroup.CalculateEntityCount() == 0)
{
return(inputDeps);
}
var handle = JobHandle.CombineDependencies(inputDeps, m_BuildPhysicsWorldSystem.FinalJobHandle);
if (Input.GetMouseButtonDown(0) && (Camera.main != null))
{
Vector2 mousePosition = Input.mousePosition;
UnityEngine.Ray unityRay = Camera.main.ScreenPointToRay(mousePosition);
var mice = m_MouseGroup.ToComponentDataArray <MousePick>(Allocator.TempJob);
var IgnoreTriggers = mice[0].IgnoreTriggers != 0;
mice.Dispose();
// Schedule picking job, after the collision world has been built
handle = new Pick
{
CollisionWorld = m_BuildPhysicsWorldSystem.PhysicsWorld.CollisionWorld,
NumDynamicBodies = m_BuildPhysicsWorldSystem.PhysicsWorld.NumDynamicBodies,
SpringData = SpringDatas,
RayInput = new RaycastInput
{
Start = unityRay.origin,
End = unityRay.origin + unityRay.direction * k_MaxDistance,
Filter = CollisionFilter.Default,
},
Near = Camera.main.nearClipPlane,
Forward = Camera.main.transform.forward,
IgnoreTriggers = IgnoreTriggers,
}.Schedule(JobHandle.CombineDependencies(handle, m_BuildPhysicsWorldSystem.FinalJobHandle));
PickJobHandle = handle;
handle.Complete(); // TODO.ma figure out how to do this properly...we need a way to make physics sync wait for
// any user jobs that touch the component data, maybe a JobHandle LastUserJob or something that the user has to set
}
if (Input.GetMouseButtonUp(0))
{
SpringDatas[0] = new SpringData();
}
return(handle);
}
// Start is called before the first frame update
void Start()
{
SpringJoint curSpring = GetComponent <SpringJoint>();
_spring = new SpringData()
{
anchor = curSpring.anchor,
connectedAnchor = curSpring.connectedAnchor,
spring = curSpring.spring,
damper = curSpring.damper
};
Destroy(curSpring);
_trans = gameObject.transform;
_rigid = GetComponent <Rigidbody>();
_prevConstraints = _rigid.constraints; // Should be freeze X and Z movement and all rotation
_rigid.constraints = RigidbodyConstraints.FreezeAll;
_startingY = _trans.position.y;
_bottomY = _startingY - DownDist;
}
public void Execute()
{
float fraction = 1.0f;
RigidBody?hitBody = null;
var rayCastInput = new RaycastInput {
Ray = Ray, Filter = CollisionFilter.Default
};
if (CollisionWorld.CastRay(rayCastInput, out RaycastHit hit))
{
if (hit.RigidBodyIndex < NumDynamicBodies)
{
hitBody = CollisionWorld.Bodies[hit.RigidBodyIndex];
fraction = hit.Fraction;
}
}
// If there was a hit, set up the spring
if (hitBody != null)
{
float3 pointInWorld = (Ray.Origin + Ray.Direction * fraction);
MTransform bodyFromWorld = Inverse(new MTransform(hitBody.Value.WorldFromBody));
float3 pointOnBody = Mul(bodyFromWorld, pointInWorld);
SpringData[0] = new SpringData
{
Entity = hitBody.Value.Entity,
Dragging = 1,
PointOnBody = pointOnBody,
MouseDepth = Near + math.dot(math.normalize(Ray.Direction), Forward) * fraction * k_MaxDistance
};
}
else
{
SpringData[0] = new SpringData
{
Dragging = 0
};
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (m_MouseGroup.CalculateLength() == 0)
{
return(inputDeps);
}
var handle = JobHandle.CombineDependencies(inputDeps, m_BuildPhysicsWorldSystem.FinalJobHandle);
if (Input.GetMouseButtonDown(0) && (Camera.main != null))
{
var mice = m_MouseGroup.ToComponentDataArray <MousePick>(Allocator.TempJob);
var IgnoreTriggers = mice[0].IgnoreTriggers != 0;
mice.Dispose();
// Schedule picking job, after the collision world has been built
handle = new Pick
{
CollisionWorld = m_BuildPhysicsWorldSystem.PhysicsWorld.CollisionWorld,
NumDynamicBodies = m_BuildPhysicsWorldSystem.PhysicsWorld.NumDynamicBodies,
SpringData = SpringDatas,
RayInput = MousePickBehaviour.CreateRayCastFromMouse(),
Near = Camera.main.nearClipPlane,
Forward = Camera.main.transform.forward,
IgnoreTriggers = IgnoreTriggers,
}.Schedule(JobHandle.CombineDependencies(handle, m_BuildPhysicsWorldSystem.FinalJobHandle));
PickJobHandle = handle;
handle.Complete(); // TODO.ma figure out how to do this properly...we need a way to make physics sync wait for
// any user jobs that touch the component data, maybe a JobHandle LastUserJob or something that the user has to set
}
if (Input.GetMouseButtonUp(0))
{
SpringDatas[0] = new SpringData();
}
return(handle);
}
public MousePickSystem()
{
SpringDatas = new NativeArray <SpringData>(1, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
SpringDatas[0] = new SpringData();
}
public static bool Prefix(PolyPhysics.SpringAudioListener __instance, FastList <SpringData> ___springDatas)
{
int progress = 0;
try {
progress = 1;
//if (!shouldRun()) return true;
if (___springDatas == null)
{
return(false);
}
float fixedDeltaTime = Time.fixedDeltaTime;
float b = 0f;
progress = 2;
if (0 < ___springDatas.Count)
{
progress = 3;
if (___springDatas[0].edge == null || ___springDatas[0].edge?.world?.settings?.deltaTimeForVelocityEdge == null)
{
return(false);
}
progress = 4;
float deltaTimeForVelocityEdge = ___springDatas[0].edge.world.settings.deltaTimeForVelocityEdge;
if (1E-06f < deltaTimeForVelocityEdge)
{
b = 1f / deltaTimeForVelocityEdge;
}
progress = 5;
}
for (int i = 0; i < ___springDatas.Count; i++)
{
ref SpringData ptr = ref ___springDatas.array[i];
progress = 6;
//Debug.Log(ptr.edge?.material == null);
//if (ptr.edge.material.isRope && ptr.edge.material.isSpring) continue;
ptr.timeSinceCompressionLastTriggered += fixedDeltaTime;
ptr.timeSinceExpansionLastTriggered += fixedDeltaTime;
progress = 7;
Vec2 a = ptr.edge.node1.solverNode.vel - ptr.edge.node0.solverNode.vel;
a *= b;
Vec2 vec = ptr.edge.node1.solverNode.pos - ptr.edge.node0.solverNode.pos;
vec.Normalize();
progress = 8;
float num = Vec2.Dot(a, vec);
if (__instance.ExpandVelocityThresholdToTriggerSound < num && __instance.soundCooldownTime <= ptr.timeSinceExpansionLastTriggered)
{
ptr.timeSinceExpansionLastTriggered = 0f;
Vec2 vec2 = 0.5f * (ptr.edge.node1.solverNode.pos + ptr.edge.node0.solverNode.pos);
if (num > 4f)
{
MasterAudio.PlaySound3DAtVector3AndForget(__instance.expandBig, vec2, 1f, null, 0f, null, null);
}
else
{
MasterAudio.PlaySound3DAtVector3AndForget(__instance.expandSmall, vec2, 1f, null, 0f, null, null);
}
if (__instance.debugLogSounds)
{
Debug.Log(string.Concat(new object[]
{
"Spring Expansion at ",
vec2,
", speed: ",
num
}));
}
progress = 9;
}
else if (num < __instance.CompressVelocityThresholdToTriggerSound && __instance.soundCooldownTime <= ptr.timeSinceCompressionLastTriggered)
{
ptr.timeSinceCompressionLastTriggered = 0f;
Vec2 vec3 = 0.5f * (ptr.edge.node1.solverNode.pos + ptr.edge.node0.solverNode.pos);
if (num < -4.5f)
{
MasterAudio.PlaySound3DAtVector3AndForget(__instance.compressBig, vec3, 1f, null, 0f, null, null);
}
else
{
MasterAudio.PlaySound3DAtVector3AndForget(__instance.compressSmall, vec3, 1f, null, 0f, null, null);
}
if (__instance.debugLogSounds)
{
Debug.Log(string.Concat(new object[]
{
"Spring Compression at ",
vec3,
", speed: ",
num
}));
}
}
progress = 10;
}
}
void Update()
{
if (Input.GetMouseButton(0))
{
Vector3 screenPoint = Input.mousePosition;
screenPoint.z = _camera.transform.position.z;
Ray ray = _camera.ScreenPointToRay(screenPoint);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, _camera.focalLength, _mask))
{
if (_currentManipulator == null && _releasedManipulators.Count + 1 < ManipulatorManager.MAX_MANIPULATORS)
{
Vector3 pos = _camera.ScreenToWorldPoint(screenPoint);
Quaternion rot = Quaternion.LookRotation(Vector3.forward, hit.normal);
_currentManipulator = Instantiate <Manipulator>(_moveManipulator, pos, rot);
_currentManipulator.gameObject.SetActive(true);
}
}
Debug.DrawRay(ray.origin, ray.direction * 100.0f, hit.transform ? Color.green : Color.red);
if (_currentManipulator)
{
_currentManipulator.handle.position = _camera.ScreenToWorldPoint(screenPoint);
//scale down handle as you pull farther away
float maxDistance = _scalePullMaxDistance;
float t = math.clamp(math.distancesq(_currentManipulator.handle.position, _currentManipulator.transform.position) / (maxDistance * maxDistance), 0.0f, 1.0f);
_currentManipulator.handle.localScale = Vector3.one + (Vector3.one * t * _scalePullMultipler);
}
}
if (Input.GetMouseButtonUp(0) && _currentManipulator)
{
SpringData springData = new SpringData
{
handle = _currentManipulator.handle,
origin = _currentManipulator.transform,
linearVelocity = Vector3.zero,
scaleVelocity = Vector3.zero,
startTime = Time.time
};
_releasedManipulators.Add(springData);
_currentManipulator = null;
}
for (int i = _releasedManipulators.Count - 1; i >= 0; i--)
{
SpringData springData = _releasedManipulators[i];
if (Time.time > springData.startTime + _springDuration)
{
Destroy(_releasedManipulators[i].origin.gameObject);
_releasedManipulators.RemoveAt(i);
break;
}
_releasedManipulators[i].handle.position += springData.linearVelocity * Time.deltaTime;
_releasedManipulators[i].handle.localScale += springData.scaleVelocity * Time.deltaTime;
Vector3 linearAcceleration = (-_springStrength * (_releasedManipulators[i].handle.position - _releasedManipulators[i].origin.position)) * Time.deltaTime;
springData.linearVelocity += linearAcceleration;
springData.linearVelocity *= _springDampening;
Vector3 scaleAcceleration = (-_springStrength * (_releasedManipulators[i].handle.localScale - Vector3.one)) * Time.deltaTime;
springData.scaleVelocity += scaleAcceleration;
springData.scaleVelocity *= _springDampening;
_releasedManipulators[i] = springData;
}
if (Input.GetKeyDown(KeyCode.Space))
{
float slowMotionTime = 0.2f;
Time.timeScale = Time.timeScale == slowMotionTime ? 1.0f : slowMotionTime;
Time.fixedDeltaTime = 0.02F * Time.timeScale;
}
}
