//const float defaultViewportScale = 800f;
        private static SVGMatrix GetFillTransform(SVGPaintable svgPaintable, Rect bounds)
        {
            SVGFill   svgFill        = svgPaintable.svgFill;
            SVGMatrix transform      = new SVGMatrix();
            SVGMatrix gradientMatrix = svgFill.gradientTransform;

            Rect viewport = svgPaintable.viewport;

            if (svgFill.fillType == FILL_TYPE.GRADIENT)
            {
                switch (svgFill.gradientType)
                {
                case GRADIENT_TYPE.LINEAR:
                {
                    Vector2 startPoint = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
                    Vector2 endPoint   = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds);

                    Vector2 gradientVector   = endPoint - startPoint;
                    Vector2 normalizedVector = Vector2.zero;

                    float   angle   = Mathf.Atan2(gradientVector.y, gradientVector.x) * Mathf.Rad2Deg;
                    Vector2 posDiff = Vector2.Lerp(startPoint, endPoint, 0.5f);

                    float magnitude = gradientVector.magnitude;

                    if (magnitude != 0f)
                    {
                        normalizedVector.x = viewport.width / magnitude;
                        normalizedVector.y = viewport.height / magnitude;
                    }

                    transform = transform.Translate(viewport.center);
                    transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
                    transform = transform.Rotate(-angle);
                    transform = transform.Translate(-posDiff);

                    transform = transform.Multiply(gradientMatrix.Inverse());
                    transform = transform.Multiply(svgFill.transform.Inverse());

                    break;
                }

                case GRADIENT_TYPE.RADIAL:
                {
                    Vector2 point  = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
                    float   radius = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds).x;
                    if (svgFill.gradientEndX.unitType == SVGLengthType.Percentage)
                    {
                        radius *= 0.5f;
                    }

                    float radiusTimesTwo = radius * 2f;

                    Vector2 normalizedVector = Vector2.zero;

                    if (radiusTimesTwo != 0f)
                    {
                        normalizedVector.x = viewport.width / radiusTimesTwo;
                        normalizedVector.y = viewport.height / radiusTimesTwo;
                    }

                    transform = transform.Translate(viewport.center);
                    transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
                    transform = transform.Translate(-point);

                    transform = transform.Multiply(gradientMatrix.Inverse());
                    transform = transform.Multiply(svgFill.transform.Inverse());

                    break;
                }

                case GRADIENT_TYPE.CONICAL:
                {
                    Vector2 point  = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
                    float   radius = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds).x;
                    if (svgFill.gradientEndX.unitType == SVGLengthType.Percentage)
                    {
                        radius *= 0.5f;
                    }

                    float radiusTimesTwo = radius * 2f;

                    Vector2 normalizedVector = Vector2.zero;

                    if (radiusTimesTwo != 0f)
                    {
                        normalizedVector.x = viewport.width / radiusTimesTwo;
                        normalizedVector.y = viewport.height / radiusTimesTwo;
                    }

                    transform = transform.Translate(viewport.center);
                    transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
                    transform = transform.Translate(-point);

                    transform = transform.Multiply(gradientMatrix.Inverse());
                    transform = transform.Multiply(svgFill.transform.Inverse());

                    break;
                }
                }
            }

            return(transform);
        }
Exemple #2
0
        //const float defaultViewportScale = 800f;
        public static SVGMatrix GetFillTransform(SVGFill svgFill, Rect bounds, SVGLength[] gradientStart, SVGLength[] gradientEnd, SVGMatrix fillTransform, SVGMatrix gradientTransform)
        {
            SVGMatrix transform = SVGMatrix.identity;

            SVGLength gradientStartX = gradientStart[0];
            SVGLength gradientStartY = gradientStart[1];

            SVGLength gradientEndX = gradientEnd[0];
            SVGLength gradientEndY = gradientEnd[1];

            Rect viewport = svgFill.viewport;

            //Debug.Log(viewport);

            if (svgFill.fillType == FILL_TYPE.GRADIENT)
            {
                switch (svgFill.gradientType)
                {
                case GRADIENT_TYPE.LINEAR:
                {
                    Vector2 startPoint = GetGradientVector(gradientStartX, gradientStartY, bounds);
                    Vector2 endPoint   = GetGradientVector(gradientEndX, gradientEndY, bounds);

                    Vector2 gradientVector   = endPoint - startPoint;
                    Vector2 normalizedVector = Vector2.zero;

                    float   angle   = Mathf.Atan2(gradientVector.y, gradientVector.x) * Mathf.Rad2Deg;
                    Vector2 posDiff = Vector2.Lerp(startPoint, endPoint, 0.5f);

                    float magnitude = gradientVector.magnitude;

                    if (magnitude != 0f)
                    {
                        normalizedVector.x = viewport.width / magnitude;
                        normalizedVector.y = viewport.height / magnitude;
                    }

                    transform = transform.Translate(viewport.center);
                    transform = transform.Scale(normalizedVector.x, normalizedVector.y);
                    transform = transform.Rotate(-angle);
                    transform = transform.Translate(-posDiff);

                    transform = transform.Multiply(gradientTransform.Inverse());
                    transform = transform.Multiply(fillTransform.Inverse());

                    break;
                }

                case GRADIENT_TYPE.RADIAL:
                {
                    Vector2 point  = GetGradientVector(gradientStartX, gradientStartY, bounds);
                    float   radius = GetGradientVector(gradientEndX, gradientEndY, bounds).x;
                    if (gradientEndX.unitType == SVGLengthType.Percentage)
                    {
                        radius *= 0.5f;
                    }

                    float radiusTimesTwo = radius * 2f;

                    Vector2 normalizedVector = Vector2.zero;

                    if (radiusTimesTwo != 0f)
                    {
                        normalizedVector.x = viewport.width / radiusTimesTwo;
                        normalizedVector.y = viewport.height / radiusTimesTwo;
                    }

                    transform = transform.Translate(viewport.center);
                    transform = transform.Scale(normalizedVector.x, normalizedVector.y);
                    transform = transform.Translate(-point);

                    transform = transform.Multiply(gradientTransform.Inverse());
                    transform = transform.Multiply(fillTransform.Inverse());

                    break;
                }

                case GRADIENT_TYPE.CONICAL:
                {
                    Vector2 point  = GetGradientVector(gradientStartX, gradientStartY, bounds);
                    float   radius = GetGradientVector(gradientEndX, gradientEndY, bounds).x;
                    if (gradientEndX.unitType == SVGLengthType.Percentage)
                    {
                        radius *= 0.5f;
                    }

                    float radiusTimesTwo = radius * 2f;

                    Vector2 normalizedVector = Vector2.zero;

                    if (radiusTimesTwo != 0f)
                    {
                        normalizedVector.x = viewport.width / radiusTimesTwo;
                        normalizedVector.y = viewport.height / radiusTimesTwo;
                    }

                    transform = transform.Translate(viewport.center);
                    transform = transform.Scale(normalizedVector.x, normalizedVector.y);
                    transform = transform.Translate(-point);

                    transform = transform.Multiply(gradientTransform.Inverse());
                    transform = transform.Multiply(fillTransform.Inverse());

                    break;
                }
                }
            }

            return(transform);
        }
        //const float defaultViewportScale = 800f;
        private static SVGMatrix GetFillTransform(SVGPaintable svgPaintable, Rect bounds)
        {
            SVGFill svgFill = svgPaintable.svgFill;
            SVGMatrix transform = new SVGMatrix();
            SVGMatrix gradientMatrix = svgFill.gradientTransform;

            Rect viewport = svgPaintable.viewport;

            if (svgFill.fillType == FILL_TYPE.GRADIENT)
            {
                switch (svgFill.gradientType)
                {
                    case GRADIENT_TYPE.LINEAR:
                    {
                        Vector2 startPoint = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
                        Vector2 endPoint = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds);

                        Vector2 gradientVector = endPoint - startPoint;        
                        Vector2 normalizedVector = Vector2.zero;

                        float angle = Mathf.Atan2(gradientVector.y, gradientVector.x) * Mathf.Rad2Deg;
                        Vector2 posDiff = Vector2.Lerp(startPoint, endPoint, 0.5f);

                        float magnitude = gradientVector.magnitude;

                        if(magnitude != 0f)
                        {
                            normalizedVector.x = viewport.width / magnitude;
                            normalizedVector.y = viewport.height / magnitude;
                        }

                        transform = transform.Translate(viewport.center);
                        transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
                        transform = transform.Rotate(-angle);
                        transform = transform.Translate(-posDiff);

                        transform = transform.Multiply(gradientMatrix.Inverse());
                        transform = transform.Multiply(svgFill.transform.Inverse());

                        break;
                    }
                    case GRADIENT_TYPE.RADIAL:
                    {
                        Vector2 point = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
                        float radius = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds).x;
                        if(svgFill.gradientEndX.unitType == SVGLengthType.Percentage) radius *= 0.5f;

                        float radiusTimesTwo = radius * 2f;

                        Vector2 normalizedVector = Vector2.zero;

                        if(radiusTimesTwo != 0f)
                        {
                            normalizedVector.x = viewport.width / radiusTimesTwo;
                            normalizedVector.y = viewport.height / radiusTimesTwo;
                        }

                        transform = transform.Translate(viewport.center);
                        transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
                        transform = transform.Translate(-point);
                        
                        transform = transform.Multiply(gradientMatrix.Inverse());
                        transform = transform.Multiply(svgFill.transform.Inverse());

                        break;
                    }
                    case GRADIENT_TYPE.CONICAL:
                    {
                        Vector2 point = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
                        float radius = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds).x;
                        if(svgFill.gradientEndX.unitType == SVGLengthType.Percentage) radius *= 0.5f;

                        float radiusTimesTwo = radius * 2f;
                        
                        Vector2 normalizedVector = Vector2.zero;
                        
                        if(radiusTimesTwo != 0f)
                        {
                            normalizedVector.x = viewport.width / radiusTimesTwo;
                            normalizedVector.y = viewport.height / radiusTimesTwo;
                        }
                        
                        transform = transform.Translate(viewport.center);
                        transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
                        transform = transform.Translate(-point);
                        
                        transform = transform.Multiply(gradientMatrix.Inverse());
                        transform = transform.Multiply(svgFill.transform.Inverse());
                        
                        break;
                    }
                }
            }
            
            return transform;
        }