public static bool TargetHasNotChanged(GeometryDataModels.Target newTarget,
GeometryDataModels.Target currentTarget)
{
return(newTarget.GeoInfoHashCode == currentTarget.GeoInfoHashCode &&
newTarget.entity.Index == currentTarget.entity.Index &&
newTarget.entity.Version == currentTarget.entity.Version);
}
// Update is called once per frame
void Update()
{
closestTarget = geoVision.GetClosestTarget();
if (currentTarget.distanceToCastOrigin == 0)
{
Destroy(this.gameObject);
}
else if (GeometryVisionUtilities.TargetHasNotChanged(closestTarget, currentTarget))
{
targetingSystemPosition = geoVision.transform.position;
PlayParticleSystemAtTarget();
positions = ElectrifyPoints(targetingSystemPosition, frequency, currentTarget.position,
currentTarget.distanceToCastOrigin);
lineRenderer.positionCount = positions.Length;
lineRenderer.SetPositions(positions);
}
else
{
Destroy(this.gameObject);
}
void PlayParticleSystemAtTarget()
{
if (targetParticlesEffect)
{
targetParticlesEffect.Play(true);
targetParticlesEffect.transform.position = currentTarget.position;
}
}
}
private List <GeometryDataModels.Target> GetProjectionDataForTargets(Vector3 rayLocation, Vector3 rayDirectionWS,
List <GeometryDataModels.GeoInfo> GeoInfos, List <GeometryDataModels.Target> targetInfos)
{
GeometryDataModels.Target targetInfo = new GeometryDataModels.Target();
foreach (var geoInfoAsTarget in GeoInfos)
{
targetInfos = GetDataForTarget();
List <GeometryDataModels.Target> GetDataForTarget()
{
Vector3 point = geoInfoAsTarget.transform.position;
Vector3 rayDirectionEndPoint = rayDirectionWS;
point = pointToRaySpace(rayLocation, point);
rayDirectionEndPoint = pointToRaySpace(rayLocation, rayDirectionWS);
targetInfo.projectedTargetPosition = Vector3.Project(point, rayDirectionEndPoint) + rayLocation;
targetInfo.position = pointFromRaySpaceToObjectSpace(point, rayLocation);
targetInfo.distanceToRay =
Vector3.Distance(targetInfo.position, targetInfo.projectedTargetPosition);
targetInfo.distanceToCastOrigin = Vector3.Distance(rayLocation, targetInfo.projectedTargetPosition);
targetInfo.GeoInfoHashCode = geoInfoAsTarget.GetHashCode();
targetInfos.Add(targetInfo);
return(targetInfos);
}
}
return(targetInfos);
}
public IEnumerator PerformanceOfUpdateVisibilityForGameObjects(
[ValueSource(typeof(TestUtilities), nameof(TestUtilities.GetStressTestsScenePathsForGameObjects))]
string scenePath)
{
TestUtilities.SetupScene(scenePath);
for (int i = 0; i < 50; i++)
{
yield return(null);
}
factorySettings.processGameObjects = true;
var geoVision =
TestUtilities.SetupGeoVision(new Vector3(0f, 0f, -6f), new GeometryVisionFactory(factorySettings));
yield return(null);
var target = new GeometryDataModels.Target();
Measure.Method(() =>
{
geoVision.GetComponent <GeometryVision>().GetEye <GeometryVisionEye>().UpdateVisibility(false);
}).Run();
target = geoVision.GetComponent <GeometryVision>().GetClosestTarget();
Assert.True(target.distanceToCastOrigin != 0f);
}
internal static IEnumerator MoveEntityTarget(Vector3 newPosition,
float speedMultiplier, GeometryDataModels.Target target, float distanceToStop,
TransformEntitySystem transformEntitySystem, World entityWorld,
NativeList <GeometryDataModels.Target> closestTargets)
{
if (transformEntitySystem == null)
{
transformEntitySystem = entityWorld.CreateSystem <TransformEntitySystem>();
}
float timeOut = 2f;
while (Vector3.Distance(target.position, newPosition) > distanceToStop)
{
var animatedPoint =
transformEntitySystem.MoveEntityToPosition(newPosition, target, speedMultiplier);
target.position = animatedPoint;
if (closestTargets.Length != 0)
{
closestTargets[0] = target;
}
if (timeOut < 0.1f)
{
break;
}
timeOut -= Time.deltaTime;
yield return(null);
}
}
public void Execute(int index)
{
GeometryDataModels.Target target = targets[index];
target.position = translations[index].Value;
target.isEntity = true;
target.entity = entities[index];
targets[index] = target;
}
public void Execute()
{
tempJobTarget = target[0];
tempJobTarget.position = Vector3.MoveTowards(tempJobTarget.position, newPosition, moveSpeed);
target[0] = tempJobTarget;
var trans = translation[0];
trans.Value = tempJobTarget.position;
translation[0] = trans;
}
// Start is called before the first frame update
void Start()
{
GetGeometricVisionFromParentAndUnParent();
currentTarget = geoVision.GetClosestTarget();
lineRenderer = GetComponent <LineRenderer>();
void GetGeometricVisionFromParentAndUnParent()
{
if (transform.parent != null)
{
geoVision = transform.parent.GetComponent <GeometryVision>();
}
transform.parent = null;
}
}
List <GeometryDataModels.Target> IGeoTargeting.GetTargets(Vector3 rayLocation, Vector3 rayDirectionWS,
GeometryVision geoVision, TargetingInstruction targetingInstruction)
{
GeometryDataModels.Target targetInfo = new GeometryDataModels.Target();
List <GeometryDataModels.Target> gameObjectTargets = new List <GeometryDataModels.Target>();
if (targetingInstruction.TargetTag.Length > 0)
{
foreach (var geoInfoAsTarget in geoVision.GetEye <GeometryVisionEye>().SeenGeoInfos)
{
if (geoInfoAsTarget.gameObject.CompareTag(targetingInstruction.TargetTag))
{
gameObjectTargets.Add(GetDataForTarget(geoInfoAsTarget));
}
}
}
else
{
foreach (var geoInfoAsTarget in geoVision.GetEye <GeometryVisionEye>().SeenGeoInfos)
{
gameObjectTargets.Add(GetDataForTarget(geoInfoAsTarget));
}
}
return(gameObjectTargets);
//Local functions
GeometryDataModels.Target GetDataForTarget(GeometryDataModels.GeoInfo geoInfoAsTarget)
{
float3 point = geoInfoAsTarget.transform.position;
float3 rayDirectionEndPoint = rayDirectionWS;
point = pointToRaySpace(rayLocation, point);
rayDirectionEndPoint = pointToRaySpace(rayLocation, rayDirectionWS);
targetInfo.projectedTargetPosition = Vector3.Project(point, rayDirectionEndPoint) + rayLocation;
targetInfo.position = pointFromRaySpaceToObjectSpace(point, rayLocation);
targetInfo.distanceToRay =
Vector3.Distance(targetInfo.position, targetInfo.projectedTargetPosition);
targetInfo.distanceToCastOrigin =
Vector3.Distance(rayLocation, targetInfo.projectedTargetPosition);
targetInfo.GeoInfoHashCode = geoInfoAsTarget.GetHashCode();
return(targetInfo);
}
}
public Vector3 MoveEntityToPosition(Vector3 newPosition, GeometryDataModels.Target closestTarget, float speed)
{
this.speedMultiplier = speed;
this.newPosition = newPosition;
this.target = new NativeArray <GeometryDataModels.Target>(1, Allocator.TempJob);
this.entityToMove = new NativeArray <Entity>(1, Allocator.TempJob);
this.entityToMove[0] = closestTarget.entity;
this.target[0] = closestTarget;
this.Update();
var toReturn = this.target[0].position;
closestTarget = target[0];
target.Dispose();
entityToMove.Dispose();
return(toReturn);
}
// Update is called once per frame
void Update()
{
closestTarget = geoVision.GetClosestTarget();
if (closestTarget.distanceToCastOrigin < 0.56f)
{
Destroy(this);
}
var shape = particleSystem.shape;
shape.length = closestTarget.distanceToCastOrigin;
cachedTransform.LookAt(closestTarget.position);
if (lockPositionToParent)
{
cachedTransform.position = geoVision.transform.position;
}
}
public void DestroyTargetEntity(GeometryDataModels.Target target1)
{
ecb = endSimulationEcbSystem.CreateCommandBuffer();
if (World.EntityManager.Exists(target1.entity))
{
if (World.EntityManager.HasComponent <Child>(target1.entity))
{
DynamicBuffer <Child> childs = World.EntityManager.GetBuffer <Child>(target1.entity);
foreach (var child in childs)
{
ecb.DestroyEntity(child.Value);
}
}
ecb.DestroyEntity(target1.entity);
}
}
public void Execute(int i)
{
GeometryDataModels.Target target = targets[i];
Vector3 targetLocation = target.position;
Vector3 rayDirection = rayDirWS;
Vector3 rayDirectionEndPoint = rayDirWS;
targetLocation = pointToRaySpace(rayLocWS, targetLocation);
rayDirectionEndPoint = pointToRaySpace(rayLocWS, rayDirection);
Vector3 pointToRaySpace(Vector3 rayLocation, Vector3 point)
{
return(point - rayLocation);
}
target.projectedTargetPosition = Project(targetLocation, rayDirectionEndPoint) + rayLocWS;
Vector3 Project(Vector3 vector, Vector3 onNormal)
{
float num1 = Vector3.Dot(onNormal, onNormal);
if (num1 < float.Epsilon)
{
return(Vector3.zero);
}
float num2 = Vector3.Dot(vector, onNormal);
return(new Vector3(onNormal.x * num2 / num1, onNormal.y * num2 / num1,
onNormal.z * num2 / num1));
}
target.position = pointFromRaySpaceToObjectSpace(targetLocation, rayLocWS);
Vector3 pointFromRaySpaceToObjectSpace(Vector3 rayLocation, Vector3 target3)
{
return(target3 + rayLocation);
}
target.isEntity = true;
target.distanceToRay = Vector3.Distance(target.position, target.projectedTargetPosition);
target.distanceToCastOrigin = Vector3.Distance(rayLocWS, target.projectedTargetPosition);
targets[i] = target;
}
public IEnumerator TargetingSystemGetsTarget([ValueSource(typeof(TestUtilities), nameof(TestUtilities.GetSimpleTestScenePathsForGameObjects))] string scenePath)
{
TestUtilities.SetupScene(scenePath);
for (int i = 0; i < 50; i++)
{
yield return(null);
}
factorySettings.defaultTag = "";
var geoVision = TestUtilities.SetupGeoVision(new Vector3(0f, 0f, -6f), new GeometryVisionFactory(factorySettings));
yield return(null);
GeometryDataModels.Target target = new GeometryDataModels.Target();
Measure.Method(() => { target = geoVision.GetComponent <GeometryVision>().GetClosestTarget(); }).Run();
Assert.True(target.isEntity == false);
Assert.True(target.distanceToCastOrigin > 0);
}
// Update is called once per frame
void Update()
{
closestTarget = geoVision.GetClosestTarget();
if (closestTarget.distanceToCastOrigin == 0)
{
Destroy(this.gameObject);
}
if (closestTarget.distanceToCastOrigin > 0)
{
if (lockPositionToTarget)
{
cachedTransform.position = closestTarget.position;
}
if (rotateTowardsCamera)
{
transform.LookAt(geoVision.transform.position);
}
}
}
public IEnumerator EntityFilteringByComponentWorks([ValueSource(typeof(TestUtilities), nameof(TestUtilities.GetTargetingTestScenePathsForEntities))] string scenePath)
{
TestUtilities.SetupScene(scenePath);
for (int i = 0; i < 50; i++)
{
yield return(null);
}
string pathToEntityFilterScript = "Assets/Plugins/GeometricVision/EntityScripts/FromUnity/RotationSpeed_SpawnAndRemove.cs";
UnityEngine.Object entityFilterScript = AssetDatabase.LoadAssetAtPath(pathToEntityFilterScript, typeof(UnityEngine.Object));
factorySettings.entityComponentQueryFilter = entityFilterScript;
var geoVision =
TestUtilities.SetupGeoVision(new Vector3(0f, 0f, -6f), new GeometryVisionFactory(factorySettings));
yield return(null);
factorySettings.entityComponentQueryFilter = null;
float offset = 0.1f;
GeometryDataModels.Target target = new GeometryDataModels.Target();
int amountOfItemsFound = 0;
int amountOfExpectedItemsToBeFound = 1;
for (var index = 0; index < testObjectNames.Length; index++)
{
geoVision.transform.position = new Vector3(index * -2f + offset, 0f, -6f);
yield return(null);
Measure.Method(() => { target = geoVision.GetComponent <GeometryVision>().GetClosestTarget(); })
.Run();
if (Vector3.Distance(target.position, new Vector3(index * -2f, 0f, 10f)) < 0.1f + offset)
{
amountOfItemsFound += 1;
Assert.True(target.isEntity == true);
Assert.True(target.distanceToCastOrigin > 0);
}
}
Assert.True(amountOfItemsFound == amountOfExpectedItemsToBeFound);
}
public IEnumerator TargetingSystemGetsClosestTarget(
[ValueSource(typeof(TestUtilities), nameof(TestUtilities.GetTargetingTestScenePathsForEntities))]
string scenePath)
{
TestUtilities.SetupScene(scenePath);
for (int i = 0; i < 50; i++)
{
yield return(null);
}
factorySettings.entityComponentQueryFilter = null;
var geoVision =
TestUtilities.SetupGeoVision(new Vector3(0f, 0f, -6f), new GeometryVisionFactory(factorySettings));
yield return(null);
yield return(null);
float offset = 0.1f;
GeometryDataModels.Target target = new GeometryDataModels.Target();
//Go through every test object
for (var index = 0; index < testObjectNames.Length; index++)
{
geoVision.transform.position = new Vector3(index * -2f + offset, 0f, -6f);
yield return(null);
Measure.Method(() => { target = geoVision.GetComponent <GeometryVision>().GetClosestTarget(); })
.Run();
Assert.True(Vector3.Distance(target.position, new Vector3(index * -2f, 0f, 10f)) < 0.1f + offset);
}
Assert.True(target.isEntity);
Assert.True(target.distanceToCastOrigin > 0);
}
public void Execute(int index)
{
GeometryDataModels.Target target = targets[index];
target.isSeen = IsInsideFrustum(target.position, planes);
targets[index] = target;
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var renderer = GetComponent <Renderer>();
Mesh mesh;
if (UseColliderMeshInsteadOfRendererMesh)
{
mesh = GetComponent <MeshCollider>().sharedMesh;
}
else
{
mesh = GetComponent <MeshFilter>().mesh;
}
GeometryDataModels.Edge[] edges = new GeometryDataModels.Edge[1];
dstManager.AddBuffer <GeometryDataModelsEntities.EdgesBuffer>(entity);
dstManager.AddBuffer <GeometryDataModelsEntities.VerticesBuffer>(entity);
dstManager.AddBuffer <GeometryDataModelsEntities.TrianglesBuffer>(entity);
DynamicBuffer <GeometryDataModelsEntities.EdgesBuffer> eBuffer = dstManager.GetBuffer <GeometryDataModelsEntities.EdgesBuffer>(entity);
DynamicBuffer <GeometryDataModelsEntities.VerticesBuffer> vBuffer = dstManager.GetBuffer <GeometryDataModelsEntities.VerticesBuffer>(entity);
DynamicBuffer <GeometryDataModelsEntities.TrianglesBuffer> tBuffer = dstManager.GetBuffer <GeometryDataModelsEntities.TrianglesBuffer>(entity);
//Reinterpret to plain int buffer
DynamicBuffer <GeometryDataModels.Edge> edgesBuffer = eBuffer.Reinterpret <GeometryDataModels.Edge>();
DynamicBuffer <Vector3> vector3Buffer = vBuffer.Reinterpret <Vector3>();
DynamicBuffer <int> triangleBuffer = tBuffer.Reinterpret <int>();
//populate the dynamic buffer
for (int j = 0; j < mesh.vertexCount; j++)
{
vector3Buffer.Add(mesh.vertices[j]);
}
for (int j = 0; j < mesh.triangles.Length; j++)
{
triangleBuffer.Add(mesh.triangles[j]);
}
dstManager.AddComponentData(entity, new GeometryDataModelsEntities.LocalToWorldMatrix
{
Matrix = renderer.localToWorldMatrix,
});
dstManager.AddComponentData(entity, new GeometryDataModelsEntities.Visible
{
IsVisible = true,
});
var geoInfoData = new GeometryDataModelsEntities.GeoInfoEntityComponent
{
Edges = edgesBuffer,
Vertices = vector3Buffer,
Triangles = triangleBuffer,
Matrix = renderer.localToWorldMatrix,
};
dstManager.AddComponentData(entity, geoInfoData);
var targetData = new GeometryDataModels.Target
{
position = transform.position,
projectedTargetPosition = Vector3.zero,
distanceToRay = 0,
distanceToCastOrigin = 0,
entity = entity
};
dstManager.AddComponentData(entity, targetData);
}
