示例#1
0
    void CreatePloyObj(nav_editor.MyPoly poly, int id)
    {
        GameObject obj = new GameObject();

        obj.name                    = "PolyMesh_" + id.ToString();
        obj.transform.parent        = parent_;
        obj.transform.localPosition = Vector3.zero;
        obj.transform.localScale    = Vector3.one;
        obj.transform.localRotation = Quaternion.Euler(Vector3.zero);

        MeshFilter   mesh_filter = obj.AddComponent <MeshFilter>();
        MeshRenderer mesh_render = obj.AddComponent <MeshRenderer>();

        mesh_render.material = new Material(Shader.Find("unlit/vertex_color"));

        Mesh mesh = new Mesh();

        mesh.name = obj.name;

        mesh_filter.sharedMesh = mesh;

        //转换数据
        Vector3[] vertices = new Vector3[poly.vertex_num];
        int[]     indexes  = new int[poly.index_num];
        Color[]   colors   = new Color[poly.vertex_num];

        for (int i = 0; i < poly.vertex_num; ++i)
        {
            IntPtr p = new IntPtr(poly.vertexs.ToInt64() + (uint)(i * Marshal.SizeOf(typeof(nav_editor.MyVertex))));
            nav_editor.MyVertex v = nav_editor.PtrToStructure <nav_editor.MyVertex>(p);
            vertices[i].x = -v.v[0]; //注意!
            vertices[i].y = v.v[1];
            vertices[i].z = v.v[2];

            colors[i] = GetColor(poly.area);
            //colors[i].a = 0.3f;
        }

        for (int i = 0; i < poly.index_num; ++i)
        {
            IntPtr p = new IntPtr(poly.indexs.ToInt64() + (uint)(i * Marshal.SizeOf(typeof(int))));
            indexes[i] = nav_editor.PtrToStructure <int>(p);
        }

        Transform trans = obj.transform;

        for (int i = 0; i < vertices.Length; ++i)
        {
            vertices[i] = trans.InverseTransformPoint(vertices[i]);
        }
        mesh.vertices  = vertices;
        mesh.triangles = indexes;
        mesh.colors    = colors;
    }
示例#2
0
    void TestFindPath()
    {
        nav_editor.MyVertex start = new nav_editor.MyVertex();
        start.v    = new float[3];
        start.v[0] = -start_pos.x;
        start.v[1] = start_pos.y;
        start.v[2] = start_pos.z;

        nav_editor.MyVertex end = new nav_editor.MyVertex();
        end.v    = new float[3];
        end.v[0] = -end_pos.x;
        end.v[1] = end_pos.y;
        end.v[2] = end_pos.z;

        int    num = 0;
        IntPtr vf  = IntPtr.Zero;

        for (int i = 0; i < ConvexUtilities.flag_edit_num; ++i)
        {
            if (include_toggle[i])
            {
                include_flag |= (ushort)(1 << i);
            }
            else
            {
                include_flag &= (ushort)(~(1 << i));
            }
        }
        for (int i = 0; i < ConvexUtilities.flag_edit_num; ++i)
        {
            if (exclude_toggle[i])
            {
                exclude_flag |= (ushort)(1 << i);
            }
            else
            {
                exclude_flag &= (ushort)(~(1 << i));
            }
        }

        pos_list.Clear();
        nav_editor.editor_nav_mesh_path_query(ref start, ref end, include_flag, exclude_flag, ref num, ref vf);

        //Debug.Log("find path,from:" + start_pos.ToString() + ",to:" + end_pos.ToString() + " num:" + num.ToString());

        for (int i = 0; i < num; ++i)
        {
            IntPtr p  = new IntPtr(vf.ToInt64() + (uint)(3 * i * Marshal.SizeOf(typeof(float))));
            IntPtr p1 = new IntPtr(p.ToInt64() + 1 * Marshal.SizeOf(typeof(float)));
            IntPtr p2 = new IntPtr(p.ToInt64() + 2 * Marshal.SizeOf(typeof(float)));

            float   x   = -nav_editor.PtrToStructure <float>(p);
            float   y   = nav_editor.PtrToStructure <float>(p1);
            float   z   = nav_editor.PtrToStructure <float>(p2);
            Vector3 pos = new Vector3(x, y, z);

            //Debug.Log(pos.ToString());

            pos_list.Add(pos);
        }
    }