v2.0.2
|
|
v2.0.2
|
#import "CC3Environment.h"#import "CC3Math.h"#import "CC3Logging.h"#import "CC3CC2Extensions.h"#import "ccTypes.h"#import <CoreGraphics/CGColor.h>Classes | |
| struct | CC3AngularVector |
| struct | CC3AttenuationCoefficients |
| struct | CC3BarycentricWeights |
| struct | CC3Box |
| struct | CC3ColoredVertex |
| struct | CC3Face |
| struct | CC3FaceIndices |
| struct | CC3IntPoint |
| struct | CC3IntSize |
| struct | CC3IntVector |
| struct | CC3IntVector4 |
| struct | CC3LitColoredVertex |
| struct | CC3Plane |
| struct | CC3Ray |
| struct | CC3Sphere |
| struct | CC3TexturedVertex |
| struct | CC3Vector |
| struct | CC3Vector4 |
| union | CC3Viewport |
Macros | |
| #define | CC3_POP_NOSELECTOR _Pragma("GCC diagnostic pop") |
| #define | CC3_POP_NOSHADOW _Pragma("GCC diagnostic pop") |
| #define | CC3_PUSH_NOSELECTOR _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wselector\"") |
| #define | CC3_PUSH_NOSHADOW _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wshadow\"") |
| #define | cc3tc(U, V) CC3TexCoordsMake((U),(V)) |
| #define | cc3v(X, Y, Z) CC3VectorMake((X),(Y),(Z)) |
| #define | ccc4f(R, G, B, A) CCC4FMake((R),(G),(B),(A)) |
| #define | COCOS3D_VERSION 0x020002 |
| #define | kCC3BoundingBoxNull kCC3BoxNull |
| #define | kCC3BoundingBoxZero kCC3BoxZero |
Typedefs | |
| typedef CC3TexturedVertex CCTexturedVertex | __deprecated = { { {0.0, 0.0, 0.0} }, 1.0 } |
| typedef GLfloat | CC3Angle |
| typedef CC3IntPoint | CC3Tessellation |
Variables | |
| static const CC3AttenuationCoefficients | kCC3AttenuationNone = {1.0, 0.0, 0.0} |
| static const CC3Box | kCC3BoxNull = { {INFINITY, INFINITY, INFINITY}, {INFINITY, INFINITY, INFINITY} } |
| static const CC3Box | kCC3BoxZero = { {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0} } |
| static const CC3FaceIndices | kCC3FaceIndicesZero = { {0, 0, 0} } |
| static const CC3Face | kCC3FaceZero = { { { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 } } } |
| static const CC3IntPoint | kCC3IntPointZero = { 0, 0 } |
| static const CC3IntSize | kCC3IntSizeZero = { 0, 0 } |
| static const CC3Plane | kCC3PlaneZero = { 0, 0, 0, 0 } |
| static const CC3Quaternion | kCC3QuaternionIdentity = { { {0.0, 0.0, 0.0} }, 1.0 } |
| static const CC3Vector4 | kCC3QuaternionNull = { { {INFINITY, INFINITY, INFINITY} }, INFINITY} |
| static const CC3Quaternion | kCC3QuaternionZero = { { {0.0, 0.0, 0.0} }, 0.0 } |
| static GLfloat | kCC3ScaleMin = 1.0e-9f |
| static const CC3Vector4 | kCC3Vector4Null = { { {INFINITY, INFINITY, INFINITY} }, INFINITY} |
| static const CC3Vector4 | kCC3Vector4Zero = { { {0.0, 0.0, 0.0} }, 0.0 } |
| static const CC3Vector4 | kCC3Vector4ZeroLocation = { { {0.0, 0.0, 0.0} }, 1.0 } |
| static const CC3Vector | kCC3VectorNull = {INFINITY, INFINITY, INFINITY} |
| static const CC3Vector | kCC3VectorUnitCube = { 1.0, 1.0, 1.0 } |
| static const GLfloat | kCC3VectorUnitCubeLength = kCC3Sqrt3 |
| static const CC3Vector | kCC3VectorUnitXNegative = {-1.0, 0.0, 0.0 } |
| static const CC3Vector | kCC3VectorUnitXPositive = { 1.0, 0.0, 0.0 } |
| static const CC3Vector | kCC3VectorUnitYNegative = { 0.0, -1.0, 0.0 } |
| static const CC3Vector | kCC3VectorUnitYPositive = { 0.0, 1.0, 0.0 } |
| static const CC3Vector | kCC3VectorUnitZNegative = { 0.0, 0.0, -1.0 } |
| static const CC3Vector | kCC3VectorUnitZPositive = { 0.0, 0.0, 1.0 } |
| static const CC3Vector | kCC3VectorZero = { 0.0, 0.0, 0.0 } |
| static const CC3Viewport | kCC3ViewportZero = { {0, 0, 0, 0} } |
| static const ccColor4F | kCCC4FBlack = { 0.0, 0.0, 0.0, 1.0 } |
| static const ccColor4F | kCCC4FBlackTransparent = {0.0, 0.0, 0.0, 0.0} |
| static const ccColor4F | kCCC4FBlue = { 0.0, 0.0, 1.0, 1.0 } |
| static const ccColor4F | kCCC4FCyan = { 0.0, 1.0, 1.0, 1.0 } |
| static const ccColor4F | kCCC4FDarkGray = { 0.25, 0.25, 0.25, 1.0 } |
| static const ccColor4F | kCCC4FGray = { 0.5, 0.5, 0.5, 1.0 } |
| static const ccColor4F | kCCC4FGreen = { 0.0, 1.0, 0.0, 1.0 } |
| static const ccColor4F | kCCC4FLightGray = { 0.75, 0.75, 0.75, 1.0 } |
| static const ccColor4F | kCCC4FMagenta = { 1.0, 0.0, 1.0, 1.0 } |
| static const ccColor4F | kCCC4FOrange = { 1.0, 0.5, 0.0, 1.0 } |
| static const ccColor4F | kCCC4FRed = { 1.0, 0.0, 0.0, 1.0 } |
| static const ccColor4F | kCCC4FWhite = { 1.0, 1.0, 1.0, 1.0 } |
| static const ccColor4F | kCCC4FYellow = { 1.0, 1.0, 0.0, 1.0 } |
| #define CC3_POP_NOSELECTOR _Pragma("GCC diagnostic pop") |
Resume compiler warnings of unimplemented selectors.
| #define CC3_POP_NOSHADOW _Pragma("GCC diagnostic pop") |
Resume compiler warnings for hidden variable shadowing.
| #define CC3_PUSH_NOSELECTOR _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wselector\"") |
Temporarily turn off compiler warnings of unimplemented selectors.
| #define CC3_PUSH_NOSHADOW _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wshadow\"") |
Temporarily turn off compiler warnings for hidden variable shadowing.
| #define cc3tc | ( | U, | |
| V | |||
| ) | CC3TexCoordsMake((U),(V)) |
Convenience alias macro to create ccTex2F with less keystrokes.
| #define cc3v | ( | X, | |
| Y, | |||
| Z | |||
| ) | CC3VectorMake((X),(Y),(Z)) |
Convenience alias macro to create CC3Vectors with less keystrokes.
| #define ccc4f | ( | R, | |
| G, | |||
| B, | |||
| A | |||
| ) | CCC4FMake((R),(G),(B),(A)) |
Convenience alias macro to create ccColor4F with less keystrokes.
| #define COCOS3D_VERSION 0x020002 |
The version of Cocos3D, derived from the version format, where each of the HI.ME.LO components of the version is allocated two digits in this value, in the format HIMELO.
Examples:
| #define kCC3BoundingBoxNull kCC3BoxNull |
| #define kCC3BoundingBoxZero kCC3BoxZero |
| const CC3AttenuationCoefficients kCC3ParticleSizeAttenuationNone __deprecated = { { {0.0, 0.0, 0.0} }, 1.0 } |
Deprecated.
Use kCC3AttenuationNone instead.
| typedef GLfloat CC3Angle |
An angle such as a heading or inclination.
Can be measured in degrees or radians and may be positive or negative.
| typedef CC3IntPoint CC3Tessellation |
A struct representing an integer tessellation.
|
inlinestatic |
Returns the difference between two CC3AngularVectors, by subtracting the corresponding heading, inclination & radial components.
Note that this is NOT true vector arithmetic, which would yield a completely different angular and radial results.
|
inlinestatic |
Returns an CC3AngularVector providing the heading, inclination & radius of the specified CC3Vector.
Heading is measured in degrees, in the X-Z plane, clockwise from the negative Z-axis. Inclination is measured in degrees, with up being in the positive-Y direction.
|
inlinestatic |
Returns an CC3AngularVector structure constructed from the vector components.
|
inlinestatic |
Returns whether the two attenuation coefficents are equal by comparing their respective components.
|
inlinestatic |
If at least one of the coefficients in the specified attenuation is not zero, the specified attenuation coefficients is returned unchanged.
However, if all three coefficients of the specified attenuation coefficients are zero, the value is illegal (and will cause divide-by-zero errors, especially in shaders). If that is the case, this function returns kCC3AttenuationNone.
|
inlinestatic |
Returns a CC3AttenuationCoefficients structure constructed from the specified coefficients.
|
inlinestatic |
Converts the specified quaternion to a vector that represents a rotation in axis-angle form.
The X, Y & Z components of the returned vector contain the rotation axis, and the W component specifies the angle, in degrees.
|
inlinestatic |
Returns whether the specified barycentric weights indicate a location inside a triangle.
To be inside a triangle, none of the weights may be negative. If any of the weights are negative, the specified barycentric weights represent a location outside a triangle.
|
inlinestatic |
Returns a CC3BarycentricWeights structure constructed from the three specified weights.
|
inlinestatic |
Returns whether the two boolean values are in equal state.
This test will work if the two booleans each contain different non-zero content to indicate logical YES, whereas a simple == comparison would give an erroneous result in that situation.
| BOOL CC3BoundingBoxIsNull | ( | CC3Box | bb) |
| BOOL CC3BoundingBoxIsZero | ( | CC3Box | bb) |
| CC3Box CC3BoundingBoxMake | ( | GLfloat | minX, |
| GLfloat | minY, | ||
| GLfloat | minZ, | ||
| GLfloat | maxX, | ||
| GLfloat | maxY, | ||
| GLfloat | maxZ | ||
| ) |
Returns a bounding box that has the same dimensions as the specified bounding box, but with each corner expanded outward by the specified amount of padding.
The padding value is added to the maximum vector, and subtracted from the minimum vector.
Returns a box that has the same dimensions as the specified box, but with each corner expanded outward by the specified amount of padding.
The padding value is added to all three components of the maximum vector, and subtracted from all three components of the minimum vector.
Returns the geometric center of the specified bounding box.
Returns whether the specified bounding box contains the specified location.
Returns the smallest CC3Box that contains both the specified bounding box and location.
If the specified bounding box is null, returns a bounding box of zero size at the specified location.
Returns whether the two bounding boxes are equal by comparing their respective components.
Returns a CC3Box structure constructed from the min and max vertices.
|
inlinestatic |
Returns whether the specified bounding box is equal to the null bounding box, specified by kCC3BoxNull.
|
inlinestatic |
Returns whether the specified bounding box is equal to the zero bounding box, specified by kCC3BoxZero.
|
inlinestatic |
Returns a CC3Box structure constructed from the min and max components.
Returns a bounding box of the same size as the specified bounding box, and whose center lies at the origin of the coordinate system.
This effectivly moves the bounding box so that its center is at the origin.
Returns a bounding box constructed by scaling the specified bounding box by the specified scale value.
Scaling can be different along each axis of the box.
This has the effect of multiplying each component of each of the vectors representing the minimum and maximum corners of the box by the corresponding component in the scale vector.
Returns a bounding box constructed by scaling the specified bounding box by the specified scale value.
The same scaling is applied to each axis of the box.
This has the effect of multiplying each component of each of the vectors representing the minimum and maximum corners of the box by the scale value.
Returns the size of the specified bounding box, between the minimum to maximum corners.
Returns a box constructed by translating the specified box by the specified translation offset.
Returns a box constructed by translating the specified box by a translation that is a fraction of the box size, as determined by the specified offsetScale.
For example, a value of -0.2 in the X-component of the offsetScale, will move the box 20% of its dimension in the X-axis, in the direction of the negative X-axis.
Returns the smallest CC3Box that contains the two specified bounding boxes.
If either bounding box is the null bounding box, simply returns the other bounding box (which may also be the null bounding box).
Returns the distance from the specified location to the specified plane.
The distance is returned in terms of the length of the normal. If the normal is of unit length, then the distance is in absolute units.
Returns whether the specified ray intersects the specified sphere.
Returns whether the specified spheres intersect.
|
inlinestatic |
Ensures that the specified file path is absolute, converting it if necessary.
Relative paths are assumed to be relative to the application resources directory. If the specified file path is not already absolute, the path to that directory is prepended to it.
|
inlinestatic |
Ensures the specified value can be used as a component in a scale vector.
If the value is greater than kCC3ScaleMin or less than -kCC3ScaleMin, it is returned unchanced, otherwise either -kCC3ScaleMin or kCC3ScaleMin is returned, depending on whether the value is less than zero or not, respectively.
This is used to ensure that scales used in transforms do not cause uninvertable matrices.
Ensures the absolute value of each of the components in the specified scale vector is greater than kCC3ScaleMin.
Any component between -kCC3ScaleMin and kCC3ScaleMin is replaced with -kCC3ScaleMin or kCC3ScaleMin depending on whether the component is less than zero or not, respectively.
This can be used to ensure that scales used in transforms do not cause uninvertable matrices.
| CC3BarycentricWeights CC3FaceBarycentricWeights | ( | CC3Face | face, |
| CC3Vector | aLocation | ||
| ) |
Returns the barycentric weights for the specified location on the plane of the specified face.
The returned weights are specified in the same order as the vertices of the face.
The specified location should be on the plane of the specified face.
If the location is on the plane of the specified face, the three returned weights will add up to one. If all three of the returned weights are positive, then the location is inside the triangle defined by the face, otherwise, at least one of the returned weights will be negative.
Returns the location of the center of the specified face, calculated as the mathematical average of the three vertices that define the face.
|
inlinestatic |
Returns a CC3FaceIndices structure constructed from the three specified vertex indices, which should be supplied in winding order.
Returns a CC3Face structure that has the same vertices as the specified face, but in the opposite winding order.
|
inlinestatic |
Returns the 3D cartesian location on the specified face that corresponds to the specified barycentric coordinate weights.
Returns a CC3Face structure constructed from the three specified vectors, which should be supplied in winding order.
Returns a normalized normal vector derived from the location and winding order of the three vertices in the specified face.
The direction of the normal vector is affected by the winding order of the vertices in the face. The vertices should wind vertex[0] -> vertex[1] -> vertex[2]. The normal will point in the direction that has the three points winding in a counter-clockwise direction, according to a right-handed coordinate system. If the direction of the normal is important, be sure the winding order of the points in the face is correct.
Returns a CC3Plane structure that contains the points in the specified face.
The direction of the normal of the returned plane is dependent on the winding order of the face, which is taken to be vertex[0] -> vertex[1] -> vertex[2], and the normal will point in the direction that has the three points winding in a counter-clockwise direction, according to a right-handed coordinate system. If the direction of the normal is important, be sure the winding order of the points in the face is correct.
| void CC3FlipVertically | ( | GLubyte * | rowMajorData, |
| GLuint | rowCount, | ||
| GLuint | bytesPerRow | ||
| ) |
Reverses the order of the rows in the specified data block.
The transformation is performed in-place.
This function can be useful for vertically flipping the contents of a texture or image, which is a common requirement when transferring content data between an OpenGL texture and an iOS or OSX image. Or it may be used to reverse the order of the rows of any row-major memory structure.
The specified data block is assumed to be in row-major order, containing the specified number of rows, and with the specified number of bytes in each row. The total number of bytes in the data block must be at least (bytesPerRow * rowCount).
|
inlinestatic |
Returns a point representing the sum of the two specified points, by add their respective components.
|
inlinestatic |
Returns a CC3IntPoint structure constructed from the specified CGPoint.
|
inlinestatic |
Returns whether the specified point is zero, as specified by kCC3IntPointZero.
|
inlinestatic |
Returns a CC3IntPoint structure constructed from the vector components.
|
inlinestatic |
Returns whether the two points are equal by comparing their respective components.
|
inlinestatic |
Returns a CC3IntSize structure constructed from the specified CGSize.
|
inlinestatic |
Returns whether the specified size is zero, as specified by kCC3IntSizeZero.
|
inlinestatic |
Returns a CC3IntSize structure constructed from the dimensional components.
|
inlinestatic |
Returns whether the two sizes are equal by comparing their respective components.
|
inlinestatic |
Returns a CC3IntVector4 structure constructed from the vector components.
|
inlinestatic |
Returns whether the two vectors are equal by comparing their respective components.
|
inlinestatic |
Returns a CC3IntVector structure constructed from the vector components.
|
inlinestatic |
Returns whether the two vectors are equal by comparing their respective components.
|
inlinestatic |
Returns whether the specified bit in the specified bitfield is set to zero.
|
inlinestatic |
Returns whether the specified bit in the specified bitfield is set to one.
Returns whether the specified location lies on the specified ray.
Returns whether the specified location lies within the specified sphere.
|
inlinestatic |
Returns the luminosity of the specified color as calculated using the ITU-R BT.601 conversion for standard-definition television (SDTV):
luminosity = (0.299 * red) + (0.587 * green) + (0.114 * blue),
|
inlinestatic |
Returns the luminosity of the specified color as calculated using the ITU-R BT.709 conversion for high-definition television (HDTV):
luminosity = (0.2126 * red) + (0.7152 * green) + (0.0722 * blue),
Returns a CC3Plane structure that contains the specified locations.
The direction of the normal of the returned plane is dependent on the winding order of the three locations. Winding is done in the order the locations are specified (v1 -> v2 -> v3), and the normal will point in the direction that has the three locations winding in a counter-clockwise direction, according to a right-handed coordinate system. If the direction of the normal is important, be sure to specify the three points in the appropriate order.
Returns a CC3Plane that has the specified normal and intersects the specified location.
|
inlinestatic |
Returns whether the specified plane is equal to the zero plane, specified by kCC3PlaneZero.
|
inlinestatic |
Returns a CC3Plane structure constructed from the specified coefficients.
Returns a plane that is the negative of the specified plane in all dimensions, including D.
The returned plane represents a plane that is coincident with the specified plane, but whose normal points in the opposite direction.
Returns the normal of the plane, which is (a, b, c) from the planar equation.
Returns a normalized copy of the specified CC3Plane so that the length of its normal (a, b, c) is 1.0.
Returns whether the two planes are equal by comparing their respective components.
|
inlinestatic |
Returns a quaternion that is the conjugate of the specified quaterion.
The X, Y, Z dimensions are negated, but the W is not.
|
inlinestatic |
Returns the dot-product of the two given quaternions (q1 .
q2).
|
inlinestatic |
Converts the specified vector that represents an rotation in axis-angle form to the corresponding quaternion.
The X, Y & Z components of the incoming vector contain the rotation axis, and the W component specifies the angle, in degrees.
|
inlinestatic |
Returns a CC3Quaternion structure constructed from a 3D vector and a w component.
|
inlinestatic |
Returns a CC3Quaternion structure constructed from the specified GLKQuaternion structure.
Although CC3Quaternion has the same internal structure as GLKQuaternion, the structures may have different byte alignment requirements. Avoid casting directly between GLKQuaternion and CC3Quaternion, as this is not guaranteed to work reliably.
| CC3Quaternion CC3QuaternionFromRotation | ( | CC3Vector | aRotation) |
Converts the specified Euler angle rotational vector to a quaternion.
The specified rotation vector contains three Euler angles measured in degrees.
|
inlinestatic |
Returns the inverse of the specified quaterion.
The inverse of a quaternion is another quaternion such that multiplying a quaternion by its inverse results in the identity quaternion.
The returned inverse quaternion is calculated as the conjugate of the specified quaternion divided by the square of the length of the specified quaternion.
|
inlinestatic |
Returns whether the specified quaternion is equal to the null quaternion, specified by kCC3QuaternionNull.
|
inlinestatic |
Returns whether the specified quaternion is equal to the zero quaternion, specified by kCC3QuaternionZero.
|
inlinestatic |
Returns the scalar length (or magnitude) of the specified quaternion.
This is calculated as sqrt(x*x + y*y + z*z + w*w) and will always be positive.
|
inlinestatic |
Returns the square of the scalar length (or magnitude) of the specified quaternion.
This is calculated as (x*x + y*y + z*z + w*w) and will always be positive.
This function is useful for comparing vector sizes without having to run an expensive square-root calculation.
|
inlinestatic |
Returns a CC3Quaternion structure constructed from the vector components.
|
inlinestatic |
Returns the result of multiplying qL on the left by qR on the right.
This represents a concatenation of two rotations, so that a point rotated by the result is equivalent to the point being rotated first by qL and then by qR: (qL.qR).p == qR.(qL.p).
|
inlinestatic |
Returns a quaternion that is the negative of the specified quaterion in all dimensions, including W.
|
inlinestatic |
Returns a normalized copy of the specified quaternion so that its length is 1.0.
The w-component is also normalized.
|
inlinestatic |
Returns the specified vector rotated by the specified quaternion.
This uses a highly optimized version of the basic quaternion rotation equation: qvq(-1):
v' = v + 2 * cross(cross(v, q.v) + (q.w * v), q.v)
Derivation of this algorithm can be found in the following Wikipedia article: http://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Performance_comparisons which describes the algo in terms of a left-handed coordinate system. It has been modified here for the right-handed coordinate system of OpenGL.
The right-handed algo is also described here: http://twistedpairdevelopment.wordpress.com/2013/02/11/rotating-a-vector-by-a-quaternion-in-glsl/
A related algo can be found derived (for left-handed coordinates) here: http://mollyrocket.com/forums/viewtopic.php?t=833&sid=3a84e00a70ccb046cfc87ac39881a3d0
|
inlinestatic |
Returns whether the two quaterions are equal by comparing their respective components.
|
inlinestatic |
Returns the result of scaling the original quaternion by the corresponding scale factor uniformly along all axes.
| CC3Quaternion CC3QuaternionSlerp | ( | CC3Quaternion | q1, |
| CC3Quaternion | q2, | ||
| GLfloat | blendFactor | ||
| ) |
Returns a spherical linear interpolation between two quaternions, based on the blendFactor.
which should be between zero and one inclusive. The returned quaternion is calculated as q1 + (blendFactor * (q2 - q1)). If the blendFactor is either zero or one exactly, this function short-circuits to simply return q1 or q2 respectively.
Returns a CC3Ray structure constructed from the start location and direction vectors.
| CC3Vector4 CC3RayIntersectionWithBoundingBoxSide | ( | CC3Ray | aRay, |
| CC3Box | bb, | ||
| CC3Vector | sideNormal, | ||
| CC3Vector4 | prevHit | ||
| ) |
Returns the location that the specified ray intersects the specified bounding box, or returns kCC3VectorNull if the ray does not intersect the bounding box, or the bounding box is behind the ray.
The result takes into consideration the startLocation of the ray, and will return kCC3VectorNull if the bounding box is behind the startLocation, even if the line projecting back through the startLocation in the negative direction of the ray intersects the bounding box.
The ray may start inside the bounding box, and the exit location of the ray will be returned.
| CC3Vector4 CC3RayIntersectionWithBoxSide | ( | CC3Ray | aRay, |
| CC3Box | bb, | ||
| CC3Vector | sideNormal, | ||
| CC3Vector4 | prevHit | ||
| ) |
Returns the location that the specified ray intersects the specified bounding box, on the side of the bounding box that has the specified normal, but only if the intersection distance is less than the specified previous intersection location.
The distance measurement is specified in the W component of the returned 4D vector.
If the ray does not intersect the specified side of the bounding box, if the side is behind the ray, or if the intersection distance is larger than that for the specified previous intersection location is returned.
This method first creates the plane on which the side exists, finds the intersection of the ray and that plane, determines whether the intersection location is actually within the bounding box, and then tests whether the intersection distance is less than for the specified previous intersection.
| CC3Vector4 CC3RayIntersectionWithPlane | ( | CC3Ray | ray, |
| CC3Plane | plane | ||
| ) |
Returns the location of the point where the specified ray intersects the specified plane.
The returned result is a 4D vector, where the x, y & z components give the intersection location in 3D space, and the w component gives the distance from the startLocation of the ray to the intersection location, in multiples of the ray direction vector. If this value is negative, the intersection point is in the direction opposite to the direction of the ray.
If the ray is parallel to the plane, no intersection occurs, and the returned 4D vector will be equal to kCC3Vector4Null.
Returns the location that the specified ray intersects the specified sphere, or returns kCC3VectorNull if the ray does not intersect the sphere, or the sphere is behind the ray.
The result takes into consideration the startLocation of the ray, and will return kCC3VectorNull if the sphere is behind the startLocation, even if the line projecting back through the startLocation in the negative direction of the ray intersects the sphere.
The ray may start inside the sphere, in which case, the returned location represents the exit location of the ray.
|
inlinestatic |
Returns a CC3Ray structure constructed from the start location and direction components.
Returns the coefficients of the quadratic equation that describes the points of intersection between the specified ray and sphere.
Given the equation for a sphere at the origin: x*x + y*y + z*z = r*r, and the equation for a ray in the same frame of reference: p = s + tv, where s is the ray start, v is the ray direction, and p is a point on the ray, we can solve for the intersection points of the ray and sphere. The result is a quadratic equation in t: at*t + bt + c = 0, where: a = v*v, b = 2(s.v), and c = s*s - r*r.
The a, b and c elements of the returned CC3Plane structure contain the a, b and c coefficients of the quadratic equation, respectively. The d element of the returned CC3Plane structure contains the discriminant of the quadratic equation (d = b*b - 4ac).
The returned quadratic coefficients are not a plane. The CC3Plane structure is simply used for convenience.
Reference: Mathematics for 3D Game Programming and Computer Graphics, 3rd ed. book, by Eric Lengyel
|
inlinestatic |
Resolves the specified file path as one of:
This function checks for the existence of the file on each of the above paths, in order, and returns an absolute path to the first file located.
Since the paths are searched in the above order, the application can provide a resource file to override a standard Cocos3D library resource file by adding the file with the same name to the application bundle resource directory.
Returns nil if the file could not be located in on any of the paths above.
| CC3Vector CC3RotationFromQuaternion | ( | CC3Quaternion | aQuaternion) |
Converts the specified quaternion to a Euler angle rotational vector.
The returned rotation vector contains three Euler angles measured in degrees.
|
inlinestatic |
Sets the specified bit in the specified bitfield is to one if the specified value is YES, or to zero if the specified value is NO.
Returns a CC3Spere that circumscribes the specified box.
Returns a CC3Spere constructed from the specified center and radius.
Returns the smallest CC3Sphere that contains the two specified spheres.
|
inlinestatic |
Returns a CC3Tessellation structure constructed from the specified components.
|
inlinestatic |
Returns a ccTex2F structure constructed from the vector components.
Returns the instersection point of the three specified planes, or returns kCC3VectorNull if the planes do not intersect at a single point, which can occur if the planes are parallel, or if one plane is parallel to the line of intersection of the other two planes.
|
inlinestatic |
Returns the result of adding the two specified vectors, by adding the corresponding components of both vectors.
If one vector is a location (W=1) and the other is a direction (W=0), this can be thought of as a translation of the location in that direction.
|
inlinestatic |
Returns the difference between two vectors, by subtracting the subtrahend from the minuend, which is accomplished by subtracting each of the corresponding components.
If both vectors are locations (W=1), the result will be a direction (W=0).
|
inlinestatic |
Returns the dot-product of the two given vectors (v1 .
v2).
|
inlinestatic |
Returns a CC3Vector4 structure constructed from a 3D vector and a w component.
|
inlinestatic |
Returns a CC3Vector4 homogeneous coordinate constructed from a 3D direction.
The W component of the returned vector is set to 0.0.
|
inlinestatic |
Returns a CC3Vector4 structure constructed from the specified GLKVector4 structure.
Although CC3Vector4 has the same internal structure as GLKVector4, the structures may have different byte alignment requirements. Avoid casting directly between GLKVector4 and CC3Vector4, as this is not guaranteed to work reliably.
|
inlinestatic |
Returns a CC3Vector4 homogeneous coordinate constructed from a 3D location.
The W component of the returned vector is set to 1.0.
|
inlinestatic |
Returns a vector that is the negative of the specified homogeneous vector in the X, Y & Z axes.
The W component is left unchanged.
|
inlinestatic |
Returns the result of scaling the original vector by the corresponding scale factor uniformly along the X, Y & Z axes.
The W component is left unchanged.
Use this method for scaling 4D homgeneous coordinates.
|
inlinestatic |
If the specified homogeneous vector represents a location (w is not zero), returns a homoginized copy of the vector, by dividing each component by the w-component (including the w-component itself, leaving it with a value of one).
If the specified vector is a direction (w is zero), or is already homogenized (w is one) the vector is returned unchanged.
|
inlinestatic |
Returns whether the vector represents a direction, rather than a location.
It is directional if the w component is zero.
|
inlinestatic |
Returns whether the specified 4D homogeneous vector is in front of the specified normalized plane.
If the vector is a location (w = 1), being "in front" means the location is on the side of the plane from which the plane normal points.
If the vector is a direction (w = 0), being "in front" means that the direction points away from the plane on the same side of the plane as the normal points away from the plane.
|
inlinestatic |
Returns whether the vector represents a location, rather than a direction.
It is locational if the w component is not zero.
|
inlinestatic |
Returns whether the specified vector is equal to the null vector, specified by kCC3Vector4Null.
|
inlinestatic |
Returns whether the specified vector is equal to the zero vector, specified by kCC3Vector4Zero.
|
inlinestatic |
Returns the scalar length of the specified vector from the origin, including the w-component This is calculated as sqrt(x*x + y*y + z*z + w*w) and will always be positive.
|
inlinestatic |
Returns the square of the scalar length of the specified vector from the origin, including the w-component.
This is calculated as (x*x + y*y + z*z + w*w) and will always be positive.
This function is useful for comparing vector sizes without having to run an expensive square-root calculation.
|
inlinestatic |
Returns a CC3Vector4 structure constructed from the vector components.
|
inlinestatic |
Returns a vector that is the negative of the specified vector in all dimensions, including W.
|
inlinestatic |
Returns a normalized copy of the specified vector so that its length is 1.0.
The w-component is also normalized.
|
inlinestatic |
Returns whether the two vectors are equal by comparing their respective components.
|
inlinestatic |
Returns the result of scaling the original vector by the corresponding scale factor uniformly along all axes.
| CC3Vector4 CC3Vector4Slerp | ( | CC3Vector4 | v1, |
| CC3Vector4 | v2, | ||
| GLfloat | blendFactor | ||
| ) |
Returns the result of adding the two specified vectors, by adding the corresponding components of both vectors.
This can also be thought of as a translation of the first vector by the second.
Returns a vector that represents the average of the two specified vectors.
This is calculated by adding the two specified vectors and scaling the resulting sum vector by half.
The returned vector represents the midpoint between a line that joins the endpoints of the two specified vectors.
Returns the cross-product of the two given vectors (v1 x v2).
Returns the difference between two vectors, by subtracting the subtrahend from the minuend, which is accomplished by subtracting each of the corresponding x,y,z components.
Returns the positive scalar distance between the ends of the two specified vectors.
Returns the square of the scalar distance between the ends of the two specified vectors.
This function is useful for comparing vector distances without having to run an expensive square-root calculation.
Returns the dot-product of the two given vectors (v1 .
v2).
|
inlinestatic |
Returns a CC3Vector from the specified CC3AngularVector.
Heading is measured in degrees, in the X-Z plane, clockwise from the negative Z-axis. Inclination is measured in degrees, with up being in the positive-Y direction.
|
inlinestatic |
Returns a CC3Vector structure constructed from the specified GLKVector3 structure.
Although CC3Vector has the same internal structure as GLKVector3, the structures may have different byte alignment requirements. Avoid casting directly between GLKVector3 and CC3Vector, as this is not guaranteed to work reliably.
|
inlinestatic |
Returns a CC3Vector structure constructed from a CC3Vector4.
The CC3Vector4 is first homogenized (via CC3Vector4Homogenize), before copying the resulting x, y & z coordinates into the CC3Vector.
| CC3Vector CC3VectorFromQuaternion | ( | CC3Quaternion | q) |
| CC3Vector CC3VectorFromTruncatedCC3Vector4 | ( | CC3Vector4 | v) |
Returns a CC3Vector that is the inverse of the specified vector in all directions, such that scaling the original by the inverse using CC3VectorScale will result in a vector of unit dimension in each direction (1.0, 1.0, 1.0).
The result of this function is effectively calculated by dividing each component of the original vector into 1.0 (1.0/x, 1.0/y, 1.0/z). It is the responsibility of the caller to ensure that none of the components of the original is zero.
Returns whether the specified vector is in front of the specified normalized plane.
If the vector is a location, being "in front" means the location is on the side of the plane from which the plane normal points.
If the vector is a direction, being "in front" means that the direction points away from the plane on the same side of the plane as the normal points away from the plane.
|
inlinestatic |
Returns whether the specified vector is equal to the null vector, specified by kCC3VectorNull.
|
inlinestatic |
Returns whether the specified vector is equal to the zero vector, specified by kCC3VectorZero.
|
inlinestatic |
Returns the scalar length of the specified CC3Vector from the origin.
This is calculated as sqrt(x*x + y*y + z*z) and will always be positive.
|
inlinestatic |
Returns the square of the scalar length of the specified CC3Vector from the origin.
This is calculated as (x*x + y*y + z*z) and will always be positive.
This function is useful for comparing vector sizes without having to run an expensive square-root calculation.
Returns a linear interpolation between two vectors, based on the blendFactor.
which should be between zero and one inclusive. The returned value is calculated as v1 + (blendFactor * (v2 - v1)). If the blendFactor is either zero or one exactly, this method short-circuits to simply return v1 or v2 respectively.
|
inlinestatic |
Returns a CC3Vector structure constructed from the vector components.
Returns a vector whose components comprise the maximum value of each of the respective components of the two specfied vectors.
In general, do not expect this method to return one of the specified vectors, but a new vector, each of the components of which is the maximum value for that component between the two vectors.
Returns a vector whose components comprise the minimum value of each of the respective components of the two specfied vectors.
In general, do not expect this method to return one of the specified vectors, but a new vector, each of the components of which is the minimum value for that component between the two vectors.
Returns a vector that is the negative of the specified vector in all directions.
For vectors that represent directions, the returned vector points in the direction opposite to the original.
Returns a normalized copy of the specified CC3Vector so that its length is 1.0.
If the length is zero, the original vector (a zero vector) is returned.
| void CC3VectorOrthonormalize | ( | CC3Vector * | vectors, |
| GLuint | vectorCount | ||
| ) |
Orthonormalizes the specified array of vectors, using a Gram-Schmidt process, and returns the orthonormal results in the same array.
The vectorCount argument indicates the number of vectors in the vectors array argument.
Upon completion, each vector in the specfied array will be a unit vector that is orthagonal to all of the other vectors in the array.
The first vector in the array is used as the starting point for orthonormalization. Since the Gram-Schmidt process is biased towards the starting vector, if this function will be used repeatedly on the same set of vectors, it is recommended that the order of the vectors in the array be changed on each call to this function, to ensure that the starting bias be averaged across each of the vectors over the long term.
|
inlinestatic |
Orthonormalizes the specified array of three vectors, using a Gram-Schmidt process, and returns the orthonormal results in the same array.
The number of vectors in the specified array must be exactly three.
Upon completion, each vector in the specfied array will be a unit vector that is orthagonal to all of the other vectors in the array.
The first vector in the array is used as the starting point for orthonormalization. Since the Gram-Schmidt process is biased towards the starting vector, if this function will be used repeatedly on the same set of vectors, it is recommended that the order of the vectors in the array be changed on each call to this function, to ensure that the starting bias be averaged across each of the vectors over the long term.
|
inlinestatic |
Returns the difference between two rotation vectors, in terms of the minimal degrees, along each axis, required to travel between the two roations, given that rotations are cyclical with a period of 360 degrees.
The result may be positive or negative, but will always be between (+/-180 degrees).
For example, the difference between 350 and 10 will yield -20 (ie- the smallest change from 10 degrees to 350 degrees is -20 degrees) rather than +340 (from simple subtraction). Similarly, the difference between 10 and 350 will yield +20 (ie- the smallest change from 350 degrees to 10 degrees is +20 degrees) rather than -340 (from simple subtraction).
Returns a modulo version of the specifed rotation, so that each component is between (+/-360 degrees).
Returns whether the two vectors are equal by comparing their respective components.
Returns YES if the two vectors are either exactly parallel or exactly antiparallel.
Returns whether the two vectors are exactly perpendicular.
Returns the result of scaling the original vector by the corresponding scale vector.
Scaling can be different for each axis. This has the effect of multiplying each component of the vector by the corresponding component in the scale vector.
Returns the result of scaling the original vector by the corresponding scale factor uniformly along all axes.
|
inlinestatic |
Returns whether the specified point lies within the specified viewport.
A point is considered inside the viewport if its coordinates lie inside the viewport or on the minimum X or minimum Y edge.
|
inlinestatic |
Returns a CC3Viewport constructed from the specified CGRect.
|
inlinestatic |
Returns a CC3Viewport constructed from the specified origin and size.
|
inlinestatic |
Returns whether the specified viewport is equal to the zero viewport, specified by kCC3ViewportZero.
|
inlinestatic |
Returns a CC3Viewport structure constructed from the specified components.
|
inlinestatic |
Returns whether the two viewports are equal by comparing their respective components.
|
inlinestatic |
Returns a CC3Viewport of the same size as the specified viewport, but whose origin is translated from the origin of the specified viewport by the by the specified amount.
|
inlinestatic |
Returns whether the two colors are equal by comparing their respective components.
|
inlinestatic |
Returns an ccColor3B structure whose values are a weighted average of the specified base color and the blend color.
The parameter blendWeight should be between zero and one. A value of zero will leave the base color unchanged. A value of one will result in the blend being the same as the blend color.
|
inlinestatic |
Returns a ccColor3B structure constructed from the specified ccColor4B.
|
inlinestatic |
Returns a ccColor3B structure constructed from the specified ccColor4F.
|
inlinestatic |
Returns whether the two colors are equal by comparing their respective components.
|
inlinestatic |
Returns a ccColor4B color whose R, G & B components are those of the specified color multiplied by the alpha value of the specified color, clamping to the range between zero and 255 if needed.
The alpha value remains unchanged.
This function performs the same operation on the specified color that is known as pre-multiplied alpha when applied to the texels of a texture.
|
inlinestatic |
Returns a ccColor4B structure constructed from the specified ccColor4F.
|
inlinestatic |
Returns a ccColor4B structure constructed from the specified ccColor3B and opacity.
|
inlinestatic |
Returns the result of adding the two specified colors, by adding the corresponding components.
Each of the resulting color components is clamped to be between 0.0 and 1.0. This can also be thought of as a translation of the first color by the second.
|
inlinestatic |
Returns whether the two colors are equal by comparing their respective components.
|
inlinestatic |
Returns a ccColor4F structure whose values are a weighted average of the specified base color and the blend color.
The parameter blendWeight should be between zero and one. A value of zero will leave the base color unchanged. A value of one will result in the blend being the same as the blend color.
|
inlinestatic |
Returns a ccColor4F color whose R, G & B components are those of the specified color multiplied by the alpha value of the specified color, clamping to the range between zero and one if needed.
The alpha value remains unchanged.
This function performs the same operation on the specified color that is known as pre-multiplied alpha when applied to the texels of a texture.
|
inlinestatic |
Returns the difference between two colors, by subtracting the subtrahend from the minuend, which is accomplished by subtracting each of the corresponding r,g, b, a components.
Each of the resulting color components is clamped to be between 0.0 and 1.0.
|
inlinestatic |
Returns a ccColor4F structure constructed from the specified ccColor4B.
|
inlinestatic |
Returns a ccColor4F structure constructed from the specified CoreGraphics CGColorRef.
|
inlinestatic |
Returns a ccColor4F structure constructed from the specified ccColor3B and opacity.
|
inlinestatic |
Returns the intensity of the specified color, calculated as the arithmetic mean of the R, G & B components.
|
inlinestatic |
Returns a ccColor4F structure constructed from the specified components.
|
inlinestatic |
Returns the result of modulating the specified colors, by multiplying the corresponding components.
Each of the resulting color components is clamped to be between 0.0 and 1.0.
|
inlinestatic |
Returns a ccColor4F structure whose values are those of the specified original color, multiplied by the specified scaling factor.
Each of the resulting color components is clamped to be between 0.0 and 1.0.
|
inlinestatic |
Returns a ccColor4F structure whose values are those of the specified original color, where each color component has been translated by the specified offset.
Each of the resulting color components is clamped to be between 0.0 and 1.0.
|
inlinestatic |
Returns a GLubyte between 0 and 255 converted from the specified GLfloat value.
The specified float value is clamped to between 0 and 1 before conversion, so that the Glubyte does not overflow or underflow, which would create unexpected colors.
|
inlinestatic |
Returns a GLfloat between 0 and 1 converted from the specified GLubyte value between 0 and 255.
|
inlinestatic |
Returns a CGPoint structure constructed from the specified CC3IntPoint.
|
inlinestatic |
Returns a CGRect constructed from the specified viewport.
|
inlinestatic |
Returns a CGSize structure constructed from the specified CC3IntSize.
|
inlinestatic |
Returns a GLKQuaternion structure constructed from the specified CC3Quaternion structure.
Although GLKQuaternion has the same internal structure as CC3Quaternion, the structures may have different byte alignment requirements. Avoid casting directly between CC3Quaternion and GLKQuaternion, as this is not guaranteed to work reliably.
|
inlinestatic |
Returns a GLKVector3 structure constructed from the specified CC3Vector structure.
Although GLKVector3 has the same internal structure as CC3Vector, the structures may have different byte alignment requirements. Avoid casting directly between CC3Vector and GLKVector3, as this is not guaranteed to work reliably.
|
inlinestatic |
Returns a GLKVector4 structure constructed from the specified CC3Vector4 structure.
Although GLKVector4 has the same internal structure as CC3Vector4, the structures may have different byte alignment requirements. Avoid casting directly between CC3Vector4 and GLKVector4, as this is not guaranteed to work reliably.
|
inlinestatic |
Returns the string YES or NO, depending on the specified boolean value.
|
inlinestatic |
Returns a string description of the specified CC3AngularVector struct in the form "(heading, inclination, radius)".
|
inlinestatic |
Returns a string description of the specified CC3AttenuationCoefficients struct in the form "(a, b, c)".
|
inlinestatic |
Returns a string description of the specified NSStringFromCC3BarycentricWeights struct.
| NSString* NSStringFromCC3BoundingBox | ( | CC3Box | bb) |
|
inlinestatic |
Returns a string description of the specified CC3Box struct.
|
inlinestatic |
Returns a string description of the specified CC3Face struct.
|
inlinestatic |
Returns a string description of the specified CC3FaceIndices struct.
|
inlinestatic |
Returns a string description of the specified CC3IntPoint struct in the form "(x, y)".
|
inlinestatic |
Returns a string description of the specified CC3IntSize struct in the form "(width, height)".
|
inlinestatic |
Returns a string description of the specified CC3IntVector struct in the form "(x, y, z)".
|
inlinestatic |
Returns a string description of the specified CC3IntVector4 struct in the form "(x, y, z, w)".
|
inlinestatic |
Returns a string description of the specified CC3Plane struct in the form "(a, b, c, d)".
|
inlinestatic |
Returns a string description of the specified CC3Quaternion struct in the form "(x, y, z, w)".
|
inlinestatic |
Returns a string description of the specified CC3Ray struct.
|
inlinestatic |
Returns a string description of the specified sphere.
|
inlinestatic |
Returns a string description of the specified CC3Tessellation struct in the form "(x, y)".
|
inlinestatic |
Returns a string description of the specified textured vertex.
|
inlinestatic |
Returns a string description of the specified CC3Vector struct in the form "(x, y, z)".
|
inlinestatic |
Returns a string description of the specified CC3Vector4 struct in the form "(x, y, z, w)".
| NSString* NSStringFromCC3Vectors | ( | CC3Vector * | vectors, |
| GLuint | vectorCount | ||
| ) |
Returns a string description of the specified array of CC3Vector structs.
The vectorCount argument indicates the number of vectors in the vectors array argument.
Each vector in the array is output on a separate line in the result.
|
inlinestatic |
Returns a string describing the Cocos3D version.
|
inlinestatic |
Returns a string description of the specified CC3Viewport struct in the form "(x, y, w, h)".
|
inlinestatic |
Returns a string description of the specified ccColor3B in the form "(r, g, b)".
|
inlinestatic |
Returns a string description of the specified ccColor4B in the form "(r, g, b, a)".
|
inlinestatic |
Returns a string description of the specified ccColor4F in the form "(r, g, b, a)".
|
inlinestatic |
Returns a random ccColor4F where each component value between the specified min inclusive and the specified max exclusive.
This can be useful when creating particle systems.
|
static |
Attenuation coefficients corresponding to no attenuation with distance (constant size).
|
static |
The null bounding box.
It cannot be drawn, but is useful for marking an uninitialized bounding box.
|
static |
A CC3Box of zero origin and dimensions.
|
static |
A CC3FaceIndices with all vertices set to zero.
|
static |
A CC3Face with all vertices set to zero.
|
static |
A CC3IntPoint at the origin.
|
static |
A CC3IntSize of zero extent.
|
static |
An undefined plane.
|
static |
A CC3Quaternion that represents the identity quaternion.
|
static |
The null CC3Quaternion.
Useful for marking an uninitialized quaternion.
|
static |
A CC3Vector4 of zero length at the origin.
|
static |
Minimum acceptable absolute value for a scale transformation component.
This is used to ensure that scales used in transforms do not cause uninvertable matrices.
The initial value is 1.0e-9f. Set this to another value if appropriate.
|
static |
The null CC3Vector4.
It cannot be drawn, but is useful for marking an uninitialized vector.
|
static |
A CC3Vector4 of zero length at the origin.
|
static |
A CC3Vector4 location at the origin.
As a definite location, the W component is 1.0.
|
static |
The null CC3Vector.
It cannot be drawn, but is useful for marking an uninitialized vector.
|
static |
A CC3Vector with each component equal to one, representing the diagonal of a unit cube.
|
static |
The diagonal length of a unit cube.
|
static |
Unit vector pointing in the same direction as the negative X-axis.
|
static |
Unit vector pointing in the same direction as the positive X-axis.
|
static |
Unit vector pointing in the same direction as the negative Y-axis.
|
static |
Unit vector pointing in the same direction as the positive Y-axis.
|
static |
Unit vector pointing in the same direction as the negative Z-axis.
|
static |
Unit vector pointing in the same direction as the positive Z-axis.
|
static |
An empty or undefined viewport.
|
static |
Opaque Black.
|
static |
Transparent Black.
|
static |
Opaque Blue.
|
static |
Opaque Cyan.
|
static |
Opaque Dark Gray.
|
static |
Opaque Gray.
|
static |
Opaque Green.
|
static |
Opaque Light Gray.
|
static |
Opaque Magenta.
|
static |
Opaque Orange.
|
static |
Opaque Red.
|
static |
Opaque White.
|
static |
Opaque Yellow.