Esempio n. 1
0
    public GeomBuilder add_wedge(Color c,
                                 Vector3 wedge_base,
                                 Vector3 wedge_top,
                                 float width,
                                 Quaternion rot)
    {
        int     start_verts = new_verts.Count;
        float   delta_y     = wedge_top.y - wedge_base.y;
        Vector3 midpoint    = (wedge_top + wedge_base) / 2.0f;

        if (midpoint != Vector3.zero)
        {
            wedge_base = (wedge_base - (midpoint - Vector3.zero));
            wedge_top  = (wedge_top - (midpoint - Vector3.zero));
        }
        Vector3 p3 = new Vector3(wedge_top.x, wedge_base.y, wedge_top.z);

        Vector3 direction;

        if (wedge_base.y > wedge_top.y)
        {
            direction = new Vector3(0, 1000, 0);
        }
        else
        {
            direction = new Vector3(0, -1000, 0);
        }
        Vector3 offset = Vector3.Cross(
            ((wedge_top + direction) - wedge_base),
            (wedge_top - wedge_base)).normalized;

        offset *= (width / 2.0f);

        AddVertV3 add_vert = delegate(Vector3 v) {
            new_verts.Add(rot * v + midpoint);
        };

        if (width != 0 || delta_y != 0)
        {
            add_vert(wedge_top - offset);
            add_vert(wedge_base - offset);
            add_vert(wedge_base + offset);
            add_vert(wedge_top + offset);
            add_last_verts_as_quad();
        }
        if (width != 0 && (p3 - wedge_base).magnitude != 0)
        {
            add_vert(p3 - offset);
            add_vert(p3 + offset);
            add_vert(wedge_base + offset);
            add_vert(wedge_base - offset);
            add_last_verts_as_quad();
        }
        if (width != 0 && delta_y != 0.0)
        {
            add_vert(wedge_top - offset);
            add_vert(wedge_top + offset);
            add_vert(p3 + offset);
            add_vert(p3 - offset);
            add_last_verts_as_quad();
        }
        if (delta_y != 0 && (p3 - wedge_base).magnitude != 0)
        {
            add_vert(p3 - offset);
            add_vert(wedge_base - offset);
            add_vert(wedge_top - offset);
            add_last_verts_as_tri();

            add_vert(wedge_top + offset);
            add_vert(wedge_base + offset);
            add_vert(p3 + offset);
            add_last_verts_as_tri();
        }
        int end_verts = new_verts.Count;

        add_vert_colors(c, start_verts, end_verts);
        return(this);
    }
Esempio n. 2
0
    public GeomBuilder add_dome(Color c,
                                Vector3 center,
                                float radius,
                                int samples,
                                int planes,
                                Quaternion rot)
    {
        int   start_verts = new_verts.Count;
        float two_pi      = Mathf.PI * 2;
        float half_pi     = Mathf.PI / 2;
        var   azimuths    = (from x in Enumerable.Range(0, samples + 1)
                             select(two_pi * x) / samples).ToList <float>();
        var elevations = (from x in Enumerable.Range(0, planes)
                          select(half_pi * x) / (planes - 1)).ToList <float>();
        AddVertV3 add_vert = delegate(Vector3 v) {
            new_verts.Add(rot * v + center);
        };

        foreach (int i in Enumerable.Range(0, elevations.Count() - 2))
        {
            foreach (int j in Enumerable.Range(0, azimuths.Count() - 1))
            {
                Vector3 p1 = to_cartesian(azimuths.ElementAt(j),
                                          elevations.ElementAt(i), radius);

                Vector3 p2 = to_cartesian(azimuths.ElementAt(j),
                                          elevations.ElementAt(i + 1), radius);

                Vector3 p3 = to_cartesian(azimuths.ElementAt(j + 1),
                                          elevations.ElementAt(i + 1), radius);

                Vector3 p4 = to_cartesian(azimuths.ElementAt(j + 1),
                                          elevations.ElementAt(i), radius);

                add_vert(p1);
                add_vert(p2);
                add_vert(p3);
                add_vert(p4);
                add_last_verts_as_quad();
            }
        }
        foreach (int k in Enumerable.Range(0, azimuths.Count() - 1))
        {
            Vector3 p1 = to_cartesian(azimuths.ElementAt(k),
                                      elevations.ElementAt(elevations.Count() - 2), radius);

            Vector3 p2 = new Vector3(0, radius, 0);

            Vector3 p3 = to_cartesian(azimuths.ElementAt(k + 1),
                                      elevations.ElementAt(elevations.Count() - 2), radius);

            add_vert(p1);
            add_vert(p2);
            add_vert(p3);
            add_last_verts_as_tri();
        }
        int end_verts = new_verts.Count;

        add_vert_colors(c, start_verts, end_verts);
        return(this);
    }
Esempio n. 3
0
    public GeomBuilder add_ramp(Color c,
                                Vector3 ramp_base,
                                Vector3 ramp_top,
                                float width,
                                float thickness,
                                Quaternion rot)
    {
        int     start_verts = new_verts.Count;
        Vector3 midpoint    = (ramp_top + ramp_base) / 2.0f;

        if (midpoint != Vector3.zero)
        {
            ramp_base = (ramp_base - (midpoint - Vector3.zero));
            ramp_top  = (ramp_top - (midpoint - Vector3.zero));
        }

        Vector3 p3 = new Vector3(ramp_top.x,
                                 ramp_top.y - thickness, ramp_top.z);
        Vector3 p4 = new Vector3(ramp_base.x,
                                 ramp_base.y - thickness, ramp_base.z);

        Vector3 offset = Vector3.Cross(
            ((ramp_top + new Vector3(0, -1000, 0)) - ramp_base),
            (ramp_top - ramp_base)).normalized;

        offset *= (width / 2.0f);

        AddVertV3 add_vert = delegate(Vector3 v) {
            new_verts.Add(rot * v + midpoint);
        };

        if (width != 0 && (p3 - ramp_base).magnitude != 0)
        {
            add_vert(ramp_top - offset);
            add_vert(ramp_base - offset);
            add_vert(ramp_base + offset);
            add_vert(ramp_top + offset);
            add_last_verts_as_quad();

            add_vert(p4 + offset);
            add_vert(p4 - offset);
            add_vert(p3 - offset);
            add_vert(p3 + offset);
            add_last_verts_as_quad();
        }
        if (width != 0 && thickness != 0)
        {
            add_vert(ramp_top - offset);
            add_vert(ramp_top + offset);
            add_vert(p3 + offset);
            add_vert(p3 - offset);
            add_last_verts_as_quad();

            add_vert(p4 - offset);
            add_vert(p4 + offset);
            add_vert(ramp_base + offset);
            add_vert(ramp_base - offset);
            add_last_verts_as_quad();
        }
        if (thickness != 0 && (p3 - ramp_base).magnitude != 0)
        {
            add_vert(ramp_top - offset);
            add_vert(p3 - offset);
            add_vert(p4 - offset);
            add_vert(ramp_base - offset);
            add_last_verts_as_quad();

            add_vert(p4 + offset);
            add_vert(p3 + offset);
            add_vert(ramp_top + offset);
            add_vert(ramp_base + offset);
            add_last_verts_as_quad();
        }

        int end_verts = new_verts.Count;

        add_vert_colors(c, start_verts, end_verts);
        return(this);
    }