示例#1
0
    public void startGlint()
    {
        for (int i = 0; i < m_aQuads.Count; i++)
        {
            GameObject quad   = (GameObject)m_aQuads[i];
            CQuad      script = (CQuad)quad.GetComponent(typeof(CQuad));
            script.m_bGlint = true;
        }

        m_bStopGlint = true;
//		InvokeRepeating("stopGlint", 1,5);
        int range = Random.Range(0, 3);

        switch (range)
        {
        case 0:
            transform.Rotate(0, 0, 90);
            break;

        case 1:
            transform.Rotate(0, 0, 180);
            break;

        case 2:
            transform.Rotate(0, 0, 270);
            break;

        case 3:
            transform.Rotate(0, 0, 360);
            break;
        }
    }
示例#2
0
        public void Tick(float deltaTime)
        {
            if (CQuad == null)
            {
                CQuad = new CollisionQuad(0, 0, 0, 0, 0, 0);
            }
            var lbn = Vector4.Transform(m_quadLBZ, Matrix4.CreateTranslation(m_lightSource.Position));
            var rtf = Vector4.Transform(m_quadRTZ, Matrix4.CreateTranslation(m_lightSource.Position));

            CQuad.synchronizeCoordinates(lbn.X, rtf.X, lbn.Y, rtf.Y, lbn.Z, lbn.Z);
        }
示例#3
0
    void stopGlint()
    {
        for (int i = 0; i < m_aQuads.Count; i++)
        {
            GameObject quad   = (GameObject)m_aQuads[i];
            CQuad      script = (CQuad)quad.GetComponent(typeof(CQuad));
            script.m_bGlint = false;
        }
        createMask();
        m_bStopGlint = false;
//		CancelInvoke ();
    }
    public void RebuildEverything()
    {
        for (int v = 0; v < 4; ++v)
        {
            List <CQuad> _quads = new List <CQuad>();

            for (int i = 0; i < mPlanes.Count; ++i)
            {
                CModelPlane p = mPlanes[i];

                Quaternion o = Quaternion.Euler(p.mRotation);
                Matrix4x4  m = Matrix4x4.TRS(p.mPosition, o, Vector3.one);
                p.mAxisX = m.MultiplyVector(Vector3.right);
                p.mAxisY = m.MultiplyVector(Vector3.up);
                p.mAxisZ = m.MultiplyVector(Vector3.forward);

                Vector3 c1 = m.MultiplyPoint(p.mCorner[0].mPosition);
                Vector3 c2 = m.MultiplyPoint(p.mCorner[1].mPosition);
                Vector3 c3 = m.MultiplyPoint(p.mCorner[2].mPosition);
                Vector3 c4 = m.MultiplyPoint(p.mCorner[3].mPosition);
                p.c1 = c1; p.c2 = c2; p.c3 = c3; p.c4 = c4;

                Vector3 normal = p.mAxisY;

                Vector3 c1c2 = (c2 - c1).normalized;
                Vector3 c2c3 = (c3 - c2).normalized;
                Vector3 c3c4 = (c4 - c3).normalized;
                Vector3 c4c1 = (c1 - c4).normalized;

                Vector3 perp1 = Vector3.Cross(normal, c1c2);
                Vector3 perp2 = Vector3.Cross(normal, c2c3);
                Vector3 perp3 = Vector3.Cross(normal, c3c4);
                Vector3 perp4 = Vector3.Cross(normal, c4c1);
                p.perp1 = perp1; p.perp2 = perp2; p.perp3 = perp3; p.perp4 = perp4;

                Vector3 ie1_1 = Vector3.zero;
                Vector3 ie1_2 = Vector3.zero;
                Vector3 ie2_1 = Vector3.zero;
                Vector3 ie2_2 = Vector3.zero;
                Vector3 ie3_1 = Vector3.zero;
                Vector3 ie3_2 = Vector3.zero;
                Vector3 ie4_1 = Vector3.zero;
                Vector3 ie4_2 = Vector3.zero;

                if (p.mEdge[0].mBrush[v] != null)
                {
                    CBrushAsset brush = p.mEdge[0].mBrush[v];
                    ie1_1 = -c2c3 * (brush.mWeight / Vector3.Dot(-c2c3, perp1));
                    ie1_2 = c4c1 * (brush.mWeight / Vector3.Dot(c4c1, perp1));
                    CQuad q = new CQuad();
                    q.c  = brush.mColor;
                    q.v1 = c1;
                    q.v2 = c2;
                    q.v3 = c2 + ie1_1;
                    q.v4 = c1 + ie1_2;
                    q.n  = normal;

                    _quads.Add(q);
                }

                if (p.mEdge[1].mBrush[v] != null)
                {
                    CBrushAsset brush = p.mEdge[1].mBrush[v];
                    ie2_1 = c1c2 * (brush.mWeight / Vector3.Dot(c1c2, perp2));
                    ie2_2 = -c3c4 * (brush.mWeight / Vector3.Dot(-c3c4, perp2));
                    CQuad q = new CQuad();
                    q.c  = brush.mColor;
                    q.v1 = c2 + ie2_1;
                    q.v2 = c2;
                    q.v3 = c3;
                    q.v4 = c3 + ie2_2;
                    q.n  = normal;

                    _quads.Add(q);
                }

                if (p.mEdge[2].mBrush[v] != null)
                {
                    CBrushAsset brush = p.mEdge[2].mBrush[v];
                    ie3_1 = -c4c1 * (brush.mWeight / Vector3.Dot(-c4c1, perp3));
                    ie3_2 = c2c3 * (brush.mWeight / Vector3.Dot(c2c3, perp3));
                    CQuad q = new CQuad();
                    q.c  = brush.mColor;
                    q.v1 = c4 + ie3_1;
                    q.v2 = c3 + ie3_2;
                    q.v3 = c3;
                    q.v4 = c4;
                    q.n  = normal;

                    _quads.Add(q);
                }

                if (p.mEdge[3].mBrush[v] != null)
                {
                    CBrushAsset brush = p.mEdge[3].mBrush[v];
                    ie4_1 = -c1c2 * (brush.mWeight / Vector3.Dot(-c1c2, perp4));
                    ie4_2 = c3c4 * (brush.mWeight / Vector3.Dot(c3c4, perp4));
                    CQuad q = new CQuad();
                    q.c  = brush.mColor;
                    q.v1 = c1;
                    q.v2 = c1 + ie4_1;
                    q.v3 = c4 + ie4_2;
                    q.v4 = c4;
                    q.n  = normal;

                    _quads.Add(q);
                }

                if (p.mFillBrush != null)
                {
                    CQuad q = new CQuad();
                    q.c  = p.mFillBrush.mColor;
                    q.v1 = c1 + ie1_2 + ie4_1;
                    q.v2 = c2 + ie1_1 + ie2_1;
                    q.v3 = c3 + ie2_2 + ie3_2;
                    q.v4 = c4 + ie3_1 + ie4_2;
                    q.n  = normal;

                    _quads.Add(q);
                }
            }

            if (_mesh[v] == null)
            {
                _mesh[v] = new Mesh();
            }
            else
            {
                _mesh[v].Clear(true);
            }

            if (_quads.Count != 0)
            {
                Vector3[] verts = new Vector3[_quads.Count * 4];
                Color32[] cols  = new Color32[_quads.Count * 4];
                int[]     tris  = new int[_quads.Count * 6];

                for (int i = 0; i < _quads.Count; ++i)
                {
                    CQuad q = _quads[i];

                    verts[i * 4 + 0] = q.v1;
                    verts[i * 4 + 1] = q.v2;
                    verts[i * 4 + 2] = q.v3;
                    verts[i * 4 + 3] = q.v4;

                    tris[i * 6 + 0] = i * 4 + 0;
                    tris[i * 6 + 1] = i * 4 + 1;
                    tris[i * 6 + 2] = i * 4 + 2;
                    tris[i * 6 + 3] = i * 4 + 0;
                    tris[i * 6 + 4] = i * 4 + 2;
                    tris[i * 6 + 5] = i * 4 + 3;

                    cols[i * 4 + 0] = q.c;
                    cols[i * 4 + 1] = q.c;
                    cols[i * 4 + 2] = q.c;
                    cols[i * 4 + 3] = q.c;
                }

                _mesh[v].vertices  = verts;
                _mesh[v].colors32  = cols;
                _mesh[v].triangles = tris;
            }
        }
    }