ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/kazmath/ray2.js

@@ -0,0 +1,163 @@
+/**
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+ Copyright (c) 2008, Luke Benstead.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ 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.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+
+cc.kmRay2 = function(start, dir){
+  this.start = start || new cc.kmVec2();
+    this.start = start || new cc.kmVec2();
+};
+
+cc.kmRay2Fill = function(ray, px, py,vx,vy){
+    ray.start.x = px;
+    ray.start.y = py;
+    ray.dir.x = vx;
+    ray.dir.y = vy;
+};
+
+cc.kmRay2IntersectLineSegment = function(ray, p1, p2, intersection){
+    var x1 = ray.start.x;
+    var y1 = ray.start.y;
+    var x2 = ray.start.x + ray.dir.x;
+    var y2 = ray.start.y + ray.dir.y;
+    var x3 = p1.x;
+    var y3 = p1.y;
+    var x4 = p2.x;
+    var y4 = p2.y;
+
+    var denom = (y4 -y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+    var ua, x, y;
+    //If denom is zero, the lines are parallel
+    if(denom > -cc.kmEpsilon && denom < cc.kmEpsilon) {
+        return cc.KM_FALSE;
+    }
+
+    ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom;
+//    var ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denom;
+
+    x = x1 + ua * (x2 - x1);
+    y = y1 + ua * (y2 - y1);
+
+    if(x < cc.kmMin(p1.x, p2.x) - cc.kmEpsilon ||
+        x > cc.kmMax(p1.x, p2.x) + cc.kmEpsilon ||
+        y < cc.kmMin(p1.y, p2.y) - cc.kmEpsilon ||
+        y > cc.kmMax(p1.y, p2.y) + cc.kmEpsilon) {
+        //Outside of line
+        //printf("Outside of line, %f %f (%f %f)(%f, %f)\n", x, y, p1.x, p1.y, p2.x, p2.y);
+        return cc.KM_FALSE;
+    }
+
+    if(x < cc.kmMin(x1, x2) - cc.kmEpsilon ||
+        x > cc.kmMax(x1, x2) + cc.kmEpsilon ||
+        y < cc.kmMin(y1, y2) - cc.kmEpsilon ||
+        y > cc.kmMax(y1, y2) + cc.kmEpsilon) {
+        //printf("Outside of ray, %f %f (%f %f)(%f, %f)\n", x, y, x1, y1, x2, y2);
+        return cc.KM_FALSE;
+    }
+
+    intersection.x = x;
+    intersection.y = y;
+
+    return cc.KM_TRUE;
+};
+
+cc.calculate_line_normal = function(p1, p2, normal_out){
+    var tmp = new cc.kmVec2();
+    cc.kmVec2Subtract(tmp, p2, p1); //Get direction vector
+
+    normal_out.x = -tmp.y;
+    normal_out.y = tmp.x;
+    cc.kmVec2Normalize(normal_out, normal_out);
+
+    //TODO: should check that the normal is pointing out of the triangle
+};
+
+cc.kmRay2IntersectTriangle = function(ray, p1, p2, p3, intersection, normal_out){
+    var intersect = new cc.kmVec2();
+    var final_intersect = new cc.kmVec2();
+    var  normal = new cc.kmVec2();
+    var distance = 10000.0;
+    var intersected = cc.KM_FALSE;
+
+    var tmp,this_distance;
+
+    if(cc.kmRay2IntersectLineSegment(ray, p1, p2, intersect)) {
+        tmp = new cc.kmVec2();
+
+        intersected = cc.KM_TRUE;
+        this_distance = cc.kmVec2Length(cc.kmVec2Subtract(tmp, intersect, ray.start));
+        if(this_distance < distance) {
+            final_intersect.x = intersect.x;
+            final_intersect.y = intersect.y;
+            distance = this_distance;
+
+            cc.calculate_line_normal(p1, p2, normal);
+        }
+    }
+
+    if(cc.kmRay2IntersectLineSegment(ray, p2, p3, intersect)) {
+        tmp = new cc.kmVec2();
+        intersected = cc.KM_TRUE;
+
+        this_distance = cc.kmVec2Length(cc.kmVec2Subtract(tmp, intersect, ray.start));
+        if(this_distance < distance) {
+            final_intersect.x = intersect.x;
+            final_intersect.y = intersect.y;
+            distance = this_distance;
+
+            cc.calculate_line_normal(p2, p3, normal);
+        }
+    }
+
+    if(cc.kmRay2IntersectLineSegment(ray, p3, p1, intersect)) {
+        tmp = new cc.kmVec2();
+        intersected = cc.KM_TRUE;
+
+        this_distance = cc.kmVec2Length(cc.kmVec2Subtract(tmp, intersect, ray.start));
+        if(this_distance < distance) {
+            final_intersect.x = intersect.x;
+            final_intersect.y = intersect.y;
+            distance = this_distance;
+
+            cc.calculate_line_normal(p3, p1, normal);
+        }
+    }
+
+    if(intersected) {
+        intersection.x = final_intersect.x;
+        intersection.y = final_intersect.y;
+        if(normal_out) {
+            normal_out.x = normal.x;
+            normal_out.y = normal.y;
+        }
+    }
+
+    return intersected;
+};
+
+cc.kmRay2IntersectCircle = function(ray, centre, radius, intersection) {
+    cc.log("cc.kmRay2IntersectCircle() has not been implemented.");
+};

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/kazmath/utility.js

@@ -0,0 +1,76 @@
+/**
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+ Copyright (c) 2008, Luke Benstead.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ 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.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+
+/**
+ * @ignore
+ */
+cc.kmScalar = Number;
+
+cc.kmBool = Number;
+
+cc.kmEnum = Number;
+
+cc.KM_FALSE = 0;
+
+cc.KM_TRUE = 1;
+
+cc.kmPI = 3.141592;
+
+cc.kmPIOver180 = 0.017453;
+
+cc.kmPIUnder180 = 57.295779;
+
+cc.kmEpsilon = 1.0 / 64.0;
+
+/**
+ * Returns the square of s (e.g. s*s)
+ * @param {Number} s
+ */
+cc.kmSQR = function(s){
+    return s*s;
+};
+
+cc.kmDegreesToRadians = function(degrees){
+    return degrees * cc.kmPIOver180;
+};
+
+cc.kmRadiansToDegrees = function(radians){
+    return radians * cc.kmPIUnder180;
+};
+
+cc.kmMin = function(lhs,rhs){
+    return (lhs < rhs)? lhs : rhs;
+};
+
+cc.kmMax = function(lhs,rhs){
+    return (lhs > rhs)? lhs : rhs;
+};
+
+cc.kmAlmostEqual = function(lhs,rhs){
+    return (lhs + cc.kmEpsilon > rhs && lhs - cc.kmEpsilon < rhs);
+};

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/kazmath/vec2.js

@@ -0,0 +1,107 @@
+/**
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+ Copyright (c) 2008, Luke Benstead.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ 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.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+
+cc.kmVec2 = function (x, y) {
+    this.x = x || 0;
+    this.y = y || 0;
+};
+
+cc.kmVec2Fill = function (pOut, x, y) {
+    pOut.x = x;
+    pOut.y = y;
+    return pOut;
+};
+
+cc.kmVec2Length = function (pIn) {
+    return Math.sqrt(cc.kmSQR(pIn.x) + cc.kmSQR(pIn.y));
+};
+
+cc.kmVec2LengthSq = function (pIn) {
+    return cc.kmSQR(pIn.x) + cc.kmSQR(pIn.y);
+};
+
+cc.kmVec2Normalize = function (pOut, pIn) {
+    var l = 1.0 / cc.kmVec2Length(pIn);
+
+    var v = new cc.kmVec2();
+    v.x = pIn.x * l;
+    v.y = pIn.y * l;
+
+    pOut.x = v.x;
+    pOut.y = v.y;
+
+    return pOut;
+};
+
+cc.kmVec2Add = function (pOut, pV1, pV2) {
+    pOut.x = pV1.x + pV2.x;
+    pOut.y = pV1.y + pV2.y;
+
+    return pOut
+};
+
+cc.kmVec2Dot = function (pV1, pV2) {
+    return pV1.x * pV2.x + pV1.y * pV2.y;
+};
+
+cc.kmVec2Subtract = function (pOut, pV1, pV2) {
+    pOut.x = pV1.x - pV2.x;
+    pOut.y = pV1.y - pV2.y;
+
+    return pOut;
+};
+
+cc.kmVec2Transform = function (pOut, pV, pM) {
+    var v= new cc.kmVec2();
+
+    v.x = pV.x * pM.mat[0] + pV.y * pM.mat[3] + pM.mat[6];
+    v.y = pV.x * pM.mat[1] + pV.y * pM.mat[4] + pM.mat[7];
+
+    pOut.x = v.x;
+    pOut.y = v.y;
+
+    return pOut;
+};
+
+cc.kmVec2TransformCoord = function (pOut, pV, pM) {
+    return null;
+};
+
+cc.kmVec2Scale = function (pOut, pIn, s) {
+    pOut.x = pIn.x * s;
+    pOut.y = pIn.y * s;
+
+    return pOut;
+};
+
+cc.kmVec2AreEqual = function (p1, p2) {
+    return (
+        (p1.x < p2.x + cc.kmEpsilon && p1.x > p2.x - cc.kmEpsilon) &&
+            (p1.y < p2.y + cc.kmEpsilon && p1.y > p2.y - cc.kmEpsilon)
+        );
+};

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/kazmath/vec3.js

@@ -0,0 +1,205 @@
+/**
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+ Copyright (c) 2008, Luke Benstead.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ 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.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+
+cc.kmVec3 = function (x, y, z) {
+    this.x = x || 0;
+    this.y = y || 0;
+    this.z = z || 0;
+};
+
+cc.kmVec3Fill = function(pOut, x, y , z){
+    if(!pOut)
+        return new cc.kmVec3(x, y , z);
+    pOut.x = x;
+    pOut.y = y;
+    pOut.z = z;
+    return pOut;
+};
+
+cc.kmVec3Length = function(pIn){
+    return Math.sqrt(cc.kmSQR(pIn.x) + cc.kmSQR(pIn.y) + cc.kmSQR(pIn.z));
+};
+
+cc.kmVec3LengthSq = function(pIn){
+    return cc.kmSQR(pIn.x) + cc.kmSQR(pIn.y) + cc.kmSQR(pIn.z)
+} ;
+
+cc.kmVec3Normalize = function(pOut,pIn){
+    var l = 1.0 / cc.kmVec3Length(pIn);
+
+    pOut.x = pIn.x * l;
+    pOut.y = pIn.y * l;
+    pOut.z = pIn.z * l;
+    return pOut;
+};
+
+cc.kmVec3Cross = function(pOut, pV1,pV2){
+    pOut.x = (pV1.y * pV2.z) - (pV1.z * pV2.y);
+    pOut.y = (pV1.z * pV2.x) - (pV1.x * pV2.z);
+    pOut.z = (pV1.x * pV2.y) - (pV1.y * pV2.x);
+    return pOut;
+};
+
+cc.kmVec3Dot = function(pV1, pV2){
+    return (  pV1.x * pV2.x
+        + pV1.y * pV2.y
+        + pV1.z * pV2.z );
+} ;
+
+cc.kmVec3Add = function(pOut, pV1, pV2){
+    pOut.x = pV1.x + pV2.x;
+    pOut.y = pV1.y + pV2.y;
+    pOut.z = pV1.z + pV2.z;
+    return pOut;
+};
+
+cc.kmVec3Subtract = function(pOut, pV1, pV2){
+    pOut.x = pV1.x - pV2.x;
+    pOut.y = pV1.y - pV2.y;
+    pOut.z = pV1.z - pV2.z;
+    return pOut;
+};
+
+cc.kmVec3Transform = function(pOut, pV, pM){
+    /*
+     a = (Vx, Vy, Vz, 1)
+     b = (a×M)T
+     Out = (bx, by, bz)
+     */
+    pOut.x = pV.x * pM.mat[0] + pV.y * pM.mat[4] + pV.z * pM.mat[8] + pM.mat[12];
+    pOut.y = pV.x * pM.mat[1] + pV.y * pM.mat[5] + pV.z * pM.mat[9] + pM.mat[13];
+    pOut.z = pV.x * pM.mat[2] + pV.y * pM.mat[6] + pV.z * pM.mat[10] + pM.mat[14];
+    return pOut;
+};
+
+cc.kmVec3TransformNormal = function(pOut, pV, pM){
+    /*
+     a = (Vx, Vy, Vz, 0)
+     b = (a×M)T
+     Out = (bx, by, bz)
+     */
+    //Omits the translation, only scaling + rotating
+    pOut.x = pV.x * pM.mat[0] + pV.y * pM.mat[4] + pV.z * pM.mat[8];
+    pOut.y = pV.x * pM.mat[1] + pV.y * pM.mat[5] + pV.z * pM.mat[9];
+    pOut.z = pV.x * pM.mat[2] + pV.y * pM.mat[6] + pV.z * pM.mat[10];
+    return pOut;
+};
+
+cc.kmVec3TransformCoord = function(pOut,pV,pM){
+    /*
+     a = (Vx, Vy, Vz, 1)
+     b = (a×M)T
+     Out = 1⁄bw(bx, by, bz)
+     */
+    var v = new cc.kmVec4();
+    var inV = new cc.kmVec4();
+    cc.kmVec4Fill(inV, pV.x, pV.y, pV.z, 1.0);
+
+    cc.kmVec4Transform(v, inV,pM);
+
+    pOut.x = v.x / v.w;
+    pOut.y = v.y / v.w;
+    pOut.z = v.z / v.w;
+
+    return pOut;
+};
+
+cc.kmVec3Scale = function(pOut, pIn, s){
+    pOut.x = pIn.x * s;
+    pOut.y = pIn.y * s;
+    pOut.z = pIn.z * s;
+
+    return pOut;
+};
+
+cc.kmVec3AreEqual = function(p1, p2){
+    if ((p1.x < (p2.x + cc.kmEpsilon) && p1.x > (p2.x - cc.kmEpsilon)) &&
+        (p1.y < (p2.y + cc.kmEpsilon) && p1.y > (p2.y - cc.kmEpsilon)) &&
+        (p1.z < (p2.z + cc.kmEpsilon) && p1.z > (p2.z - cc.kmEpsilon))) {
+        return 1;
+    }
+
+    return 0;
+};
+
+cc.kmVec3InverseTransform = function(pOut, pVect,pM){
+    var v1 = new cc.kmVec3(pVect.x - pM.mat[12], pVect.y - pM.mat[13],pVect.z - pM.mat[14]);
+
+    pOut.x = v1.x * pM.mat[0] + v1.y * pM.mat[1] + v1.z * pM.mat[2];
+    pOut.y = v1.x * pM.mat[4] + v1.y * pM.mat[5] + v1.z * pM.mat[6];
+    pOut.z = v1.x * pM.mat[8] + v1.y * pM.mat[9] + v1.z * pM.mat[10];
+
+    return pOut;
+};
+
+cc.kmVec3InverseTransformNormal = function(pOut, pVect, pM){
+    pOut.x = pVect.x * pM.mat[0] + pVect.y * pM.mat[1] + pVect.z * pM.mat[2];
+    pOut.y = pVect.x * pM.mat[4] + pVect.y * pM.mat[5] + pVect.z * pM.mat[6];
+    pOut.z = pVect.x * pM.mat[8] + pVect.y * pM.mat[9] + pVect.z * pM.mat[10];
+
+    return pOut;
+};
+
+cc.kmVec3Assign = function(pOut,pIn){
+    if (pOut == pIn)
+        return pOut;
+
+    pOut.x = pIn.x;
+    pOut.y = pIn.y;
+    pOut.z = pIn.z;
+    return pOut;
+};
+
+cc.kmVec3Zero = function(pOut){
+    pOut.x = 0.0;
+    pOut.y = 0.0;
+    pOut.z = 0.0;
+
+    return pOut;
+};
+
+cc.kmVec3ToTypeArray = function(vecValue){
+    if(!vecValue)
+        return null;
+
+    var tyArr = new Float32Array(3);
+    tyArr[0] = vecValue.x;
+    tyArr[1] = vecValue.y;
+    tyArr[2] = vecValue.z;
+    return tyArr;
+};
+
+
+
+
+
+
+
+
+
+

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/kazmath/vec4.js

@@ -0,0 +1,158 @@
+/**
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+ Copyright (c) 2008, Luke Benstead.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ 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.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+
+cc.kmVec4 = function (x, y, z, w) {
+    this.x = x || 0;
+    this.y = y || 0;
+    this.z = z || 0;
+    this.w = w || 0;
+};
+
+
+cc.kmVec4Fill = function(outVec, x, y ,z, w){
+    outVec.x = x;
+    outVec.y = y;
+    outVec.z = z;
+    outVec.w = w;
+    return outVec;
+};
+
+cc.kmVec4Add = function(outVec, pV1, pV2){
+    outVec.x = pV1.x + pV2.x;
+    outVec.y = pV1.y + pV2.y;
+    outVec.z = pV1.z + pV2.z;
+    outVec.w = pV1.w + pV2.w;
+
+    return outVec;
+};
+
+cc.kmVec4Dot = function( vec1, vec2){
+    return (  vec1.x * vec2.x
+        + vec1.y * vec2.y
+        + vec1.z * vec2.z
+        + vec1.w * vec2.w );
+};
+
+cc.kmVec4Length = function(inVec){
+    return Math.sqrt(cc.kmSQR(inVec.x) + cc.kmSQR(inVec.y) + cc.kmSQR(inVec.z) + cc.kmSQR(inVec.w));
+};
+
+cc.kmVec4LengthSq = function(inVec){
+    return cc.kmSQR(inVec.x) + cc.kmSQR(inVec.y) + cc.kmSQR(inVec.z) + cc.kmSQR(inVec.w);
+};
+
+cc.kmVec4Lerp = function(outVec, pV1, pV2, t){
+    return outVec;
+};
+
+cc.kmVec4Normalize = function(outVec, inVec){
+    var l = 1.0 / cc.kmVec4Length(inVec);
+
+    outVec.x *= l;
+    outVec.y *= l;
+    outVec.z *= l;
+    outVec.w *= l;
+
+    return outVec;
+};
+
+cc.kmVec4Scale = function(outVec, inVec, scale){
+    cc.kmVec4Normalize(outVec, inVec);
+
+    outVec.x *= scale;
+    outVec.y *= scale;
+    outVec.z *= scale;
+    outVec.w *= scale;
+    return outVec;
+};
+
+cc.kmVec4Subtract = function(outVec,vec1, vec2){
+    outVec.x = vec1.x - vec2.x;
+    outVec.y = vec1.y - vec2.y;
+    outVec.z = vec1.z - vec2.z;
+    outVec.w = vec1.w - vec2.w;
+
+    return outVec;
+};
+
+cc.kmVec4Transform = function(outVec, vec,mat4Obj){
+    outVec.x = vec.x * mat4Obj.mat[0] + vec.y * mat4Obj.mat[4] + vec.z * mat4Obj.mat[8] + vec.w * mat4Obj.mat[12];
+    outVec.y = vec.x * mat4Obj.mat[1] + vec.y * mat4Obj.mat[5] + vec.z * mat4Obj.mat[9] + vec.w * mat4Obj.mat[13];
+    outVec.z = vec.x * mat4Obj.mat[2] + vec.y * mat4Obj.mat[6] + vec.z * mat4Obj.mat[10] + vec.w * mat4Obj.mat[14];
+    outVec.w = vec.x * mat4Obj.mat[3] + vec.y * mat4Obj.mat[7] + vec.z * mat4Obj.mat[11] + vec.w * mat4Obj.mat[15];
+    return outVec;
+};
+
+cc.kmVec4TransformArray = function(outVec,outStride,vecObj,stride,mat4Obj,count){
+    var i = 0;
+    //Go through all of the vectors
+    while (i < count) {
+        var currIn = vecObj + (i * stride); //Get a pointer to the current input
+        var out = outVec + (i * outStride); //and the current output
+        cc.kmVec4Transform(out, currIn, mat4Obj); //Perform transform on it
+        ++i;
+    }
+
+    return outVec;
+};
+
+cc.kmVec4AreEqual = function(vec1,vec2){
+    return (
+        (vec1.x < vec2.x + cc.kmEpsilon && vec1.x > vec2.x - cc.kmEpsilon) &&
+            (vec1.y < vec2.y + cc.kmEpsilon && vec1.y > vec2.y - cc.kmEpsilon) &&
+            (vec1.z < vec2.z + cc.kmEpsilon && vec1.z > vec2.z - cc.kmEpsilon) &&
+            (vec1.w < vec2.w + cc.kmEpsilon && vec1.w > vec2.w - cc.kmEpsilon)
+        );
+};
+
+cc.kmVec4Assign = function(destVec, srcVec){
+    if(destVec == srcVec){
+        cc.log("destVec and srcVec are same object");
+        return destVec;
+    }
+
+    destVec.x = srcVec.x;
+    destVec.y = srcVec.y;
+    destVec.z = srcVec.z;
+    destVec.w = srcVec.w;
+
+    return destVec;
+};
+
+cc.kmVec4ToTypeArray = function(vecValue){
+    if(!vecValue)
+        return null;
+
+    var tyArr = new Float32Array(4);
+    tyArr[0] = vecValue.x;
+    tyArr[1] = vecValue.y;
+    tyArr[2] = vecValue.z;
+    tyArr[3] = vecValue.w;
+    return tyArr;
+};
+