(root)/iphone/tappity : 60 : common/source/geometry.m

//

//  geometry.m

//

//  Created by döme on 26.07.2009.

//

 

/*

 * Copyright (c) 2009 Doemoetoer Gulyas.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. The name of the author may not be used to endorse or promote products

 *    derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

 

#import "geometry.h"

 

m16 computeAlignedBasesFromDownVector(v3 acc)

{

        v3 up = vnormalize(vnegate(acc));

        

        v3 X = {{1.0,0.0,0.0}};

        v3 Y = {{0.0,1.0,0.0}};

//      v3 Z = {{0.0,0.0,1.0}};

 

        float udx = vdot(up, X);

        float udy = vdot(up, Y);

        

//      float upalignx = fabs(udx);

//      float upaligny = fabs(udy);

 

                

        

        v3 forwardax = vmul(vcross(up,X), 1.0);

 

        v3 rightay = vmul(vcross(Y,up), 1.0);

        v3 forwarday = vcross(up, rightay);

 

        float weightx = 1.0 - udx;

        float weighty = 1.0 - udy;

 

        v3 forward = vnormalize(vadd(vmul(forwardax, weightx), vmul(forwarday, weighty)));

        v3 right = vnormalize(vcross(forward, up));

 

        

        m16 m = {{right.v.x, right.v.y, right.v.z, 0.0f,

                        forward.v.x, forward.v.y, forward.v.z, 0.0f,

                        up.v.x, up.v.y, up.v.z, 0.0f,

                        0.0f, 0.0f, 0.0f, 1.0f}};

        

        return m;

}

 

m16 computeAlignedBasesFromDownVector2(v3 acc, v3 pf)

{

        if (vdot(acc,acc) < FLT_EPSILON)

                acc = vcreate(0.0,0.0,-1.0);

        if (vdot(pf,pf) < FLT_EPSILON)

                pf = vcreate(0.0,1.0,0.0);

        v3 up = vnormalize(vnegate(acc));

        

        v3 right = vnormalize(vcross(pf, up));

        v3 forward = vnormalize(vcross(up,right));

 

        

        m16 m = {{right.v.x, right.v.y, right.v.z, 0.0f,

                        forward.v.x, forward.v.y, forward.v.z, 0.0f,

                        up.v.x, up.v.y, up.v.z, 0.0f,

                        0.0f, 0.0f, 0.0f, 1.0f}};

        

        return m;

}

 

 

CGPoint CGPointTransform(CGPoint a, CGAffineTransform m)

{

        CGPoint b;

        b.x = a.x*m.a + a.y*m.c + m.tx;

        b.y = a.x*m.b + a.y*m.d + m.ty;

        return b;

}

 

 

struct _bezierTransformerRec

{

        CGMutablePathRef                path;

        const CGAffineTransform m;

};

 

static void _pathTransformer(void *_info,

    const CGPathElement *element)

{

        struct _bezierTransformerRec* info = _info;

        CGMutablePathRef path = info->path;

 

        switch(element->type)

        {

                case kCGPathElementMoveToPoint:

                        CGPathMoveToPoint(path, &info->m, element->points[0].x, element->points[0].y);

                        break;

                case kCGPathElementAddLineToPoint:

                {

                        CGPathAddLineToPoint(path, &info->m, element->points[0].x, element->points[0].y);

                        break;

                }

                case kCGPathElementAddQuadCurveToPoint:

                {

                        CGPathAddQuadCurveToPoint(path, &info->m, element->points[0].x, element->points[0].y, element->points[1].x, element->points[1].y);

                        break;

                }

                case kCGPathElementAddCurveToPoint:

                {

                        CGPathAddCurveToPoint(path, &info->m, element->points[0].x, element->points[0].y, element->points[1].x, element->points[1].y, element->points[2].x, element->points[2].y);                      

                        break;

                }

                case kCGPathElementCloseSubpath:

                {

                        CGPathCloseSubpath(path);

                        break;

                }

        };

}

 

static void _pathTransformerM(void *_info,

    const CGPathElement *element)

{

        struct _bezierTransformerRec* info = _info;

        CGMutablePathRef path = info->path;

 

        switch(element->type)

        {

                case kCGPathElementMoveToPoint:

                {

                        CGPoint c0 = CGPointTransform(element->points[0], info->m);

                        CGPathMoveToPoint(path, NULL, c0.x, c0.y);

                        break;

                }

                case kCGPathElementAddLineToPoint:

                {

                        CGPoint c0 = CGPointTransform(element->points[0], info->m);

                        CGPathAddLineToPoint(path, NULL, c0.x, c0.y);

                        break;

                }

                case kCGPathElementAddQuadCurveToPoint:

                {

                        CGPoint c0 = CGPointTransform(element->points[0], info->m);

                        CGPoint c1 = CGPointTransform(element->points[1], info->m);

                        CGPathAddQuadCurveToPoint(path, NULL, c0.x, c0.y, c1.x, c1.y);

                        break;

                }

                case kCGPathElementAddCurveToPoint:

                {

                        CGPoint c0 = CGPointTransform(element->points[0], info->m);

                        CGPoint c1 = CGPointTransform(element->points[1], info->m);

                        CGPoint c2 = CGPointTransform(element->points[2], info->m);

                        CGPathAddCurveToPoint(path, NULL, c0.x, c0.y, c1.x, c1.y, c2.x, c2.y);                  

                        break;

                }

                case kCGPathElementCloseSubpath:

                {

                        CGPathCloseSubpath(path);

                        break;

                }

        };

}

 

 

CGPathRef CreateTransformedPathFromCGPath(CGPathRef cpath, CGAffineTransform m)

{

        struct _bezierTransformerRec rec = {CGPathCreateMutable(), m};

        CGPathApply(cpath, &rec, _pathTransformerM);

        

        return rec.path;

}