f8f60_len_1560.c File Reference

Go to the source code of this file.

Enumerations
enum	{   LERP_VAR_0 = 0x0 , LERP_VAR_1 = 0x1 , LERP_VAR_B = 0xB , LERP_VAR_C = 0xC ,   LERP_VAR_D = 0xD , LERP_VAR_E = 0xE , LERP_VAR_F = 0xF }

Functions
void	load_path_data (s32 num, f32 *normalizedLengths, Vec3f *pathPositions, Vec3f *outVectors)
void	get_path_position (f32 alpha, Vec3f *outPos, s32 numVectors, f32 *normalizedLengths, Vec3f *pathPoints, Vec3f *vectors)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
LERP_VAR_0
LERP_VAR_1
LERP_VAR_B
LERP_VAR_C
LERP_VAR_D
LERP_VAR_E
LERP_VAR_F

Definition at line 5 of file f8f60_len_1560.c.

     {
    LERP_VAR_0 = 0x0, // (out float) cur
    LERP_VAR_1 = 0x1, // (out bool) in-progress
    LERP_VAR_B = 0xB, // mode
    LERP_VAR_C = 0xC, // start
    LERP_VAR_D = 0xD, // end
    LERP_VAR_E = 0xE, // elapsed
    LERP_VAR_F = 0xF, // duration
};

Function Documentation

load_path_data()

void load_path_data	(	s32	num,
		f32 *	normalizedLengths,
		Vec3f *	pathPositions,
		Vec3f *	outVectors )

Definition at line 290 of file f8f60_len_1560.c.

                                                                                              {
    f32* lenBuf = heap_malloc(num * sizeof(f32));
    Vec3f* vecBuf = heap_malloc(num * sizeof(Vec3f));
    s32 i;
 
    // compute the distance of each vector along the path and map to the range [0,1]
    normalizedLengths[0] = 0.0f;
    for (i = 1; i < num; i++) {
        f32 dx = pathPositions[i].x - pathPositions[i-1].x;
        f32 dy = pathPositions[i].y - pathPositions[i-1].y;
        f32 dz = pathPositions[i].z - pathPositions[i-1].z;
        f32 length = sqrtf(SQ(dx) + SQ(dy) + SQ(dz));
        normalizedLengths[i] = normalizedLengths[i-1] + length;
    }
    for (i = 1; i < num; i++) {
        normalizedLengths[i] /= normalizedLengths[num-1];
    }
 
    // end points
    outVectors[0].x = 0.0f;
    outVectors[0].y = 0.0f;
    outVectors[0].z = 0.0f;
    outVectors[num-1].x = 0.0f;
    outVectors[num-1].y = 0.0f;
    outVectors[num-1].z = 0.0f;
 
    for (i = 0; i < num - 1; i++) {
        lenBuf[i] = normalizedLengths[i+1] - normalizedLengths[i];
        vecBuf[i+1].x = (pathPositions[i+1].x - pathPositions[i].x) / lenBuf[i];
        vecBuf[i+1].y = (pathPositions[i+1].y - pathPositions[i].y) / lenBuf[i];
        vecBuf[i+1].z = (pathPositions[i+1].z - pathPositions[i].z) / lenBuf[i];
    }
 
    // n = 1
    outVectors[1].x = vecBuf[2].x - vecBuf[1].x;
    outVectors[1].y = vecBuf[2].y - vecBuf[1].y;
    outVectors[1].z = vecBuf[2].z - vecBuf[1].z;
    vecBuf[1].x = 2.0f * (normalizedLengths[2] - normalizedLengths[0]);
    vecBuf[1].y = 2.0f * (normalizedLengths[2] - normalizedLengths[0]);
    vecBuf[1].z = 2.0f * (normalizedLengths[2] - normalizedLengths[0]);
 
    // 1 < n < N - 2
    for (i = 1; i < num - 2; i++) {
        f32 sx = lenBuf[i] / vecBuf[i].x;
        f32 sy = lenBuf[i] / vecBuf[i].y;
        f32 sz = lenBuf[i] / vecBuf[i].z;
        outVectors[i+1].x = (vecBuf[i+2].x - vecBuf[i+1].x) - outVectors[i].x * sx;
        outVectors[i+1].y = (vecBuf[i+2].y - vecBuf[i+1].y) - outVectors[i].y * sy;
        outVectors[i+1].z = (vecBuf[i+2].z - vecBuf[i+1].z) - outVectors[i].z * sz;
        vecBuf[i+1].x = 2.0f * (normalizedLengths[i+2] - normalizedLengths[i]) - lenBuf[i] * sx;
        vecBuf[i+1].y = 2.0f * (normalizedLengths[i+2] - normalizedLengths[i]) - lenBuf[i] * sy;
        vecBuf[i+1].z = 2.0f * (normalizedLengths[i+2] - normalizedLengths[i]) - lenBuf[i] * sz;
    }
 
    // n = N - 2
    outVectors[num-2].x -= (lenBuf[num-2] * outVectors[num-1].x);
    outVectors[num-2].y -= (lenBuf[num-2] * outVectors[num-1].y);
    outVectors[num-2].z -= (lenBuf[num-2] * outVectors[num-1].z);
 
    for (i = num - 2; i > 0; i--) {
        outVectors[i].x = (outVectors[i].x - (lenBuf[i] * outVectors[i+1].x)) / vecBuf[i].x;
        outVectors[i].y = (outVectors[i].y - (lenBuf[i] * outVectors[i+1].y)) / vecBuf[i].y;
        outVectors[i].z = (outVectors[i].z - (lenBuf[i] * outVectors[i+1].z)) / vecBuf[i].z;
    }
 
    heap_free(lenBuf);
    heap_free(vecBuf);
}

get_path_position()

void get_path_position	(	f32	alpha,
		Vec3f *	outPos,
		s32	numVectors,
		f32 *	normalizedLengths,
		Vec3f *	pathPoints,
		Vec3f *	vectors )

Definition at line 359 of file f8f60_len_1560.c.

                                                                                                                            {
    s32 limit = numVectors - 1;
    f32 curLength;
    f32 curProgress;
    f32 ax, ay, az, bx, by, bz, dx, dy, dz;
    s32 i;
 
    for (i = 0; i < limit;) {
        s32 temp_v1 = (i + limit) / 2;
 
        if (normalizedLengths[temp_v1] < alpha) {
            i = temp_v1 + 1;
        } else {
            limit = temp_v1;
        }
    }
 
    if (i > 0) {
        i--;
    }
 
    curLength = normalizedLengths[i+1] - normalizedLengths[i];
    curProgress = alpha - normalizedLengths[i];
 
    dx = (pathPoints[i+1].x - pathPoints[i].x) / curLength;
    ax = (((vectors[i+1].x - vectors[i].x) * curProgress / curLength) + (3.0f * vectors[i].x)) * curProgress;
    bx = dx - (((2.0f * vectors[i].x) + vectors[i+1].x) * curLength);
    outPos->x = ((ax + bx) * curProgress) + pathPoints[i].x;
 
    dy = (pathPoints[i+1].y - pathPoints[i].y) / curLength;
    ay = (((vectors[i+1].y - vectors[i].y) * curProgress / curLength) + (3.0f * vectors[i].y)) * curProgress;
    by = dy - (((2.0f * vectors[i].y) + vectors[i+1].y) * curLength);
    outPos->y = ((ay + by) * curProgress) + pathPoints[i].y;
 
    dz = (pathPoints[i+1].z - pathPoints[i].z) / curLength;
    az = (((vectors[i+1].z - vectors[i].z) * curProgress / curLength) + (3.0f * vectors[i].z)) * curProgress;
    bz = dz - (((2.0f * vectors[i].z) + vectors[i+1].z) * curLength);
    outPos->z = ((az + bz) * curProgress) + pathPoints[i].z;
}