Exemple #1
0
    private Mesh DrawMeshFromData(MaskMeshData _data)
    {
        var mesh = new Mesh();

        if (_data.m_datas.Count < 2)
        {
            return(null);
        }
        var nbOfTriangles = (_data.m_datas.Count - 1) * 2;

        var nbOfVertices = nbOfTriangles * 3;
        var vertices     = new Vector3[nbOfVertices];

        var relativeRotation = Quaternion.Inverse(Quaternion.LookRotation(transform.forward));

        for (var i = 0; i < _data.m_datas.Count - 1; i++)
        {
            vertices[i * 6]     = relativeRotation * (_data.m_datas[i].m_start - transform.position);
            vertices[i * 6 + 1] = relativeRotation * (_data.m_datas[i].m_end - transform.position);
            vertices[i * 6 + 2] = relativeRotation * (_data.m_datas[i + 1].m_start - transform.position);
            vertices[i * 6 + 3] = relativeRotation * (_data.m_datas[i].m_end - transform.position);
            vertices[i * 6 + 4] = relativeRotation * (_data.m_datas[i + 1].m_end - transform.position);
            vertices[i * 6 + 5] = relativeRotation * (_data.m_datas[i + 1].m_start - transform.position);
        }


        var triangles = new int[nbOfTriangles * 3];

        for (var i = 0; i < triangles.Length; i++)
        {
            triangles[i] = i;
        }

        var uvs = new Vector2[nbOfVertices];

        for (var i = 0; i < uvs.Length; i++)
        {
            uvs[i] = new Vector2(0, 0);
        }

        mesh.vertices  = vertices;
        mesh.triangles = triangles;
        mesh.uv        = uvs;

        //mesh.normals = normals;
        return(mesh);
    }
Exemple #2
0
    private List <MaskMeshData> RayCast(MaskMeshData.TYPE _type)
    {
        LayerMask mask;

        switch (_type)
        {
        case MaskMeshData.TYPE.FULL:
            mask = m_fullCoverLayerMask;
            break;

        case MaskMeshData.TYPE.SEMI:
            mask = m_semiCoverLayerMask;
            break;

        default:
            throw new ArgumentOutOfRangeException(nameof(_type), _type, null);
        }
        var meshDataCollection = new List <MaskMeshData>();
        var currentMeshData    = new MaskMeshData(_type);

        var step = m_lineOfSight.m_amplitudeOfSightInDegrees / (m_lineOfSight.m_numberOfRaycast - 1);

        for (var i = 0; i < m_lineOfSight.m_numberOfRaycast; i++)
        {
            var angle            = (-m_lineOfSight.m_amplitudeOfSightInDegrees * .5f) + (i * step);
            var rayCastDirection = Quaternion.Euler(0, angle, 0) * transform.forward;
            var ray = new UnityEngine.Ray(transform.position, rayCastDirection);

            var currentRayCastResult = new RaycastData()
            {
                m_angle     = angle,
                m_direction = rayCastDirection
            };
            if (!Physics.Raycast(ray, out var hit, m_lineOfSight.m_maxDistance, mask))
            {
                currentRayCastResult.m_hit   = false;
                currentRayCastResult.m_start = transform.position;
                currentRayCastResult.m_end   = ray.GetPoint(m_lineOfSight.m_maxDistance);

                if (m_previousRaycastData.m_hit)
                {
                    if (currentMeshData.m_datas.Count > 0)
                    {
                        meshDataCollection.Add(currentMeshData);
                    }
                }

                m_previousRaycastData = currentRayCastResult;
                continue;
            }
            currentRayCastResult.m_hit   = true;
            currentRayCastResult.m_start = hit.point;
            currentRayCastResult.m_end   = ray.GetPoint(m_lineOfSight.m_maxDistance);

            if (m_previousRaycastData.m_hit)
            {
                currentMeshData.m_datas.Add(currentRayCastResult);
                if (i == m_lineOfSight.m_numberOfRaycast - 1)
                {
                    if (currentMeshData.m_datas.Count > 0)
                    {
                        meshDataCollection.Add(currentMeshData);
                    }
                }
            }
            else
            {
                currentMeshData = new MaskMeshData(_type);
                currentMeshData.m_datas.Add(currentRayCastResult);
                if (i > 0)
                {
                    FindEdge();
                }
            }
            m_previousRaycastData = currentRayCastResult;
        }

        return(meshDataCollection);
    }