/// <summary>
/// If no "Node" instance, this method tries to create one
/// given the Collide.Shape component in this game object.
/// </summary>
/// <returns>True if the node was created - otherwise false.</returns>
private bool TryInitialize(Shape shape, DebugRenderManager manager)
{
if (Node != null)
{
return(false);
}
Collide.Mesh mesh = shape as Collide.Mesh;
HeightField heightField = shape as HeightField;
if (mesh != null)
{
Node = InitializeMesh(mesh);
}
else if (heightField != null)
{
Node = InitializeHeightField(heightField);
}
else
{
Node = PrefabLoader.Instantiate <GameObject>(PrefabName);
Node.transform.localScale = GetShape().GetScale();
}
if (Node != null)
{
var renderers = Node.GetComponentsInChildren <Renderer>();
foreach (var renderer in renderers)
{
renderer.sharedMaterial = manager.ShapeRenderMaterial;
}
}
return(Node != null);
}
/// <summary>
/// Create visual game object and adds it as child to shape game object.
/// </summary>
/// <param name="shape">Shape instance.</param>
/// <param name="isRenderData">If true we wont try to load predefined mesh from resources.</param>
/// <returns>Visual game object if successful - otherwise null.</returns>
protected static GameObject CreateGameObject(Collide.Shape shape, bool isRenderData)
{
GameObject go = null;
try {
go = isRenderData || shape is Collide.Mesh || shape is Collide.HollowCylinder || shape is Collide.Cone || shape is Collide.HollowCone ?
new GameObject("") :
PrefabLoader.Instantiate <GameObject>(@"Debug/" + shape.GetType().Name + "Renderer");
if (go == null)
{
Debug.LogWarning("Unable to find shape visual resource: " + @"Debug/" + shape.GetType().Name + "Renderer", shape);
return(null);
}
go.name = shape.name + "_Visual";
go.transform.hideFlags = HideFlags.NotEditable;
shape.gameObject.AddChild(go);
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
}
catch (System.Exception e) {
Debug.LogException(e);
if (go != null)
{
GameObject.DestroyImmediate(go);
}
}
return(go);
}
/// <summary>
/// If no "Node" instance, this method tries to create one
/// given the Collide.Shape component in this game object.
/// </summary>
/// <returns>True if the node was created - otherwise false.</returns>
private bool TryInitialize(Shape shape, DebugRenderManager manager)
{
if (Node != null)
{
return(false);
}
Collide.Mesh mesh = shape as Collide.Mesh;
HeightField heightField = shape as HeightField;
Cone cone = shape as Cone;
HollowCone hollowCone = shape as HollowCone;
HollowCylinder hollowCylinder = shape as HollowCylinder;
if (mesh != null)
{
Node = InitializeMesh(mesh);
}
else if (heightField != null)
{
Node = InitializeHeightField(heightField);
}
else if (hollowCone != null)
{
Node = new GameObject(PrefabName);
Node.AddComponent <MeshRenderer>().sharedMaterial = manager.ShapeRenderMaterial;
Node.AddComponent <MeshFilter>().sharedMesh = ShapeVisualHollowCone.GenerateMesh(shape);
}
else if (hollowCylinder != null)
{
Node = new GameObject(PrefabName);
Node.AddComponent <MeshRenderer>().sharedMaterial = manager.ShapeRenderMaterial;
Node.AddComponent <MeshFilter>().sharedMesh = ShapeVisualHollowCylinder.GenerateMesh(shape);
}
else if (cone != null)
{
Node = new GameObject(PrefabName);
Node.AddComponent <MeshRenderer>().sharedMaterial = manager.ShapeRenderMaterial;
Node.AddComponent <MeshFilter>().sharedMesh = ShapeVisualCone.GenerateMesh(shape);
}
else
{
Node = PrefabLoader.Instantiate <GameObject>(PrefabName);
Node.transform.localScale = GetShape().GetScale();
}
if (Node != null)
{
var renderers = Node.GetComponentsInChildren <Renderer>();
foreach (var renderer in renderers)
{
renderer.sharedMaterial = manager.ShapeRenderMaterial;
}
}
return(Node != null);
}
private static GameObject Create(string name, string objPath, HideFlags hideFlags = HideFlags.HideInHierarchy, string shaderName = "Diffuse")
{
GameObject gameObject = PrefabLoader.Instantiate <GameObject>(objPath);
if (gameObject == null)
{
throw new AgXUnity.Exception("Unable to load renderer: " + objPath);
}
gameObject.name = name;
gameObject.hideFlags = hideFlags;
Utils.SetMaterial(gameObject, shaderName);
return(gameObject);
}
private GameObject InstantiateAndSizePrimitiveRenderer(Visual visual)
{
var rendererPath = $"Debug/{visual.Geometry.Type.ToString()}Renderer";
var instance = PrefabLoader.Instantiate <GameObject>(rendererPath);
if (instance == null)
{
throw new UrdfIOException($"Unable to instantiate primitive renderer for {visual.Geometry.Type.ToString()} @ Resources/{rendererPath}.");
}
instance.transform.localScale = visual.Geometry.Type == Geometry.GeometryType.Box ?
visual.Geometry.FullExtents :
visual.Geometry.Type == Geometry.GeometryType.Cylinder ?
new Vector3(2.0f * visual.Geometry.Radius, 0.5f * visual.Geometry.Length, 2.0f * visual.Geometry.Radius) :
visual.Geometry.Type == Geometry.GeometryType.Sphere ?
2.0f * visual.Geometry.Radius * Vector3.one :
Vector3.one;
return(instance);
}
private GameObject GetInstance()
{
Action <GameObject, Material> setMaterialFunc = (go, material) =>
{
MeshRenderer[] renderers = go.GetComponentsInChildren <MeshRenderer>();
foreach (var renderer in renderers)
{
renderer.sharedMaterial = material;
}
};
// Moving create parent m_segments from Initialize to here because the
// editor will delete it when the user presses play then stop then "Undo".
if (m_segments == null)
{
var segmentsTransform = m_parentComponent.transform.Find("RenderSegments");
if (segmentsTransform != null)
{
m_segments = segmentsTransform.gameObject;
if (segmentsTransform.childCount > 0)
{
if (m_separateFirstObjectPrefabPath != string.Empty)
{
m_firstSegmentInstance = segmentsTransform.GetChild(0).gameObject;
}
if (m_firstSegmentInstance != null && segmentsTransform.childCount > 1)
{
m_segmentInstance = segmentsTransform.GetChild(1).gameObject;
}
else if (m_firstSegmentInstance == null)
{
m_segmentInstance = segmentsTransform.GetChild(0).gameObject;
}
}
}
else
{
m_segments = new GameObject("RenderSegments");
m_parentComponent.gameObject.AddChild(m_segments, false);
}
}
if (m_separateFirstObjectPrefabPath != string.Empty && m_firstSegmentInstance == null)
{
m_firstSegmentInstance = PrefabLoader.Instantiate <GameObject>(m_separateFirstObjectPrefabPath);
setMaterialFunc(m_firstSegmentInstance, Material);
AddSelectionProxy(m_firstSegmentInstance);
Add(m_firstSegmentInstance);
}
else if (m_segmentInstance == null)
{
m_segmentInstance = PrefabLoader.Instantiate <GameObject>(m_prefabObjectPath);
setMaterialFunc(m_segmentInstance, Material);
AddSelectionProxy(m_segmentInstance);
Add(m_segmentInstance);
}
// Push back new segment if there aren't enough segments already created.
int currentChildCount = m_segments.transform.childCount;
if (m_counter == currentChildCount)
{
Add(GameObject.Instantiate(m_segmentInstance));
}
else if (m_counter > currentChildCount)
{
throw new Exception("Internal counter is not in sync. Counter = " + m_counter + ", #children = " + currentChildCount);
}
return(m_segments.transform.GetChild(m_counter++).gameObject);
}
public Hit Test(Ray ray, float rayLength = 500.0f)
{
LastHit = Hit.Invalid;
if (Target == null)
{
return(Hit.Invalid);
}
Hit hit = new Hit();
Collide.Shape shape = Target.GetComponent <Collide.Shape>();
if (shape != null)
{
if (shape is Collide.Mesh)
{
hit.Triangle = MeshUtils.FindClosestTriangle((shape as Collide.Mesh).SourceObjects, shape.gameObject, ray, rayLength);
}
else if (shape is Collide.HeightField)
{
hit.Triangle = TriangleHit.Invalid;
}
else
{
GameObject tmp = PrefabLoader.Instantiate <GameObject>(Rendering.DebugRenderData.GetPrefabName(shape.GetType().Name));
if (tmp != null)
{
tmp.hideFlags = HideFlags.HideAndDontSave;
tmp.transform.position = shape.transform.position;
tmp.transform.rotation = shape.transform.rotation;
tmp.transform.localScale = shape.GetScale();
hit.Triangle = MeshUtils.FindClosestTriangle(tmp, ray, rayLength);
hit.Triangle.Target = shape.gameObject;
GameObject.DestroyImmediate(tmp);
}
}
}
else
{
MeshFilter filter = Target.GetComponent <MeshFilter>();
hit.Triangle = filter != null?MeshUtils.FindClosestTriangle(filter.sharedMesh, Target, ray, rayLength) : TriangleHit.Invalid;
}
if (hit.Triangle.Valid)
{
hit.Triangle.ClosestEdge = ShapeUtils.FindClosestEdgeToSegment(ray.GetPoint(0), ray.GetPoint(rayLength), hit.Triangle.Edges).Edge;
}
List <MeshUtils.Edge> allEdges = FindPrincipalEdges(shape, 10.0f).ToList();
if (hit.Triangle.Valid)
{
allEdges.Add(hit.Triangle.ClosestEdge);
}
var closestEdgeToSegmentResult = ShapeUtils.FindClosestEdgeToSegment(ray.GetPoint(0), ray.GetPoint(rayLength), allEdges.ToArray());
hit.ClosestEdge.Target = Target;
hit.ClosestEdge.Edge = closestEdgeToSegmentResult.Edge;
hit.ClosestEdge.Distance = closestEdgeToSegmentResult.Distance;
return(LastHit = hit);
}
