Esempio n. 1
0
    public FMeshQuad AddQuad(FMeshVertex vertex1, FMeshVertex vertex2, FMeshVertex vertex3, FMeshVertex vertex4)
    {
        FMeshQuad quad = new FMeshQuad(vertex1, vertex2, vertex3, vertex4);

        AddFacet(quad);
        return(quad);
    }
    public void UpdateMesh()
    {
        int tileCount = _elements.Length;

        _meshData.SetFacetCount(tileCount);

        float width  = _cols * _tileWidth;
        float height = _rows * _tileHeight;

        float offsetX = -_anchorX * width;
        float offsetY = -_anchorY * height;

        List <FMeshFacet> quads = _meshData.facets;

        int i = 0;

        for (int r = 0; r < _rows; r++)
        {
            for (int c = 0; c < _cols; c++)
            {
                FMeshQuad quad = (FMeshQuad)quads[i];

                quad.SetUVRectFromElement(_elements[i]);
                quad.SetPosRect(offsetX + c * _tileWidth, offsetY + r * _tileHeight, _tileWidth, _tileHeight);

                i++;
            }
        }

        _meshData.MarkChanged();
    }
Esempio n. 3
0
    public FMeshQuad AddQuad(FMeshVertex[] vertices)
    {
        FMeshQuad quad = new FMeshQuad(vertices);

        AddFacet(quad);
        return(quad);
    }
Esempio n. 4
0
    public FMeshQuad AddQuad()
    {
        FMeshQuad quad = new FMeshQuad();

        AddFacet(quad);
        return(quad);
    }
Esempio n. 5
0
 public FMeshQuad AddQuad(FMeshQuad quad)
 {
     AddFacet(quad);
     return(quad);
 }
Esempio n. 6
0
 public FMeshQuad AddQuad(FMeshVertex vertex1, FMeshVertex vertex2, FMeshVertex vertex3, FMeshVertex vertex4)
 {
     FMeshQuad quad = new FMeshQuad(vertex1,vertex2,vertex3,vertex4);
     AddFacet(quad);
     return quad;
 }
Esempio n. 7
0
 public FMeshQuad AddQuad(FMeshVertex[] vertices)
 {
     FMeshQuad quad = new FMeshQuad(vertices);
     AddFacet(quad);
     return quad;
 }
Esempio n. 8
0
 public FMeshQuad AddQuad(FMeshQuad quad)
 {
     AddFacet(quad);
     return quad;
 }
Esempio n. 9
0
 public FMeshQuad AddQuad()
 {
     FMeshQuad quad = new FMeshQuad();
     AddFacet(quad);
     return quad;
 }
    public void UpdateMesh()
    {
        float offsetX = -_anchorX * width;
        float offsetY = -_anchorY * height;

        float ewidth  = _element.sourceSize.x;
        float eheight = _element.sourceSize.y;

        float leftRemaining   = RXMath.Mod(_scrollX, ewidth);
        float bottomRemaining = RXMath.Mod(_scrollY, eheight);

        float leftX  = leftRemaining;
        float rightX = leftX + width;

        int leftCol  = 0;
        int rightCol = Mathf.FloorToInt(rightX / ewidth);

        if (rightX % ewidth == 0)
        {
            rightCol--;                              //if it fits exactly, we don't need the last column
        }
        float bottomY = bottomRemaining;
        float topY    = bottomY + height;

        int bottomRow = 0;
        int topRow    = Mathf.FloorToInt(topY / eheight);

        if (topY % eheight == 0)
        {
            topRow--;                             //if it fits exactly, we don't need the last row
        }
        int numCols = (rightCol - leftCol) + 1;
        int numRows = (topRow - bottomRow) + 1;

        _meshData.SetFacetCount(numCols * numRows);

        List <FMeshFacet> quads = _meshData.facets;

        float rightRemaining = ((rightCol + 1) * ewidth - rightX);
        float topRemaining   = ((topRow + 1) * eheight - topY);

        int q = 0;

        for (int r = 0; r < numRows; r++)
        {
            float quadBottom = offsetY + r * eheight - bottomRemaining;
            float quadTop    = quadBottom + eheight;
            float uvBottom   = 0;
            float uvTop      = 1.0f;

            if (r == 0)           //bottomRow
            {
                quadBottom += bottomRemaining;
                uvBottom   += bottomRemaining / eheight;
            }

            if (r == numRows - 1)         //topRow
            {
                quadTop -= topRemaining;
                uvTop   -= topRemaining / eheight;
            }

            for (int c = 0; c < numCols; c++)
            {
                FMeshQuad quad = (FMeshQuad)quads[q];
                q++;

                float quadLeft  = offsetX + c * ewidth - leftRemaining;
                float quadRight = quadLeft + ewidth;
                float uvLeft    = 0;
                float uvRight   = 1.0f;

                if (c == 0)               //leftCol
                {
                    quadLeft += leftRemaining;
                    uvLeft   += leftRemaining / ewidth;
                }

                if (c == numCols - 1)             //rightCol
                {
                    quadRight -= rightRemaining;
                    uvRight   -= rightRemaining / ewidth;
                }

                quad.SetPosExtents(quadLeft, quadRight, quadBottom, quadTop);
                quad.SetUVExtents(uvLeft, uvRight, uvBottom, uvTop);
            }
        }

        _meshData.MarkChanged();
    }