public override void Draw(DebugDraw debugDraw)
{
float r = 1000;
Vec2 p1 = offset * normal + Vec2.Cross(normal, r);
Vec2 p2 = offset * normal - Vec2.Cross(normal, r);
Color color = new Color(0,0,0.8f);
debugDraw.DrawSegment(p1, p2, color);
}
public override void Draw(DebugDraw debugDraw)
{
float r = 1000;
Vector2 p1 = Offset * Normal + Normal.CrossScalarPostMultiply(r);
Vector2 p2 = Offset * Normal - Normal.CrossScalarPostMultiply(r);
Color color = new Color(0, 0, 0.8f);
debugDraw.DrawSegment(p1, p2, color);
}
public void UpdatePresentationState(bool firstUpdate, float deltaTime)
{
if (firstUpdate)
{
m_AnimState.turnDirection = 0;
m_AnimState.turnStartAngle = m_AnimState.rotation;
}
var aimYawLocal = Mathf.DeltaAngle(m_AnimState.rotation, m_AnimState.aimYaw);
var absAimYawLocal = Mathf.Abs(aimYawLocal);
if (m_AnimState.turnDirection == 0)
{
if (absAimYawLocal > m_Settings.aimTurnLocalThreshold)
{
m_AnimState.turnStartAngle = m_AnimState.rotation;
m_AnimState.turnDirection = Mathf.Sign(aimYawLocal);
}
}
float absAngleRemaining = 0f;
if (m_AnimState.turnDirection != 0)
{
var rotateAngleRemaining = Mathf.DeltaAngle(m_AnimState.rotation, m_AnimState.turnStartAngle) + m_Settings.animTurnAngle * m_AnimState.turnDirection;
if (rotateAngleRemaining * m_AnimState.turnDirection <= 0)
{
m_AnimState.turnDirection = 0;
}
else
{
var turnSpeed = m_Settings.turnSpeed;
if (absAimYawLocal > m_Settings.turnThreshold)
{
var factor = 1.0f - (180 - absAimYawLocal) / m_Settings.turnThreshold;
turnSpeed = turnSpeed + factor * 300;
}
var deltaAngle = deltaTime * turnSpeed;
absAngleRemaining = Mathf.Abs(rotateAngleRemaining);
if (deltaAngle > absAngleRemaining)
{
deltaAngle = absAngleRemaining;
}
var sign = Mathf.Sign(rotateAngleRemaining);
m_AnimState.rotation += sign * deltaAngle;
while (m_AnimState.rotation > 360.0f)
{
m_AnimState.rotation -= 360.0f;
}
while (m_AnimState.rotation < 0.0f)
{
m_AnimState.rotation += 360.0f;
}
}
}
if (m_Settings.footIK.enabled)
{
var footIkJob = m_FootIk.GetJobData <FootIkJob>();
if (m_PredictedState.velocity.magnitude > 0.001f)
{
m_StandState = StandState.Moving;
}
else if (m_AnimState.turnDirection != 0 && m_StandState != StandState.TurnStart && m_StandState != StandState.Turning)
{
m_StandState = StandState.TurnStart;
}
else if (m_AnimState.turnDirection != 0)
{
m_StandState = StandState.Turning;
}
else if (m_AnimState.turnDirection == 0 && m_StandState == StandState.Turning)
{
m_StandState = StandState.TurnEnd;
}
else
{
m_StandState = StandState.Standing;
}
if (m_StandState == StandState.Moving || firstUpdate)
{
var rotation = Quaternion.Euler(0f, m_AnimState.rotation, 0f);
m_LeftFootPos = rotation * m_Settings.footIK.leftToeStandPos + m_AnimState.position;
m_RightFootPos = rotation * m_Settings.footIK.rightToeStandPos + m_AnimState.position;
}
else if (m_StandState == StandState.TurnStart)
{
var predictedRotation = Quaternion.Euler(0f, m_AnimState.turnStartAngle + m_Settings.animTurnAngle * m_AnimState.turnDirection, 0f);
m_LeftFootPos = predictedRotation * m_Settings.footIK.leftToeStandPos + m_AnimState.position;
m_RightFootPos = predictedRotation * m_Settings.footIK.rightToeStandPos + m_AnimState.position;
}
if (m_StandState == StandState.Moving || m_StandState == StandState.TurnStart)
{
var rayEmitOffset = Vector3.up * m_Settings.footIK.emitRayOffset;
var maxRayDistance = m_Settings.footIK.emitRayOffset + m_Settings.footIK.maxRayDistance;
m_LeftHitSuccess = Physics.Raycast(m_LeftFootPos + rayEmitOffset, Vector3.down, out m_LeftHit, maxRayDistance, m_Mask);
m_RightHitSuccess = Physics.Raycast(m_RightFootPos + rayEmitOffset, Vector3.down, out m_RightHit, maxRayDistance, m_Mask);
}
if (firstUpdate)
{
footIkJob.ikWeight = 0.0f;
}
if (m_StandState == StandState.Moving || m_StandState == StandState.TurnEnd)
{
m_AnimState.footIkOffset = GetClampedOffset();
m_AnimState.footIkNormalLeft = m_LeftHit.normal;
m_AnimState.footIkNormaRight = m_RightHit.normal;
m_TurnStartOffset.x = m_AnimState.footIkOffset.x;
m_TurnStartOffset.y = m_AnimState.footIkOffset.y;
m_TurnStartNormals[0] = m_LeftHit.normal;
m_TurnStartNormals[1] = m_RightHit.normal;
}
else if (m_StandState == StandState.TurnStart)
{
m_TurnEndOffset = GetClampedOffset();
m_TurnEndNormals[0] = m_LeftHit.normal;
m_TurnEndNormals[1] = m_RightHit.normal;
}
if (m_StandState == StandState.TurnStart || m_StandState == StandState.Turning)
{
var turnFraction = (-absAngleRemaining + m_Settings.animTurnAngle) / m_Settings.animTurnAngle;
var footFalls = m_AnimState.turnDirection == -1 ? m_LeftTurnFootFalls : m_RightTurnFootFalls;
var leftFootFraction = GetFootFraction(turnFraction, footFalls.leftFootUp, footFalls.leftFootDown);
m_AnimState.footIkOffset.x = Mathf.Lerp(m_TurnStartOffset.x, m_TurnEndOffset.x, leftFootFraction);
m_AnimState.footIkNormalLeft = Vector3.Lerp(m_TurnStartNormals[0], m_TurnEndNormals[0], leftFootFraction);
var rightFootFraction = GetFootFraction(turnFraction, footFalls.rightFootUp, footFalls.rightFootDown);
m_AnimState.footIkOffset.y = Mathf.Lerp(m_TurnStartOffset.y, m_TurnEndOffset.y, rightFootFraction);
m_AnimState.footIkNormaRight = Vector3.Lerp(m_TurnStartNormals[1], m_TurnEndNormals[1], rightFootFraction);
}
#if UNITY_EDITOR
footIkJob.settings = m_Settings.footIK;
if (m_Settings.footIK.debugRayCast)
{
DebugDraw.Sphere(m_LeftFootPos, 0.025f, Color.yellow);
DebugDraw.Sphere(m_RightFootPos, 0.025f, Color.yellow);
DebugDraw.Sphere(m_LeftHit.point, 0.015f);
DebugDraw.Sphere(m_RightHit.point, 0.015f);
Debug.DrawLine(m_LeftHit.point, m_LeftHit.point + m_LeftHit.normal, Color.green);
Debug.DrawLine(m_RightHit.point, m_RightHit.point + m_RightHit.normal, Color.red);
}
#endif
m_FootIk.SetJobData(footIkJob);
}
}
void UploadBlueprint()
{
if (_blueprint == null)
{
return;
}
var buildingManager = gameObject.GetSystem <IBuildingSystem>();
var buildPosition = Camera.main.transform.position + Camera.main.transform.rotation * Vector3.forward * 3f;
var buildRotation = Quaternion.AngleAxis(Camera.main.transform.rotation.eulerAngles.y, Vector3.up);
DebugDraw.DrawMarker(buildPosition, 0.25f, Color.blue);
_blueprint.transform.position = buildPosition;
_blueprint.transform.rotation = buildRotation;
BuildingSlot closestSlot = null;
var occupied = false;
var building = buildingManager.GetBuildingInRange(buildPosition, 3f);
if (building != null)
{
float closestDistance = float.MaxValue;
var sockets = _blueprint.GetComponentsInChildren <BuildingSocket>();
foreach (var socket in sockets)
{
float distance;
var slot = building.GetClosestSlot(socket.transform.position, socket.slotType, true, out distance);
if (slot == null)
{
continue;
}
if (distance < 0.25f && distance < closestDistance)
{
closestDistance = distance;
closestSlot = slot;
}
}
if (closestSlot != null)
{
buildPosition = closestSlot.transform.position;
buildRotation = closestSlot.transform.rotation;
occupied = !building.IsSlotFree(closestSlot);
}
}
_blueprint.transform.position = buildPosition + Vector3.up * 0.025f;
_blueprint.transform.rotation = buildRotation;
_blueprint.GetComponent <Renderer>().sharedMaterial = !occupied ? blueprintMaterial : occupiedBlueprintMaterial;
//
var canBuild = (_currentPartType.canCreateNewBuilding && building == null || closestSlot != null) && !occupied;
if (canBuild && Input.GetMouseButton(0))
{
if (building == null)
{
//building = buildingManager.CreateBuilding(_buildingType, buildPosition, buildRotation);
}
building.AddPart(_currentPartType, closestSlot);
building.Rebuild();
}
//
if (building != null && Input.GetMouseButtonDown(1))
{
var partIdx = building.GetClosestPartIdx(buildPosition);
if (partIdx != -1)
{
building.RemovePart(partIdx);
building.Rebuild();
}
}
}
public static Vector3 ClosestPointOnSurface(TerrainCollider collider, Vector3 to, float radius, bool debug = false)
{
TerrainData terrainData = collider.terrainData;
Vector3 local = collider.transform.InverseTransformPoint(to);
// Calculate the size of each tile on the terrain horizontally and vertically.
float pixelSizeX = terrainData.size.x / (terrainData.heightmapResolution - 1);
float pixelSizeZ = terrainData.size.z / (terrainData.heightmapResolution - 1);
float percentZ = Mathf.Clamp01(local.z / terrainData.size.z);
float percentX = Mathf.Clamp01(local.x / terrainData.size.x);
float positionX = percentX * (terrainData.heightmapResolution - 1);
float positionZ = percentZ * (terrainData.heightmapResolution - 1);
// Calculate our position, in tiles, on the terrain.
int pixelX = Mathf.FloorToInt(positionX);
int pixelZ = Mathf.FloorToInt(positionZ);
// Calculate the distance from our point to the edge of the tile we are in.
float distanceX = (positionX - pixelX) * pixelSizeX;
float distanceZ = (positionZ - pixelZ) * pixelSizeZ;
// Find out how many tiles we are overlapping on the X plane.
float radiusExtentsLeftX = radius - distanceX;
float radiusExtentsRightX = radius - (pixelSizeX - distanceX);
int overlappedTilesXLeft = radiusExtentsLeftX > 0 ? Mathf.FloorToInt(radiusExtentsLeftX / pixelSizeX) + 1 : 0;
int overlappedTilesXRight = radiusExtentsRightX > 0 ? Mathf.FloorToInt(radiusExtentsRightX / pixelSizeX) + 1 : 0;
// Find out how many tiles we are overlapping on the Z plane.
float radiusExtentsLeftZ = radius - distanceZ;
float radiusExtentsRightZ = radius - (pixelSizeZ - distanceZ);
int overlappedTilesZLeft = radiusExtentsLeftZ > 0 ? Mathf.FloorToInt(radiusExtentsLeftZ / pixelSizeZ) + 1 : 0;
int overlappedTilesZRight = radiusExtentsRightZ > 0 ? Mathf.FloorToInt(radiusExtentsRightZ / pixelSizeZ) + 1 : 0;
// Retrieve the heights of the pixels we are testing against.
int startPositionX = pixelX - overlappedTilesXLeft;
int startPositionZ = pixelZ - overlappedTilesZLeft;
int numberOfXPixels = overlappedTilesXRight + overlappedTilesXLeft + 1;
int numberOfZPixels = overlappedTilesZRight + overlappedTilesZLeft + 1;
// Account for if we are off the terrain.
if (startPositionX < 0)
{
numberOfXPixels -= Mathf.Abs(startPositionX);
startPositionX = 0;
}
if (startPositionZ < 0)
{
numberOfZPixels -= Mathf.Abs(startPositionZ);
startPositionZ = 0;
}
if (startPositionX + numberOfXPixels + 1 > terrainData.heightmapResolution)
{
numberOfXPixels = terrainData.heightmapResolution - startPositionX - 1;
}
if (startPositionZ + numberOfZPixels + 1 > terrainData.heightmapResolution)
{
numberOfZPixels = terrainData.heightmapResolution - startPositionZ - 1;
}
// Retrieve the heights of the tile we are in and all overlapped tiles.
float[,] heights = terrainData.GetHeights(startPositionX, startPositionZ, numberOfXPixels + 1, numberOfZPixels + 1);
// Pre-scale the heights data to be world-scale instead of 0...1.
for (int i = 0; i < numberOfXPixels + 1; i++)
{
for (int j = 0; j < numberOfZPixels + 1; j++)
{
heights[j, i] *= terrainData.size.y;
}
}
// Find the shortest distance to any triangle in the set gathered.
float shortestDistance = float.MaxValue;
Vector3 shortestPoint = Vector3.zero;
for (int x = 0; x < numberOfXPixels; x++)
{
for (int z = 0; z < numberOfZPixels; z++)
{
// Build the set of points that creates the two triangles that form this tile.
Vector3 a = new Vector3((startPositionX + x) * pixelSizeX, heights[z, x], (startPositionZ + z) * pixelSizeZ);
Vector3 b = new Vector3((startPositionX + x + 1) * pixelSizeX, heights[z, x + 1], (startPositionZ + z) * pixelSizeZ);
Vector3 c = new Vector3((startPositionX + x) * pixelSizeX, heights[z + 1, x], (startPositionZ + z + 1) * pixelSizeZ);
Vector3 d = new Vector3((startPositionX + x + 1) * pixelSizeX, heights[z + 1, x + 1], (startPositionZ + z + 1) * pixelSizeZ);
BSPTree.ClosestPointOnTriangleToPoint(ref a, ref d, ref c, ref local, out Vector3 nearest);
float distance = (local - nearest).sqrMagnitude;
if (distance <= shortestDistance)
{
shortestDistance = distance;
shortestPoint = nearest;
}
BSPTree.ClosestPointOnTriangleToPoint(ref a, ref b, ref d, ref local, out nearest);
distance = (local - nearest).sqrMagnitude;
if (distance <= shortestDistance)
{
shortestDistance = distance;
shortestPoint = nearest;
}
if (debug)
{
DebugDraw.DrawTriangle(a, d, c, Color.cyan);
DebugDraw.DrawTriangle(a, b, d, Color.red);
}
}
}
return(collider.transform.TransformPoint(shortestPoint));
}
/// <summary>
/// Draws a debug visualization of an individual navmesh tile.
/// </summary>
/// <remarks>
/// <para>
/// The tile will be checked to see if it is in use before it is drawn. So there is no
/// need for caller to do so.
/// </para>
/// </remarks>
private static void Draw(NavmeshTile tile
, NavmeshQuery query, uint[] markPolys, int markPolyCount
, int colorId)
{
NavmeshTileHeader header = tile.GetHeader();
// Keep this check. Less trouble for clients.
if (header.polyCount < 1)
{
return;
}
DebugDraw.SimpleMaterial.SetPass(0);
uint polyBase = tile.GetBasePolyRef();
NavmeshPoly[] polys = new NavmeshPoly[header.polyCount];
tile.GetPolys(polys);
Vector3[] verts = new Vector3[header.vertCount];
tile.GetVerts(verts);
NavmeshDetailMesh[] meshes =
new NavmeshDetailMesh[header.detailMeshCount];
tile.GetDetailMeshes(meshes);
byte[] detailTris = new byte[header.detailTriCount * 4];
tile.GetDetailTris(detailTris);
Vector3[] detailVerts = new Vector3[header.detailVertCount];
tile.GetDetailVerts(detailVerts);
GL.Begin(GL.TRIANGLES);
for (int i = 0; i < header.polyCount; i++)
{
NavmeshPoly poly = polys[i];
if (poly.Type == NavmeshPolyType.OffMeshConnection)
{
continue;
}
NavmeshDetailMesh mesh = meshes[i];
Color color = GetStandardColor(polyBase | (uint)i
, poly.Area, colorId
, query, markPolys, markPolyCount);
GL.Color(color);
for (int j = 0; j < mesh.triCount; j++)
{
int pTri = (int)(mesh.triBase + j) * 4;
for (int k = 0; k < 3; k++)
{
// Note: iVert and pVert refer to different
// arrays.
int iVert = detailTris[pTri + k];
if (iVert < poly.vertCount)
{
// Get the vertex from the main vertices.
int pVert = poly.indices[iVert];
GL.Vertex(verts[pVert]);
}
else
{
// Get the vertex from the detail vertices.
int pVert = (int)
(mesh.vertBase + iVert - poly.vertCount);
GL.Vertex(detailVerts[pVert]);
}
}
}
}
GL.End();
NavmeshLink[] links = new NavmeshLink[header.maxLinkCount];
tile.GetLinks(links);
GL.Begin(GL.LINES);
DrawPolyBoundaries(header
, polys
, verts
, meshes
, detailTris
, detailVerts
, links
, new Color(0, 0.2f, 0.25f, 0.13f)
, true);
DrawPolyBoundaries(header
, polys
, verts
, meshes
, detailTris
, detailVerts
, links
, new Color(0.65f, 0.2f, 0, 0.9f)
, false);
if (header.connCount == 0)
{
GL.End();
return;
}
NavmeshConnection[] conns = new NavmeshConnection[header.connCount];
tile.GetConnections(conns);
for (int i = 0; i < header.polyCount; i++)
{
NavmeshPoly poly = polys[i];
if (poly.Type != NavmeshPolyType.OffMeshConnection)
{
continue;
}
Color color = GetStandardColor(polyBase | (uint)i
, poly.Area, colorId
, query, markPolys, markPolyCount);
// Note: Alpha of less than one doesn't look good because connections tend to
// overlay a lot of geometry, resulting is off color transitions.
color.a = 1;
GL.Color(color);
NavmeshConnection conn = conns[i - header.connBase];
Vector3 va = verts[poly.indices[0]];
Vector3 vb = verts[poly.indices[1]];
// Check to see if start and end end-points have links.
bool startSet = false;
bool endSet = false;
for (uint k = poly.firstLink; k != Navmesh.NullLink; k = links[k].next)
{
if (links[k].edge == 0)
{
startSet = true;
}
if (links[k].edge == 1)
{
endSet = true;
}
}
// For linked endpoints: Draw a line between on-mesh location and endpoint,
// and draw circle at the endpoint.
// For un-linked endpoints: Draw a small red x-marker.
if (startSet)
{
GL.Vertex(va);
GL.Vertex(conn.endpoints[0]);
DebugDraw.AppendCircle(conn.endpoints[0], conn.radius);
}
else
{
GL.Color(Color.red);
DebugDraw.AppendXMarker(conn.endpoints[0], 0.1f);
GL.Color(color);
}
if (endSet)
{
GL.Vertex(vb);
GL.Vertex(conn.endpoints[1]);
DebugDraw.AppendCircle(conn.endpoints[1], conn.radius);
}
else
{
GL.Color(Color.red);
DebugDraw.AppendXMarker(conn.endpoints[1], 0.1f);
GL.Color(color);
}
DebugDraw.AppendArc(conn.endpoints[0], conn.endpoints[1]
, 0.25f
, conn.IsBiDirectional ? 0.6f : 0
, 0.6f);
}
GL.End();
}
private bool UpdateMale()
{
if (_maleAtom == null || !_maleAtom.on)
{
return(false);
}
var penisColliders = new List <string> {
"AutoColliderGen1Hard",
"AutoColliderGen2Hard",
"AutoColliderGen3aHard",
"AutoColliderGen3bHard"
};
var penisTransforms = _maleAtom
.GetComponentsInChildren <Collider>()
.Where(c => penisColliders.Contains(c.name))
.OrderBy(c => c.name, StringComparer.OrdinalIgnoreCase)
.Select(c => c.transform)
.ToList();
if (penisTransforms.Count != 4)
{
return(false);
}
_penisLength = 0.0f;
for (int i = 0, j = 1; j < penisTransforms.Count; i = j++)
{
_penisLength += Vector3.Distance(penisTransforms[i].position, penisTransforms[j].position);
}
_penisOrigin = penisTransforms[0];
var positionOffset = -_penisOrigin.up * (penisTransforms[1].position - penisTransforms[0].position).magnitude * 0.15f;
_referencePosition = _penisOrigin.position + positionOffset;
_penisLength += positionOffset.magnitude;
_penisLength += penisTransforms[3].GetComponent <CapsuleCollider>().radius;
_penisRadius = penisTransforms[1].GetComponent <CapsuleCollider>().radius;
var pelvisRight = _maleAtom.GetComponentByName <Collider>("AutoColliderpelvisFR3Joint")?.transform;
var pelvidLeft = _maleAtom.GetComponentByName <Collider>("AutoColliderpelvisFL3Joint")?.transform;
var pelvisMid = _maleAtom.GetComponentByName <Transform>("AutoColliderpelvisF1")?.GetComponentByName <Collider>("AutoColliderpelvisF4Joint")?.transform;
if (pelvisRight == null || pelvidLeft == null || pelvisMid == null)
{
_planeNormal = _penisOrigin.up;
}
else
{
_planeNormal = Vector3.Cross(pelvisMid.position - pelvidLeft.position, pelvisMid.position - pelvisRight.position).normalized;
}
DebugDraw.DrawSquare(ReferencePosition, ReferencePlaneNormal, ReferenceRight, Color.white, 0.33f);
DebugDraw.DrawTransform(ReferencePosition, ReferenceUp, ReferenceRight, ReferenceForward, 0.15f);
DebugDraw.DrawRay(ReferencePosition, ReferenceUp, ReferenceLength, Color.white);
DebugDraw.DrawLine(ReferencePosition, TargetPosition, Color.yellow);
return(true);
}
public static void DrawFrame(SoftBody psb, DebugDraw iDraw)
{
btSoftBodyHelpers_DrawFrame(psb.Native, iDraw._native);
}
private void OnApplicationQuit( )
{
DebugDraw.DeInit( );
}
public static void Draw(SoftBody psb, DebugDraw iDraw, DrawFlags drawFlags = DrawFlags.Std)
{
btSoftBodyHelpers_Draw(psb.Native, iDraw._native, drawFlags);
}
private void Awake( )
{
DebugDraw.Init( );
}
/// <summary>
/// Controllers override this to provide debug drawing.
/// </summary>
public virtual void Draw(DebugDraw debugDraw) { }
public override void UpdateDebugDraw()
{
if (rangeDebugDraw == null)
rangeDebugDraw = DebugDraw.Create("AtkRangeDebug", Entity.gameObject, Color.yellow);
rangeDebugDraw.DrawCircle(attrComp.AtkRange);
}
public static void DrawVector(Vector3 position, Vector3 direction, float raySize, float markerSize, Color color, float duration, bool depthTest = true)
{
Debug.DrawRay(position, direction * raySize, color, 0, false);
DebugDraw.DrawMarker(position + direction * raySize, markerSize, color, 0, false);
}
public static void DrawNodeTree(SoftBody psb, DebugDraw iDraw, int minDepth = 0,
int maxDepth = -1)
{
btSoftBodyHelpers_DrawNodeTree(psb.Native, iDraw._native,
minDepth, maxDepth);
}
//\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//\
//\ DRAWING
//\
//\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
/// <summary>
/// Draw one rect for all trackable objects.
///
/// NOTE: WE LOOP THROUGH OBJECTS OF INTEREST AND DRAW A RECT AROUND ALL
///
/// </summary>
private void _doDrawOneRectForAllTrackableObjects(TrackingPriority aTrackingPriority)
{
DebugDraw.DrawRect(_getRectForAllTrackableObjects(aTrackingPriority), _zPlaneCoordinate_float, Constants.GetDebugColorByPriority(aTrackingPriority));
}
public void DrawLastGroundHit()
{
//DebugDraw.EditorDrawArrow(GetLastGroundHitPoint(), GetLastGroundNormal(), Color.red);
DebugDraw.DebugArrow(GetLastGroundHitPoint(), GetLastGroundNormal(), Color.red);
}
public static void DrawNodeTree(SoftBody psb, IDebugDraw iDraw, int minDepth = 0,
int maxDepth = -1)
{
btSoftBodyHelpers_DrawNodeTree(psb.Native, DebugDraw.GetUnmanaged(iDraw),
minDepth, maxDepth);
}
public static void Draw(SoftBody psb, IDebugDraw iDraw, int drawFlags)
{
btSoftBodyHelpers_Draw2(psb._native, DebugDraw.GetUnmanaged(iDraw), drawFlags);
}
/// <summary>
/// Draws a debug visualization of a corridor.
/// </summary>
/// <param name="mesh">The navigation mesh associated with the corridor.</param>
/// <param name="corridor">The corridor to draw.</param>
public static void Draw(Navmesh mesh, PathCorridorData corridor)
{
if (corridor.pathCount == 0)
{
return;
}
DebugDraw.SimpleMaterial.SetPass(0);
Vector3[] tileVerts = null;
for (int iPoly = 0; iPoly < corridor.pathCount; iPoly++)
{
NavmeshTile tile;
NavmeshPoly poly;
mesh.GetTileAndPoly(corridor.path[iPoly], out tile, out poly);
if (poly.Type == NavmeshPolyType.OffMeshConnection)
{
continue;
}
NavmeshTileHeader header = tile.GetHeader();
if (tileVerts == null ||
tileVerts.Length < 3 * header.vertCount)
{
// Resize.
tileVerts = new Vector3[header.vertCount];
}
tile.GetVerts(tileVerts);
GL.Begin(GL.TRIANGLES);
GL.Color(polygonOverlayColor);
int pA = poly.indices[0];
for (int i = 2; i < poly.vertCount; i++)
{
int pB = poly.indices[i - 1];
int pC = poly.indices[i];
GL.Vertex(tileVerts[pA]);
GL.Vertex(tileVerts[pB]);
GL.Vertex(tileVerts[pC]);
}
GL.End();
// Not drawing boundaries since it would obscure other agent
// debug data.
}
Vector3 v = corridor.position;
DebugDraw.XMarker(v, positionScale, positionColor);
DebugDraw.Circle(v, positionScale, positionColor);
DebugDraw.Circle(v, positionScale * 0.5f, positionColor);
DebugDraw.Circle(v, positionScale * 0.25f, positionColor);
v = corridor.target;
DebugDraw.XMarker(v, goalScale, goalColor);
DebugDraw.Circle(v, goalScale, goalColor);
DebugDraw.Circle(v, goalScale * 0.5f, goalColor);
DebugDraw.Circle(v, goalScale * 0.25f, goalColor);
}
public static void DrawClusterTree(SoftBody psb, IDebugDraw iDraw, int minDepth,
int maxDepth)
{
btSoftBodyHelpers_DrawClusterTree3(psb._native, DebugDraw.GetUnmanaged(iDraw),
minDepth, maxDepth);
}
/// <summary>
/// Check if any of the CollisionSpheres are colliding with any walkable objects in the world.
/// If they are, apply a proper pushback and retrieve the collision data
/// </summary>
void RecursivePushback(int depth, int maxDepth)
{
PushIgnoredColliders();
bool contact = false;
foreach (var sphere in spheres)
{
foreach (Collider col in Physics.OverlapSphere((SpherePosition(sphere)), radius, Walkable, triggerInteraction))
{
Vector3 position = SpherePosition(sphere);
Vector3 contactPoint;
bool contactPointSuccess = SuperCollider.ClosestPointOnSurface(col, position, radius, out contactPoint);
if (!contactPointSuccess)
{
return;
}
if (debugPushbackMesssages)
{
DebugDraw.DrawMarker(contactPoint, 2.0f, Color.cyan, 0.0f, false);
}
Vector3 v = contactPoint - position;
if (v != Vector3.zero)
{
// Cache the collider's layer so that we can cast against it
int layer = col.gameObject.layer;
col.gameObject.layer = TemporaryLayerIndex;
// Check which side of the normal we are on
bool facingNormal = Physics.SphereCast(new Ray(position, v.normalized), TinyTolerance, v.magnitude + TinyTolerance, 1 << TemporaryLayerIndex);
col.gameObject.layer = layer;
// Orient and scale our vector based on which side of the normal we are situated
if (facingNormal)
{
if (Vector3.Distance(position, contactPoint) < radius)
{
v = v.normalized * (radius - v.magnitude) * -1;
}
else
{
// A previously resolved collision has had a side effect that moved us outside this collider
continue;
}
}
else
{
v = v.normalized * (radius + v.magnitude);
}
contact = true;
transform.position += v;
col.gameObject.layer = TemporaryLayerIndex;
// Retrieve the surface normal of the collided point
RaycastHit normalHit;
Physics.SphereCast(new Ray(position + v, contactPoint - (position + v)), TinyTolerance, out normalHit, 1 << TemporaryLayerIndex);
col.gameObject.layer = layer;
SuperCollisionType superColType = col.gameObject.GetComponent <SuperCollisionType>();
if (superColType == null)
{
superColType = defaultCollisionType;
}
// Our collision affected the collider; add it to the collision data
var collision = new SuperCollision()
{
collisionSphere = sphere,
superCollisionType = superColType,
gameObject = col.gameObject,
point = contactPoint,
normal = normalHit.normal
};
collisionData.Add(collision);
}
}
}
PopIgnoredColliders();
if (depth < maxDepth && contact)
{
RecursivePushback(depth + 1, maxDepth);
}
}
public static void DrawNodeTree(SoftBody psb, IDebugDraw iDraw)
{
btSoftBodyHelpers_DrawNodeTree(psb._native, DebugDraw.GetUnmanaged(iDraw));
}
/// <summary>
/// Sets a drawing routine. Methods on the provided object are called-back to perform drawing on each update.
/// </summary>
/// <param name="debugDraw"></param>
public void SetDebugDraw(DebugDraw debugDraw)
{
_world.SetDebugDraw(debugDraw);
}
public static void DrawNodeTree(SoftBody psb, IDebugDraw iDraw, int minDepth)
{
btSoftBodyHelpers_DrawNodeTree2(psb._native, DebugDraw.GetUnmanaged(iDraw),
minDepth);
}
public bool UpdateMotion(IMotionSource motionSource)
{
var length = motionSource.ReferenceLength * ReferenceLengthScaleSlider.val;
var radius = motionSource.ReferenceRadius * ReferenceRadiusScaleSlider.val;
var referenceEnding = motionSource.ReferencePosition + motionSource.ReferenceUp * length;
var diffPosition = motionSource.TargetPosition - motionSource.ReferencePosition;
var diffEnding = motionSource.TargetPosition - referenceEnding;
var aboveTarget = (Vector3.Dot(diffPosition, motionSource.TargetUp) < 0 && Vector3.Dot(diffEnding, motionSource.TargetUp) < 0) ||
Vector3.Dot(diffPosition, motionSource.ReferenceUp) < 0;
for (var i = 0; i < 5; i++)
{
DebugDraw.DrawCircle(Vector3.Lerp(motionSource.ReferencePosition, referenceEnding, i / 4.0f), motionSource.ReferenceUp, motionSource.ReferenceRight, Color.grey, radius);
}
var t = Mathf.Clamp(Vector3.Dot(motionSource.TargetPosition - motionSource.ReferencePosition, motionSource.ReferenceUp), 0f, length);
var closestPoint = motionSource.ReferencePosition + motionSource.ReferenceUp * t;
if (Vector3.Magnitude(closestPoint - motionSource.TargetPosition) <= radius)
{
if (diffPosition.magnitude > 0.0001f)
{
XTarget[0] = 1 - Mathf.Clamp01((closestPoint - motionSource.ReferencePosition).magnitude / length);
if (aboveTarget)
{
XTarget[0] = XTarget[0] > 0 ? 1 : 0;
}
var diffOnPlane = Vector3.ProjectOnPlane(diffPosition, motionSource.ReferencePlaneNormal);
var rightOffset = Vector3.Project(diffOnPlane, motionSource.ReferenceRight);
var forwardOffset = Vector3.Project(diffOnPlane, motionSource.ReferenceForward);
XTarget[1] = forwardOffset.magnitude * Mathf.Sign(Vector3.Dot(forwardOffset, motionSource.ReferenceForward));
XTarget[2] = rightOffset.magnitude * Mathf.Sign(Vector3.Dot(rightOffset, motionSource.ReferenceRight));
}
else
{
XTarget[0] = 1;
XTarget[1] = 0;
XTarget[2] = 0;
}
var correctedRight = Vector3.ProjectOnPlane(motionSource.TargetRight, motionSource.ReferenceUp);
if (Vector3.Dot(correctedRight, motionSource.ReferenceRight) < 0)
{
correctedRight -= 2 * Vector3.Project(correctedRight, motionSource.ReferenceRight);
}
RTarget[0] = Vector3.SignedAngle(motionSource.ReferenceRight, correctedRight, motionSource.ReferenceUp) / 180;
RTarget[1] = -Vector3.SignedAngle(motionSource.ReferenceUp, Vector3.ProjectOnPlane(motionSource.TargetUp, motionSource.ReferenceForward), motionSource.ReferenceForward) / 90;
RTarget[2] = Vector3.SignedAngle(motionSource.ReferenceUp, Vector3.ProjectOnPlane(motionSource.TargetUp, motionSource.ReferenceRight), motionSource.ReferenceRight) / 90;
ETarget[0] = OutputV0CurveEditorSettings.Evaluate(XTarget, RTarget);
ETarget[1] = OutputA0CurveEditorSettings.Evaluate(XTarget, RTarget);
ETarget[2] = OutputA1CurveEditorSettings.Evaluate(XTarget, RTarget);
ETarget[3] = OutputA2CurveEditorSettings.Evaluate(XTarget, RTarget);
if (_lastNoCollisionTime != null)
{
_lastNoCollisionSmoothingEnabled = true;
_lastNoCollisionSmoothingStartTime = Time.time;
_lastNoCollisionSmoothingDuration = Mathf.Clamp(Time.time - _lastNoCollisionTime.Value, 0.5f, 2);
_lastNoCollisionTime = null;
}
return(true);
}
else
{
if (_lastNoCollisionTime == null)
{
_lastNoCollisionTime = Time.time;
}
return(false);
}
}
public Vector3 GetClosestPositionOnX(Vector3 pos)
{
float closestDistance = float.MaxValue;
Vector3 point = Vector3.zero;
Vector3 secondPoint = Vector3.zero;
for (int i = 0; i < curvePoints.Count; i++)
{
float currentDistance = Mathf.Abs(pos.x - curvePoints[i].x);
if (currentDistance < closestDistance)
{
closestDistance = currentDistance;
point = curvePoints[i];
if (point.x < pos.x)
{
if (i + 1 >= curvePoints.Count)
{
secondPoint = curvePoints[curvePoints.Count - 1];
}
else
{
secondPoint = curvePoints[i + 1];
}
}
else
{
if (i - 1 <= 0)
{
secondPoint = points[0].transform.position;
}
else
{
secondPoint = curvePoints[i - 1];
}
}
}
}
Vector3 dir;
Vector3 targetPos;
float cameraPos;
if (point.x > secondPoint.x)
{
// close point ahead
dir = point - secondPoint;
cameraPos = Converter.Remap(pos.x, secondPoint.x, point.x, 0, 1, true);
targetPos = secondPoint + (dir * cameraPos);
}
else
{
// close point behinde
dir = secondPoint - point;
cameraPos = Converter.Remap(pos.x, point.x, secondPoint.x, 0, 1, true);
targetPos = point + (dir * cameraPos);
}
DebugDraw.DrawMarker(targetPos, 3f, Color.black, Time.fixedDeltaTime);
//DebugDraw.DrawMarker(pos, 55f, Color.white, Time.fixedDeltaTime);
//DebugDraw.DrawMarker(point, 2f, Color.red, Time.fixedDeltaTime);
//DebugDraw.DrawMarker(secondPoint, 2f, Color.green, Time.fixedDeltaTime);
return(targetPos);
}
void RecursivePartition(List <int> triangles, int depth, Node parent)
{
Vector3 partitionPoint = Vector3.zero;
Vector3 maxExtents = new Vector3(-float.MaxValue, -float.MaxValue, -float.MaxValue);
Vector3 minExtents = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
foreach (int triangle in triangles)
{
partitionPoint += vertices[tris[triangle]] + vertices[tris[triangle + 1]] + vertices[tris[triangle + 2]];
minExtents.x = Mathf.Min(minExtents.x, vertices[tris[triangle]].x, vertices[tris[triangle + 1]].x, vertices[tris[triangle + 2]].x);
minExtents.y = Mathf.Min(minExtents.y, vertices[tris[triangle]].y, vertices[tris[triangle + 1]].y, vertices[tris[triangle + 2]].y);
minExtents.z = Mathf.Min(minExtents.z, vertices[tris[triangle]].z, vertices[tris[triangle + 1]].z, vertices[tris[triangle + 2]].z);
maxExtents.x = Mathf.Max(maxExtents.x, vertices[tris[triangle]].x, vertices[tris[triangle + 1]].x, vertices[tris[triangle + 2]].x);
maxExtents.y = Mathf.Max(maxExtents.y, vertices[tris[triangle]].y, vertices[tris[triangle + 1]].y, vertices[tris[triangle + 2]].y);
maxExtents.z = Mathf.Max(maxExtents.z, vertices[tris[triangle]].z, vertices[tris[triangle + 1]].z, vertices[tris[triangle + 2]].z);
}
// Centroid of all vertices
partitionPoint /= vertexCount;
// Better idea? Center of bounding box
partitionPoint = minExtents + Math3d.SetVectorLength((maxExtents - minExtents), (maxExtents - minExtents).magnitude * 0.5f);
Vector3 extentsMagnitude = new Vector3(Mathf.Abs(maxExtents.x - minExtents.x), Mathf.Abs(maxExtents.y - minExtents.y), Mathf.Abs(maxExtents.z - minExtents.z));
Vector3 partitionNormal;
if (extentsMagnitude.x >= extentsMagnitude.y && extentsMagnitude.x >= extentsMagnitude.z)
{
partitionNormal = Vector3.right;
}
else if (extentsMagnitude.y >= extentsMagnitude.x && extentsMagnitude.y >= extentsMagnitude.z)
{
partitionNormal = Vector3.up;
}
else
{
partitionNormal = Vector3.forward;
}
List <int> positiveTriangles;
List <int> negativeTriangles;
Split(triangles, partitionPoint, partitionNormal, out positiveTriangles, out negativeTriangles);
parent.partitionNormal = partitionNormal;
parent.partitionPoint = partitionPoint;
Node posNode = new Node();
parent.positiveChild = posNode;
Node negNode = new Node();
parent.negativeChild = negNode;
if (positiveTriangles.Count < triangles.Count && positiveTriangles.Count > 3)
{
RecursivePartition(positiveTriangles, depth + 1, posNode);
}
else
{
posNode.triangles = positiveTriangles.ToArray();
if (drawMeshTreeOnStart)
{
DrawTriangleSet(posNode.triangles, DebugDraw.RandomColor());
}
}
if (negativeTriangles.Count < triangles.Count && negativeTriangles.Count > 3)
{
RecursivePartition(negativeTriangles, depth + 1, negNode);
}
else
{
negNode.triangles = negativeTriangles.ToArray();
if (drawMeshTreeOnStart)
{
DrawTriangleSet(negNode.triangles, DebugDraw.RandomColor());
}
}
}
public static void Draw(SoftBody psb, IDebugDraw iDraw, DrawFlags drawFlags = DrawFlags.Std)
{
btSoftBodyHelpers_Draw(psb.Native, DebugDraw.GetUnmanaged(iDraw), drawFlags);
}
/// <summary>
/// Initializes a new instance of the <see cref="PrefabWindowViewport"/> class.
/// </summary>
/// <param name="window">Editor window.</param>
public PrefabWindowViewport(PrefabWindow window)
: base(true)
{
_window = window;
_window.SelectionChanged += OnSelectionChanged;
Undo = window.Undo;
ViewportCamera = new FPSCamera();
_debugDrawContext = DebugDraw.AllocateContext();
// Prepare rendering task
Task.ActorsSource = ActorsSources.CustomActors;
Task.ViewFlags = ViewFlags.DefaultEditor;
Task.Begin += OnBegin;
Task.CollectDrawCalls += OnCollectDrawCalls;
Task.PostRender += OnPostRender;
// Create post effects
SelectionOutline = FlaxEngine.Object.New <SelectionOutline>();
SelectionOutline.SelectionGetter = () => TransformGizmo.SelectedParents;
Task.CustomPostFx.Add(SelectionOutline);
EditorPrimitives = FlaxEngine.Object.New <EditorPrimitives>();
EditorPrimitives.Viewport = this;
Task.CustomPostFx.Add(EditorPrimitives);
_spritesRenderer = FlaxEngine.Object.New <PrefabSpritesRenderer>();
_spritesRenderer.Task = Task;
_spritesRenderer.Viewport = this;
Task.CustomPostFx.Add(_spritesRenderer);
// Add transformation gizmo
TransformGizmo = new TransformGizmo(this);
TransformGizmo.ApplyTransformation += ApplyTransform;
TransformGizmo.ModeChanged += OnGizmoModeChanged;
TransformGizmo.Duplicate += _window.Duplicate;
Gizmos.Active = TransformGizmo;
// Transform space widget
var transformSpaceWidget = new ViewportWidgetsContainer(ViewportWidgetLocation.UpperRight);
var transformSpaceToggle = new ViewportWidgetButton(string.Empty, window.Editor.Icons.World16, null, true)
{
Checked = TransformGizmo.ActiveTransformSpace == TransformGizmoBase.TransformSpace.World,
TooltipText = "Gizmo transform space (world or local)",
Parent = transformSpaceWidget
};
transformSpaceToggle.Toggled += OnTransformSpaceToggle;
transformSpaceWidget.Parent = this;
// Scale snapping widget
var scaleSnappingWidget = new ViewportWidgetsContainer(ViewportWidgetLocation.UpperRight);
var enableScaleSnapping = new ViewportWidgetButton(string.Empty, window.Editor.Icons.ScaleStep16, null, true)
{
Checked = TransformGizmo.ScaleSnapEnabled,
TooltipText = "Enable scale snapping",
Parent = scaleSnappingWidget
};
enableScaleSnapping.Toggled += OnScaleSnappingToggle;
var scaleSnappingCM = new ContextMenu();
_scaleSnapping = new ViewportWidgetButton(TransformGizmo.ScaleSnapValue.ToString(), SpriteHandle.Invalid, scaleSnappingCM)
{
TooltipText = "Scale snapping values"
};
for (int i = 0; i < EditorViewportScaleSnapValues.Length; i++)
{
var v = EditorViewportScaleSnapValues[i];
var button = scaleSnappingCM.AddButton(v.ToString());
button.Tag = v;
}
scaleSnappingCM.ButtonClicked += OnWidgetScaleSnapClick;
scaleSnappingCM.VisibleChanged += OnWidgetScaleSnapShowHide;
_scaleSnapping.Parent = scaleSnappingWidget;
scaleSnappingWidget.Parent = this;
// Rotation snapping widget
var rotateSnappingWidget = new ViewportWidgetsContainer(ViewportWidgetLocation.UpperRight);
var enableRotateSnapping = new ViewportWidgetButton(string.Empty, window.Editor.Icons.RotateStep16, null, true)
{
Checked = TransformGizmo.RotationSnapEnabled,
TooltipText = "Enable rotation snapping",
Parent = rotateSnappingWidget
};
enableRotateSnapping.Toggled += OnRotateSnappingToggle;
var rotateSnappingCM = new ContextMenu();
_rotateSnapping = new ViewportWidgetButton(TransformGizmo.RotationSnapValue.ToString(), SpriteHandle.Invalid, rotateSnappingCM)
{
TooltipText = "Rotation snapping values"
};
for (int i = 0; i < EditorViewportRotateSnapValues.Length; i++)
{
var v = EditorViewportRotateSnapValues[i];
var button = rotateSnappingCM.AddButton(v.ToString());
button.Tag = v;
}
rotateSnappingCM.ButtonClicked += OnWidgetRotateSnapClick;
rotateSnappingCM.VisibleChanged += OnWidgetRotateSnapShowHide;
_rotateSnapping.Parent = rotateSnappingWidget;
rotateSnappingWidget.Parent = this;
// Translation snapping widget
var translateSnappingWidget = new ViewportWidgetsContainer(ViewportWidgetLocation.UpperRight);
var enableTranslateSnapping = new ViewportWidgetButton(string.Empty, window.Editor.Icons.Grid16, null, true)
{
Checked = TransformGizmo.TranslationSnapEnable,
TooltipText = "Enable position snapping",
Parent = translateSnappingWidget
};
enableTranslateSnapping.Toggled += OnTranslateSnappingToggle;
var translateSnappingCM = new ContextMenu();
_translateSnappng = new ViewportWidgetButton(TransformGizmo.TranslationSnapValue.ToString(), SpriteHandle.Invalid, translateSnappingCM)
{
TooltipText = "Position snapping values"
};
for (int i = 0; i < EditorViewportTranslateSnapValues.Length; i++)
{
var v = EditorViewportTranslateSnapValues[i];
var button = translateSnappingCM.AddButton(v.ToString());
button.Tag = v;
}
translateSnappingCM.ButtonClicked += OnWidgetTranslateSnapClick;
translateSnappingCM.VisibleChanged += OnWidgetTranslateSnapShowHide;
_translateSnappng.Parent = translateSnappingWidget;
translateSnappingWidget.Parent = this;
// Gizmo mode widget
var gizmoMode = new ViewportWidgetsContainer(ViewportWidgetLocation.UpperRight);
_gizmoModeTranslate = new ViewportWidgetButton(string.Empty, window.Editor.Icons.Translate16, null, true)
{
Tag = TransformGizmoBase.Mode.Translate,
TooltipText = "Translate gizmo mode",
Checked = true,
Parent = gizmoMode
};
_gizmoModeTranslate.Toggled += OnGizmoModeToggle;
_gizmoModeRotate = new ViewportWidgetButton(string.Empty, window.Editor.Icons.Rotate16, null, true)
{
Tag = TransformGizmoBase.Mode.Rotate,
TooltipText = "Rotate gizmo mode",
Parent = gizmoMode
};
_gizmoModeRotate.Toggled += OnGizmoModeToggle;
_gizmoModeScale = new ViewportWidgetButton(string.Empty, window.Editor.Icons.Scale16, null, true)
{
Tag = TransformGizmoBase.Mode.Scale,
TooltipText = "Scale gizmo mode",
Parent = gizmoMode
};
_gizmoModeScale.Toggled += OnGizmoModeToggle;
gizmoMode.Parent = this;
_dragHandlers.Add(_dragActorType);
_dragHandlers.Add(_dragAssets);
// Setup input actions
InputActions.Add(options => options.TranslateMode, () => TransformGizmo.ActiveMode = TransformGizmoBase.Mode.Translate);
InputActions.Add(options => options.RotateMode, () => TransformGizmo.ActiveMode = TransformGizmoBase.Mode.Rotate);
InputActions.Add(options => options.ScaleMode, () => TransformGizmo.ActiveMode = TransformGizmoBase.Mode.Scale);
InputActions.Add(options => options.FocusSelection, ShowSelectedActors);
SetUpdate(ref _update, OnUpdate);
}
public static void DrawFrame(SoftBody psb, IDebugDraw iDraw)
{
btSoftBodyHelpers_DrawFrame(psb.Native, DebugDraw.GetUnmanaged(iDraw));
}
static void DrawLineBetweenDataPoints(DataPoint data1, DataPoint data2, Color color)
{
//Gizmos.color = color;
//Gizmos.DrawLine(data1.LocalPosition, data2.LocalPosition);
DebugDraw.DrawLine(data1.LocalPosition, data2.LocalPosition, color);
}
public static void DrawInfos(SoftBody psb, IDebugDraw iDraw, bool masses,
bool areas, bool stress)
{
btSoftBodyHelpers_DrawInfos(psb.Native, DebugDraw.GetUnmanaged(iDraw),
masses, areas, stress);
}
/// <summary>
/// Draw center point crosshairs for rect of all trackable objects.
/// </summary>
private void _doDrawCenterPointCrosshairsForRectOfAllTrackableObjects(TrackingPriority aTrackingPriority)
{
DebugDraw.DrawCenterPointCrosshairsForRect(_getRectForAllTrackableObjects(aTrackingPriority), _zPlaneCoordinate_float, Constants.GetDebugColorByPriority(aTrackingPriority));
}
void Start()
{
GameObject debugDrawGo = new GameObject("DebugDraw");
debugDraw = debugDrawGo.AddComponent<DebugDraw>();
ResourceManager.Init();
SettingManager.Init(StartTest);
}
