C# Unity 3D - Is there a way to make custom raycast shapes?

Question

I have a ship that will shoot targets, but cannons on the right side should never try to shot at targets on the left side of the ship. Thus I have created sectors using the SignedAngle function, this works fine for testing, but its also kind of broken as you can see from the visualization below. I have tried using boxcast but alas it also doesnt work for this use case.

The above image visualizes what my script does, but this is not a solution to my problem. As targets close to the side and front of the ship will be outside the sector, for clarification what I mean, see picture 3.

This second image shows what happens when we increase the angle, we can now detect more targets, but we have 2 big incorrect sectors marked in red which shouldnt be there.

Finally, this is how I think it should look, its still a cone, but the big difference is that it starts with a wide bottom, thus it resolves the problem Im having with the current SignedAngle function which determines everything from a single point in the middle.

This is the script for assigning targets to the correct list according to which sector they are in:

foreach (Transform target in EnemyListManager.instance.enemyShips.ToArray())
        {

            if (Vector3.Distance(transform.position, target.position) > ship.mainGunCaliber.range)
                continue;

            Vector3 toTarget = target.position - transform.position;
            print(Vector3.SignedAngle(hullParent.forward, toTarget, Vector3.up));

            if (Vector3.SignedAngle(hullParent.forward, toTarget, Vector3.up) >= bowMinAngle &&
                Vector3.SignedAngle(hullParent.forward, toTarget, Vector3.up) <= bowMaxAngle)
            {
                if (!bowTargets.Contains(target))
                {
                    RemoveFromOthers(target);
                    bowTargets.Add(target);
                    print("added target to Bow");
                }
                continue;
            }
            if (Vector3.SignedAngle(hullParent.forward, toTarget, Vector3.up) >= sbMinAngle &&
                Vector3.SignedAngle(hullParent.forward, toTarget, Vector3.up) <= sbMaxAngle)
            {
                if (!sbTargets.Contains(target))
                {
                    RemoveFromOthers(target);
                    sbTargets.Add(target);
                    print("added target to SB");

                }
                continue;

            }
            if (Vector3.SignedAngle(-hullParent.forward, toTarget, Vector3.up) >= aftMinAngle &&
                Vector3.SignedAngle(-hullParent.forward, toTarget, Vector3.up) <= aftMaxAngle)
            {
                if (!aftTargets.Contains(target))
                {
                    RemoveFromOthers(target);
                    aftTargets.Add(target);
                    print("added target to Aft");

                }
                continue;
            }
            if (Vector3.SignedAngle(hullParent.forward, toTarget, Vector3.up) >= psMinAngle &&
                Vector3.SignedAngle(hullParent.forward, toTarget, Vector3.up) <= psMaxAngle)
            {
                if (!psTargets.Contains(target))
                {
                    RemoveFromOthers(target);
                    psTargets.Add(target);
                    print("added target to PS");

                }

            }
        }

Any help would be appreciated on how to tackle this problem!

Thank you.

Cent you raycast a sphere. And ignore all too high? – BugFinder Sep 14 '22 at 19:55 — BugFinder, Sep 14 '22 at 19:55

score 2 · Accepted Answer · answered Sep 14 '22 at 21:06

2

There are a couple options I can think of.

You can use 4 (or more, for up-down range as well) points to measure the angles from instead of the single point from the center that I'd previously suggested.

Your code, for the starboard side, would then be more like (I think, I'm nautically inclined so I may be wrong about the labelling lol):

if (Vector3.SignedAngle(markerBowStarboard.right, toTarget, Vector3.up) >= sbMinAngle &&
    Vector3.SignedAngle(markerAftStarboard.right, toTarget, Vector3.up) <= sbMaxAngle)
{
    if (!sbTargets.Contains(target))
    {
        RemoveFromOthers(target);
        sbTargets.Add(target);
        print("added target to SB");

    }
    continue;
}

You could try to adapt something from this "ConeCast" extension method someone made. It still has the issue of being from the central point, but you may be able to tweak it to start the cast, for example, further left of the ship and check that the target is on the right of the ship (convert the target global position to the local reference frame of the ship and check x/y is >0/<0). It's sort of just trading one manual calculation for another, though.
Stealing from rustyBucketBay's answer a bit, you could use the larger of the SphereCast cylinders and use some trig to rule out ships that are less than a distance from the ship based on the cosine of the angle illustrated here:

But again, it's sort of just trading one calculation for another.

You could create a conic cylinder model, don't render it but give it a MeshCollider, and then when objects enter the object (OnColliderEnter, I think?) you can add them to that direction's list and remove when they exit (OnColliderExit maybe?). You may need to do some more checking on when it is fully inside the conic cylinder though, because I think OnColliderExit (or whatever it's called) is triggered when the model stops colliding with the actual mesh, regardless of whether it is inside or outside of the object.

I'm not super sure I like any of those that much, but I'm surprised that there isn't a native "ConeCast" that can take near- and far-plane dimensions... but then I guess I'm just saying to Unity "I don't wanna do it, you do it" lol.

answered Sep 14 '22 at 21:06

Daevin

778
3
14
31

1

Thanks for your answer! I ended up using option 1. It works great and its a simple solution, I only used 2 markers though at the center line of the ship so I can use those two markers for each side. – Mad Hatter Sep 14 '22 at 23:51
2

I think in general doing this by simple math instead of using physics will usually be better in performance – derHugo Sep 15 '22 at 09:49
I have a feeling this is correct. Do you know how Unity calculates its Angles? I dont understand how it gives us an angle between 2 `Vector3`s. Essentially all I want is the Y Axis Angle Difference between `ourShip` and `target`. In this script we are rotating around `Vector3.up`, which is Y angle. Is there a better way to find the Y angle difference, or is THIS the correct way? I feel like with `Angle` and `SignedAngle` functions there is some errors or weird calculations because sometimes it returns the angle X or Z instead of Y? Or is that not true? – Mad Hatter Sep 15 '22 at 11:16
@MadHatter derHugo is likely correct, simple math should be better for performance. Maybe they could clarify how Unity does it (they're quite good with Unity), but mathematically it's basic vector and trig calculations. I don't think there would be errors in the functions, but one thing to note is that `Vector3.up` will be the ***local*** up vector (0,1,0), whereas `ship.transform.forward` (I think you have it as `hullParent.forward`?) will be the ***global*** vector for the ship. Try use `hullParent.up` instead of `Vector3.up`, that should 'fix' it? I think it's just a reference frame issue. – Daevin Sep 15 '22 at 13:33
@MadHatter as for how it gives an angle between 2 `Vector3`s... there are in essence 4 angles between 2 `Vector3`s; in the xy-pane, the yz-plane, the xz-plane, and the plane defined by the 2 vectors (which may or may not be distinct from the other 3 planes). I think technically there are infinitely many as there are infinitely many vectors to rotate around... but for simplicity let's just say the 4 I mentioned. If you choose, the y-axis to rotate around you're asking for the angle in the xz-plane, x-axis in the yz-plane, etc. It just calculates the angle in the chosen plane using simple math. – Daevin Sep 15 '22 at 13:56
@MadHatter if you're curious about the math, [here is a video](https://www.youtube.com/watch?v=TTom8n3FFCw) to show how "easy" it is for a computer to calculate. – Daevin Sep 15 '22 at 13:57
@Daevin Thanks again for the explanation. The reason I use Vector3.up is because the ships is affected by water physics so it will be rolling and pitching constantly. For these sector determinations I dont need to take this rolling and pitching into account though, so the math is all done on a "flat plane", thats why I was asking if this is the correct way to calculate a single axis angle if you know that Vector3.up is always up and never changes? Thats why I still have a feeling the Unity Angle functions are overkill, if I really just need a single axis angle. – Mad Hatter Sep 15 '22 at 14:32
This stuff is always very tricky to explain as it requires a lot of spacial thinking to imagine in your head what im trying to say, but basically its like the pictures I drew, imagine everything is on a flat plane, there is no height, so its basically a 2D scene, then I want the Y angle between target and ship, (from the ship). Is there a simpler way to do this or is this the Unity way? – Mad Hatter Sep 15 '22 at 14:35
@Daevin Nice video btw! Brings me back to my school memories. Im gonna see if there is a video that visualizes the trigonometry and why we need the magnitude and what the dot product is.. time to start learning again haha – Mad Hatter Sep 15 '22 at 15:02
Let us [continue this discussion in chat](https://chat.stackoverflow.com/rooms/248107/discussion-between-daevin-and-mad-hatter). – Daevin Sep 16 '22 at 13:19

score 0 · Answer 2 · answered Sep 14 '22 at 19:53

Some random ideas here. I would try discard the not desired sector with 2 sphere casts of different diameter. (https://docs.unity3d.com/ScriptReference/Physics.SphereCast.html). See beam2 and beam1 and the in the image below.

You can set the length of detection with maxDistance argument of the spheres cast. This will determine the length of the cone, so the Starboard Aim Sector length. The zone green lined is for the points that are detected by the beam2 but not beam1.

What to do with those points? Some are inside the cone, and some are not. A cone is simply an infinite number of circles whose size is defined by a linear equation that takes the distance from the point. So with the distance from the rays origin in the beams direction, you know the circle size of that section of the cone. You should then easily be able to know if your point is in/out that circle, so in/out of the cone.

C# Unity 3D - Is there a way to make custom raycast shapes?

2 Answers2