animator.c File Reference

Go to the source code of this file.

Data Structures
struct	DisplayListBufferHandle

Typedefs
typedef DisplayListBufferHandle	AnimatedMeshVertexCopyList[0x60]

Functions
void	appendGfx_animator_node (ModelAnimator *, AnimatorNode *, Matrix4f)
Vtx *	animator_copy_vertices_to_buffer (ModelAnimator *animator, AnimatorNode *node, Vec3s *buffer, s32 vtxCount, s32 overhead, s32 startIdx)
void	animator_make_mirrorZ (Matrix4f mtx)
void	animator_make_mirrorY (Matrix4f mtx)
void	animator_make_mirrorX (Matrix4f mtx)
void	animator_make_identity (Matrix4f mtx)
AnimatorNode *	get_animator_child_with_id_helper (AnimatorNode *node, s32 id)
AnimatorNode *	get_animator_child_with_id (ModelAnimator *animator, s32 id)
AnimatorNode *	get_animator_child_for_model (AnimatorNode *node, s32 modelId)
void	free_animator_nodes_helper (AnimatorNode *node)
void	free_animator_nodes (ModelAnimator *animator)
void	clear_animator_list (void)
void	reset_animator_list (void)
void	delete_model_animator_node (AnimatorNode *node)
void	delete_model_animator_nodes (ModelAnimator *animator)
void	delete_model_animator (ModelAnimator *animator)
s32	create_model_animator (s16 *animPos)
s32	create_mesh_animator (s16 *animPos, s16 *animBuffer)
AnimatorNode *	add_anim_node (ModelAnimator *animator, s32 parentNodeID, AnimatorNodeBlueprint *nodeBP)
void	update_model_animator (s32 animatorID)
void	update_model_animator_with_transform (s32 animatorID, Mtx *mtx)
s32	step_model_animator (ModelAnimator *animator)
void	animator_update_model_transforms (ModelAnimator *animator, Mtx *rootTransform)
void	animator_node_update_model_transform (ModelAnimator *animator, f32(*flipMtx)[4], AnimatorNode *node, Mtx *rootTransform)
void	render_animated_model (s32 animatorID, Mtx *rootTransform)
void	render_animated_model_with_vertices (s32 animatorID, Mtx *rootTransform, s32 segment, void *baseAddr)
void	appendGfx_animator (ModelAnimator *animator)
AnimatorNode *	get_animator_node_for_tree_index (ModelAnimator *animator, s32 arg1)
AnimatorNode *	get_animator_node_with_id (ModelAnimator *animator, s32 id)
void	set_animator_tree_to_node_map (ModelAnimator *animator, s32 *nodeIDs, s32 count)
ModelAnimator *	get_animator_by_index (s32 animModelID)
ModelAnimator *	set_animator_render_callback (s32 animModelID, void *callbackArg, void(*callbackFunc)(void *))
void	enable_anim_model_fog (void)
void	disable_anim_model_fog (void)
void	set_anim_model_fog_dist (s32 start, s32 end)
void	set_anim_model_fog_color (s32 r, s32 g, s32 b, s32 a)
s32	is_anim_model_fog_enabled (void)
void	get_anim_model_fog_distance (s32 *start, s32 *end)
void	get_anim_model_fog_color (s32 *r, s32 *g, s32 *b, s32 *a)
void	set_animator_flags (s32 index, s32 bits)
void	clear_animator_flags (s32 index, s32 bits)
void	play_model_animation (s32 index, s16 *animPos)
void	play_model_animation_starting_from (s32 index, s16 *animPos, s32 framesToSkip)
void	load_model_animator_node (StaticAnimatorNode *node, ModelAnimator *animator, s32 parentNodeID, s32 *treeIndexToNodeIDs)
void	load_model_animator_tree (s32 index, StaticAnimatorNode **tree)
void	load_mesh_animator_node (StaticAnimatorNode *node, ModelAnimator *animator, s32 parentNodeID, s32 *treeIndexToNodeIDs)
void	load_mesh_animator_tree (s32 index, StaticAnimatorNode **tree)
void	reload_mesh_animator_node (StaticAnimatorNode *node, ModelAnimator *animator, s32 parentNodeID, s32 *treeIndexToNodeIDs)
void	reload_mesh_animator_tree (ModelAnimator *animator)
s32	step_mesh_animator (ModelAnimator *animator)

Variables
s32	gAnimCount
BSS AnimatedMeshVertexCopyList	D_801533C0
BSS AnimatedMeshVertexCopyList	D_801536C0
BSS AnimatedMeshList	D_801539C0
BSS AnimatedMeshList	D_80153A00
BSS AnimatedMeshList *	gCurrentAnimMeshListPtr
BSS s32	gAnimModelFogEnabled
BSS s32	gAnimModelFogR
BSS s32	gAnimModelFogG
BSS s32	gAnimModelFogB
BSS s32	gAnimModelFogA
BSS s32	gAnimModelFogStart
BSS s32	gAnimModelFogEnd
BSS s32	gAnimVtxSegment
BSS Matrix4f	gAnimRotMtx
BSS Matrix4f	gAnimScaleMtx
BSS Matrix4f	gAnimTranslateMtx
BSS Matrix4f	gAnimRotScaleMtx
BSS StaticAnimatorNode **	gAnimTreeRoot
Gfx	Gfx_RM1_SURFACE_OPA []
Gfx	Gfx_RM1_DECAL_OPA []
Gfx	Gfx_RM1_INTERSECTING_OPA []
Gfx	Gfx_RM1_ALPHATEST []
Gfx	Gfx_RM1_SURFACE_XLU []
Gfx	Gfx_RM1_DECAL_XLU []
Gfx	Gfx_RM1_INTERSECTING_XLU []
Gfx	Gfx_RM3_SURFACE_OPA []
Gfx	Gfx_RM3_DECAL_OPA []
Gfx	Gfx_RM3_INTERSECTING_OPA []
Gfx	Gfx_RM3_ALPHATEST []
Gfx	Gfx_RM3_SURFACE_XLU []
Gfx	Gfx_RM3_DECAL_XLU []
Gfx	Gfx_RM3_INTERSECTING_XLU []
AnimScript	gAnimScriptDefault

---

Data Structure Documentation

DisplayListBufferHandle

struct DisplayListBufferHandle

Data Fields
s32	ttl
void *	addr

Typedef Documentation

AnimatedMeshVertexCopyList

typedef DisplayListBufferHandle AnimatedMeshVertexCopyList[0x60]

Definition at line 10 of file animator.c.

Function Documentation

appendGfx_animator_node()

void appendGfx_animator_node	(	ModelAnimator *	animator,
		AnimatorNode *	node,
		Matrix4f	mtx )

Definition at line 897 of file animator.c.

                                                                                        {
    DisplayListBufferHandle* bufferHandle;
    u32 w0,w1;
    s32 cmd;
    s32 i;
 
    if (node->flags & MODEL_ANIMATOR_FLAG_HIDDEN) {
        for (i = 0; i < ARRAY_COUNT(node->children); i++) {
            if (node->children[i] != nullptr) {
                guMtxCatF(node->mtx, mtx, node->mtx);
                appendGfx_animator_node(animator, node->children[i], node->mtx);
            }
        }
        return;
    }
 
    guMtxCatF(node->mtx, mtx, node->mtx);
    guMtxF2L(node->mtx, &gDisplayContext->matrixStack[gMatrixListPos]);
    gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
    gDPPipeSync(gMainGfxPos++);
 
    gSPTexture(gMainGfxPos++, 0, 0, 0, G_TX_RENDERTILE, G_OFF);
    gDPSetTextureLOD(gMainGfxPos++, G_TL_TILE);
    gDPSetTextureLUT(gMainGfxPos++, G_TT_NONE);
    gSPClearGeometryMode(gMainGfxPos++, G_LIGHTING);
    if (animator->flags & MODEL_ANIMATOR_FLAG_CULL_BACK) {
        gSPSetGeometryMode(gMainGfxPos++, G_CULL_BACK);
    }
    if (!gAnimModelFogEnabled) {
        gDPSetCombineMode(gMainGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
    } else {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_42, PM_CC2_MULTIPLY_SHADE);
    }
    gDPPipeSync(gMainGfxPos++);
 
    if (animator->fpRenderCallback != nullptr) animator->fpRenderCallback(animator->renderCallbackArg);
 
    gDPPipeSync(gMainGfxPos++);
 
    if (node->displayList != nullptr) {
        if (node->vertexStartOffset < 0) {
            gSPDisplayList(gMainGfxPos++, node->displayList);
        } else {
            Gfx* gfxPos;
            s32 vtxIdx, dlIdx;
            s32 j = 0;
            s32 k;
 
            if ((node->displayList[0].words.w0 >> 0x18) != G_ENDDL) {
                Gfx* gfxPtr = node->displayList;
                s32 endDL = G_ENDDL;
 
                for(;; j++) {
                    w0 = gfxPtr->words.w0;
                    gfxPtr++;
                    cmd = w0 >> 0x18;
                    if (cmd == endDL) {
                        break;
                    }
                }
            }
            j++;
            for (k = 0; k < ARRAY_COUNT(D_801536C0); k++) {
                bufferHandle = &D_801536C0[k];
                if (bufferHandle->ttl < 0) {
                    break;
                }
            }
            ASSERT(k < ARRAY_COUNT(D_801536C0));
 
            bufferHandle->addr = gfxPos = general_heap_malloc(j * sizeof(Gfx));
            ASSERT(gfxPos != nullptr);
            bufferHandle->ttl = 3;
 
            vtxIdx = 0;
            dlIdx = 0;
 
            do {
                w0 = ((s32*)node->displayList)[dlIdx++];
                w1 = ((s32*)node->displayList)[dlIdx++];
                cmd = w0 >> 0x18;
                if (cmd == G_ENDDL) {
                    break;
                }
                if (cmd == G_VTX) {
                    s32 startIdx = _SHIFTR(w0,1,7);
                    s32 vtxCount = _SHIFTR(w0,12,8);
                    Vtx* newBuffer;
 
                    startIdx -= vtxCount;
 
                    if (node->fcData.vtxList == nullptr) {
                        newBuffer = &((Vtx*)w1)[node->vertexStartOffset + vtxIdx];
                        gSPVertex(gfxPos++, newBuffer, vtxCount, startIdx);
                    } else {
                        newBuffer = animator_copy_vertices_to_buffer(
                            animator,
                            node,
                            (Vec3s*)(w1 + (node->vertexStartOffset + vtxIdx) * 0x6),
                            vtxCount,
                            startIdx,
                            vtxIdx
                        );
                        gSPVertex(gfxPos++, newBuffer, vtxCount, startIdx);
                    }
                    vtxIdx += vtxCount;
                } else {
                    Gfx* temp[1] = {gfxPos++}; // required to match
                    temp[0]->words.w0 = w0;
                    temp[0]->words.w1 = w1;
                }
            } while (true);
 
            gSPEndDisplayList(gfxPos++);
            gSPDisplayList(gMainGfxPos++, bufferHandle->addr);
        }
    }
    gDPPipeSync(gMainGfxPos++);
 
    for (i = 0; i < ARRAY_COUNT(node->children); i++) {
        if (node->children[i] != nullptr) {
            appendGfx_animator_node(animator, node->children[i], node->mtx);
        }
    }
}

Referenced by appendGfx_animator(), and appendGfx_animator_node().

animator_copy_vertices_to_buffer()

Vtx * animator_copy_vertices_to_buffer	(	ModelAnimator *	animator,
		AnimatorNode *	node,
		Vec3s *	buffer,
		s32	vtxCount,
		s32	overhead,
		s32	startIdx )

Definition at line 57 of file animator.c.

                                                                  {
    DisplayListBufferHandle* handle;
    Vtx* bufferMem;
    Vtx* nodeVtxList;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(D_801533C0); i++) {
        handle = &D_801533C0[i];
        if (handle->ttl < 0) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(D_801533C0));
 
    bufferMem = general_heap_malloc((vtxCount + overhead) * sizeof(*bufferMem));
    handle->addr = bufferMem;
 
    ASSERT(bufferMem != nullptr);
 
    handle->ttl = 3;
    nodeVtxList = &node->fcData.vtxList[startIdx];
 
    if (animator->baseAddr != nullptr) {
        i = ((s32)buffer & 0xFFFFFF); // needed to match
        buffer = (Vec3s*)(i + (s32)animator->baseAddr);
    }
 
    for (i = 0; i < vtxCount; i++) {
        *bufferMem = *nodeVtxList;
        bufferMem->v.ob[0] = buffer->x;
        bufferMem->v.ob[1] = buffer->y;
        bufferMem->v.ob[2] = buffer->z;
        bufferMem++;
        buffer++;
        nodeVtxList++;
    }
    return handle->addr;
}

Referenced by appendGfx_animator_node().

animator_make_mirrorZ()

void animator_make_mirrorZ

(

Matrix4f

mtx

)

Definition at line 98 of file animator.c.

                                         {
    guMtxIdentF(mtx);
    mtx[0][0] = 1.0f;
    mtx[1][1] = 1.0f;
    mtx[2][2] = -1.0f;
    mtx[3][3] = 1.0f;
}

Referenced by animator_update_model_transforms().

animator_make_mirrorY()

void animator_make_mirrorY

(

Matrix4f

mtx

)

Definition at line 106 of file animator.c.

                                         {
    guMtxIdentF(mtx);
    mtx[0][0] = 1.0f;
    mtx[1][1] = -1.0f;
    mtx[2][2] = 1.0f;
    mtx[3][3] = 1.0f;
}

Referenced by animator_update_model_transforms().

animator_make_mirrorX()

void animator_make_mirrorX

(

Matrix4f

mtx

)

Definition at line 114 of file animator.c.

                                         {
    guMtxIdentF(mtx);
    mtx[0][0] = -1.0f;
    mtx[1][1] = 1.0f;
    mtx[2][2] = 1.0f;
    mtx[3][3] = 1.0f;
}

Referenced by animator_update_model_transforms().

animator_make_identity()

void animator_make_identity

(

Matrix4f

mtx

)

Definition at line 122 of file animator.c.

                                          {
    guMtxIdentF(mtx);
    mtx[0][0] = 1.0f;
    mtx[1][1] = 1.0f;
    mtx[2][2] = 1.0f;
    mtx[3][3] = 1.0f;
}

Referenced by animator_update_model_transforms().

get_animator_child_with_id_helper()

AnimatorNode * get_animator_child_with_id_helper	(	AnimatorNode *	node,
		s32	id )

Definition at line 130 of file animator.c.

                                                                            {
    s32 i;
 
    if (node->uniqueIndex == id) {
        return node;
    }
 
    for (i = 0; i < ARRAY_COUNT(node->children); i++) {
        if (node->children[i] != nullptr) {
            AnimatorNode* child = get_animator_child_with_id_helper(node->children[i], id);
            if (child != nullptr) {
                return child;
            }
        }
    }
 
    return nullptr;
}

Referenced by get_animator_child_with_id(), and get_animator_child_with_id_helper().

get_animator_child_with_id()

AnimatorNode * get_animator_child_with_id	(	ModelAnimator *	animator,
		s32	id )

Definition at line 149 of file animator.c.

                                                                          {
    AnimatorNode *node = animator->rootNode;
    s32 i;
 
    if (animator->nodeCache[id] != nullptr && animator->nodeCache[id]->uniqueIndex == id) {
        return animator->nodeCache[id];
    }
    if (node->uniqueIndex == id) {
        return node;
    }
 
    for (i = 0; i < ARRAY_COUNT(node->children); i++) {
        if (node->children[i] != nullptr) {
            AnimatorNode* child = get_animator_child_with_id_helper(node->children[i], id);
 
            if (child != nullptr) {
                animator->nodeCache[id] = child;
                return child;
            }
 
        }
    }
 
    return nullptr;
}

Referenced by add_anim_node(), get_animator_node_for_tree_index(), step_mesh_animator(), and step_model_animator().

get_animator_child_for_model()

AnimatorNode * get_animator_child_for_model	(	AnimatorNode *	node,
		s32	modelId )

Definition at line 175 of file animator.c.

                                                                            {
    s32 i;
 
    if (node->fcData.modelID == modelId) {
        return node;
    }
 
    for (i = 0; i < ARRAY_COUNT(node->children); i++) {
        if (node->children[i] != nullptr) {
            AnimatorNode* child = get_animator_child_for_model(node->children[i], modelId);
 
            if (child != nullptr) {
                return child;
            }
 
        }
    }
 
    return nullptr;
}

Referenced by get_animator_child_for_model(), and get_animator_node_with_id().

free_animator_nodes_helper()

void free_animator_nodes_helper

(

AnimatorNode *

node

)

Definition at line 196 of file animator.c.

                                                    {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(node->children); i++) {
        if (node->children[i] != nullptr) {
            free_animator_nodes_helper(node->children[i]);
        }
    }
    heap_free(node);
}

Referenced by free_animator_nodes(), and free_animator_nodes_helper().

free_animator_nodes()

void free_animator_nodes

(

ModelAnimator *

animator

)

Definition at line 207 of file animator.c.

                                                  {
    AnimatorNode *root = animator->rootNode;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(animator->nodeCache); i++) {
        animator->nodeCache[i] = nullptr;
    }
    for (i = 0; i < ARRAY_COUNT(root->children); i++) {
        if (root->children[i] != nullptr) {
            free_animator_nodes_helper(root->children[i]);
        }
    }
    heap_free(root);
}

clear_animator_list()

void clear_animator_list

(

void

)

Definition at line 222 of file animator.c.

                               {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentAnimMeshListPtr = &D_801539C0;
        for (i = 0; i < ARRAY_COUNT(D_801533C0); i++) {
            D_801533C0[i].ttl = -1;
        }
 
        for (i = 0; i < ARRAY_COUNT(D_801536C0); i++) {
            D_801536C0[i].ttl = -1;
        }
    } else {
        gCurrentAnimMeshListPtr = &D_80153A00;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentAnimMeshListPtr); i++) {
        (*gCurrentAnimMeshListPtr)[i] = nullptr;
    }
 
    gAnimModelFogR = 10;
    gAnimModelFogG = 10;
    gAnimModelFogB = 10;
    gAnimModelFogA = 10;
    gAnimModelFogStart = 800;
    gAnimCount = 0;
    gAnimModelFogEnabled = 0;
    gAnimModelFogEnd = 1000;
}

Referenced by load_demo_battle(), load_engine_data(), load_map_by_IDs(), state_init_logos(), state_init_title_screen(), state_step_battle(), state_step_demo(), state_step_intro(), state_step_pause(), state_step_startup(), and state_step_title_screen().

reset_animator_list()

void reset_animator_list

(

void

)

Definition at line 252 of file animator.c.

                               {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentAnimMeshListPtr = &D_801539C0;
    } else {
        gCurrentAnimMeshListPtr = &D_80153A00;
    }
 
    gAnimModelFogR = 10;
    gAnimModelFogG = 10;
    gAnimModelFogB = 10;
    gAnimModelFogA = 10;
    gAnimModelFogStart = 800;
    gAnimCount = 0;
    gAnimModelFogEnabled = 0;
    gAnimModelFogEnd = 1000;
}

Referenced by state_step_end_battle(), and state_step_unpause().

delete_model_animator_node()

void delete_model_animator_node

(

AnimatorNode *

node

)

Definition at line 269 of file animator.c.

                                                    {
    s32 i;
 
    node->flags = 0;
 
    for (i = 0; i < ARRAY_COUNT(node->children); i++) {
        if (node->children[i] != nullptr) {
            delete_model_animator_node(node->children[i]);
            node->children[i] = nullptr;
        }
    }
 
    heap_free(node);
}

Referenced by delete_model_animator(), delete_model_animator_node(), and delete_model_animator_nodes().

delete_model_animator_nodes()

void delete_model_animator_nodes

(

ModelAnimator *

animator

)

Definition at line 284 of file animator.c.

                                                          {
    s32 i;
 
    animator->nextUniqueID = 0;
    for (i = 0; i < ARRAY_COUNT(animator->nodeCache); i++) {
        animator->nodeCache[i] = nullptr;
    }
    if (animator->rootNode != nullptr) {
        delete_model_animator_node(animator->rootNode);
        animator->rootNode = nullptr;
    }
}

Referenced by reload_mesh_animator_tree().

delete_model_animator()

void delete_model_animator

(

ModelAnimator *

animator

)

Definition at line 297 of file animator.c.

                                                    {
    s32 i;
 
    animator->nextUniqueID = 0;
 
    if (animator->rootNode != nullptr) {
        delete_model_animator_node(animator->rootNode);
        animator->rootNode = nullptr;
 
        for (i = 0; i < ARRAY_COUNT(*gCurrentAnimMeshListPtr); i++) {
            if ((*gCurrentAnimMeshListPtr)[i] == animator) {
                (*gCurrentAnimMeshListPtr)[i] = nullptr;
                break;
            }
        }
 
        heap_free(animator);
        gAnimCount--;
    }
}

Referenced by delete_entity(), and delete_entity_and_unload_data().

create_model_animator()

s32 create_model_animator

(

s16 *

animPos

)

Definition at line 318 of file animator.c.

                                        {
    ModelAnimator* animator;
    s32 i, j;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentAnimMeshListPtr); i++) {
        if ((*gCurrentAnimMeshListPtr)[i] == nullptr) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(*gCurrentAnimMeshListPtr));
 
    (*gCurrentAnimMeshListPtr)[i] = animator = heap_malloc(sizeof(*animator));
    gAnimCount++;
 
    ASSERT(animator != nullptr);
 
    animator->flags = MODEL_ANIMATOR_FLAG_UPDATE_PENDING | MODEL_ANIMATOR_FLAG_ENABLED | MODEL_ANIMATOR_FLAG_CAM_2 | MODEL_ANIMATOR_FLAG_CAM_1 | MODEL_ANIMATOR_FLAG_CAM_0;
    animator->renderMode = RENDER_MODE_ALPHATEST;
    animator->nextUpdateTime = 1.0f;
    animator->timeScale = 1.0f;
    animator->animReadPos = animPos;
 
    if (animPos == nullptr) {
        animator->animReadPos = gAnimScriptDefault;
    }
 
    animator->savedReadPos = animPos;
    animator->animationBuffer = nullptr;
    animator->baseAddr = nullptr;
    animator->fpRenderCallback = nullptr;
    animator->rootNode = nullptr;
    animator->nextUniqueID = 0;
 
    for (j = 0; j < ARRAY_COUNT(animator->nodeCache); j++) {
        animator->nodeCache[j] = nullptr;
    }
 
    for (j = 0; j < ARRAY_COUNT(animator->staticNodeIDs); j++) {
        animator->staticNodeIDs[j] = j + 1;
    }
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        i |= BATTLE_ID_BIT;
    }
    return i;
}

Referenced by create_shadow_from_data(), and load_split_entity_data().

create_mesh_animator()

s32 create_mesh_animator	(	s16 *	animPos,
		s16 *	animBuffer )

Definition at line 366 of file animator.c.

                                                        {
    ModelAnimator* animator;
    s32 i, j;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentAnimMeshListPtr); i++) {
        if ((*gCurrentAnimMeshListPtr)[i] == nullptr) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(*gCurrentAnimMeshListPtr));
 
    (*gCurrentAnimMeshListPtr)[i] = animator = heap_malloc(sizeof(*animator));
    gAnimCount++;
 
    ASSERT(animator != nullptr);
 
    animator->flags = MODEL_ANIMATOR_FLAG_UPDATE_PENDING | MODEL_ANIMATOR_FLAG_ENABLED | MODEL_ANIMATOR_FLAG_CAM_2 | MODEL_ANIMATOR_FLAG_CAM_1 | MODEL_ANIMATOR_FLAG_CAM_0;
    animator->renderMode = RENDER_MODE_ALPHATEST;
    animator->baseAddr = nullptr;
    animator->fpRenderCallback = nullptr;
    animator->rootNode = nullptr;
    animator->nextUniqueID = 0;
    animator->animationBuffer = animBuffer;
    animator->nextUpdateTime = 1.0f;
    animator->timeScale = 1.0f;
    animPos = (s16*)(((s32)animPos & 0xFFFFFF) + (s32)animator->animationBuffer);
    animator->animReadPos = animPos;
    animator->savedReadPos = animPos;
 
    for (j = 0; j < ARRAY_COUNT(animator->nodeCache); j++) {
        animator->nodeCache[j] = nullptr;
    }
 
    for (j = 0; j < ARRAY_COUNT(animator->staticNodeIDs); j++) {
        animator->staticNodeIDs[j] = j + 1;
    }
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        i |= BATTLE_ID_BIT;
    }
    return i;
}

Referenced by load_split_entity_data().

add_anim_node()

AnimatorNode * add_anim_node	(	ModelAnimator *	animator,
		s32	parentNodeID,
		AnimatorNodeBlueprint *	nodeBP )

Definition at line 410 of file animator.c.

                                                                                                      {
    AnimatorNode* ret;
    AnimatorNode* child;
    s32 nextUniqueID;
    s32 i;
 
    ret = heap_malloc(sizeof(*ret));
    ASSERT(ret != nullptr);
 
    ret->flags = MODEL_ANIMATOR_FLAG_ENABLED;
    ret->displayList = nodeBP->displayList;
    ret->basePos.x = nodeBP->basePos.x;
    ret->basePos.y = nodeBP->basePos.y;
    ret->basePos.z = nodeBP->basePos.z;
    ret->pos.x = 0.0f;
    ret->pos.y = 0.0f;
    ret->pos.z = 0.0f;
    ret->rot.x = nodeBP->rot.x;
    ret->rot.y = nodeBP->rot.y;
    ret->rot.z = nodeBP->rot.z;
    ret->scale.x = 1.0f;
    ret->scale.y = 1.0f;
    ret->scale.z = 1.0f;
    ret->vertexStartOffset = -1;
 
    for (i = 0; i < ARRAY_COUNT(ret->children); i++) {
        ret->children[i] = nullptr;
    }
 
    nextUniqueID = animator->nextUniqueID;
    nextUniqueID = nextUniqueID + 1;
 
    if (parentNodeID == 0) {
        s32 nullRootNode = animator->rootNode == nullptr; // todo ???
 
        ret->uniqueIndex = nextUniqueID;
 
        if (nullRootNode) {
            animator->rootNode = ret;
        } else {
            child = get_animator_child_with_id(animator, 1);
            ASSERT(child != nullptr);
 
            for (i = 0; i < ARRAY_COUNT(child->children); i++) {
                if (child->children[i] == nullptr) {
                    child->children[i] = ret;
                    break;
                }
            }
 
            ASSERT(i < ARRAY_COUNT(child->children));
        }
    } else {
        ret->uniqueIndex = nextUniqueID;
        child = get_animator_child_with_id(animator, parentNodeID);
        ASSERT(child != nullptr);
 
        for (i = 0; i < ARRAY_COUNT(child->children); i++) {
            if (child->children[i] == nullptr) {
                child->children[i] = ret;
                break;
            }
        }
 
        ASSERT(i < ARRAY_COUNT(child->children));
    }
 
    animator->nextUniqueID = nextUniqueID;
    return ret;
}

Referenced by load_model_animator_node(), and reload_mesh_animator_node().

update_model_animator()

void update_model_animator

(

s32

animatorID

)

Definition at line 481 of file animator.c.

                                           {
    ModelAnimator* animator;
    s32 temp;
    s32 i;
 
    if (gGameStatusPtr->context != CONTEXT_WORLD && !(animatorID & BATTLE_ID_BIT)) {
        return;
    }
 
    animatorID &= ~BATTLE_ID_BIT;
    animator = (*gCurrentAnimMeshListPtr)[animatorID];
 
    if (animator == nullptr || animator->flags == 0) {
        return;
    }
 
    if (animator->flags & MODEL_ANIMATOR_FLAG_FREEZE_ANIMATION) {
        return;
    }
 
    animator->flags &= ~MODEL_ANIMATOR_FLAG_UPDATE_PENDING;
    animator->nextUpdateTime -= animator->timeScale;
 
    temp = 0;
    if (animator->nextUpdateTime <= 0.0f) {
        if (!(animator->flags & MODEL_ANIMATOR_FLAG_MESH)) {
            do {
                temp = step_model_animator(animator);
            } while (temp > 0);
        } else {
            animator->nextUpdateTime = 1.0f;
            reload_mesh_animator_tree(animator);
            do {
                temp = step_mesh_animator(animator);
            } while (temp > 0);
        }
    }
    if (temp == -1) {
        return;
    }
 
    animator_update_model_transforms(animator, nullptr);
 
    for (i = 0; i < ARRAY_COUNT(D_801533C0); i++) {
        if (D_801533C0[i].ttl >= 0) {
            D_801533C0[i].ttl--;
            if (D_801533C0[i].ttl == 0) {
                D_801533C0[i].ttl = -1;
                general_heap_free(D_801533C0[i].addr);
            }
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(D_801536C0); i++) {
        if (D_801536C0[i].ttl >= 0) {
            D_801536C0[i].ttl--;
            if (D_801536C0[i].ttl == 0) {
                D_801536C0[i].ttl = -1;
                general_heap_free(D_801536C0[i].addr);
            }
        }
    }
}

Referenced by load_split_entity_data(), play_model_animation_starting_from(), update_entities(), and update_shadows().

update_model_animator_with_transform()

void update_model_animator_with_transform	(	s32	animatorID,
		Mtx *	mtx )

Definition at line 545 of file animator.c.

                                                                    {
    ModelAnimator* animator;
    s32 temp;
    s32 i;
 
    if (gGameStatusPtr->context != CONTEXT_WORLD && !(animatorID & BATTLE_ID_BIT)) {
        return;
    }
 
    animatorID &= ~BATTLE_ID_BIT;
    animator = (*gCurrentAnimMeshListPtr)[animatorID];
 
    if (animator == nullptr || animator->flags == 0) {
        return;
    }
 
    if (animator->flags & MODEL_ANIMATOR_FLAG_FREEZE_ANIMATION) {
        return;
    }
 
    animator->flags &= ~MODEL_ANIMATOR_FLAG_UPDATE_PENDING;
    animator->nextUpdateTime -= animator->timeScale;
 
    temp = 0;
    if (animator->nextUpdateTime <= 0.0f) {
        if (!(animator->flags & MODEL_ANIMATOR_FLAG_MESH)) {
            do {
                temp = step_model_animator(animator);
            } while (temp > 0);
        } else {
            animator->nextUpdateTime = 1.0f;
            reload_mesh_animator_tree(animator);
            do {
                temp = step_mesh_animator(animator);
            } while (temp > 0);
        }
    }
    if (temp == -1) {
        return;
    }
 
    animator_update_model_transforms(animator, mtx);
 
    for (i = 0; i < ARRAY_COUNT(D_801533C0); i++) {
        if (D_801533C0[i].ttl >= 0) {
            D_801533C0[i].ttl--;
            if (D_801533C0[i].ttl == 0) {
                D_801533C0[i].ttl = -1;
                general_heap_free(D_801533C0[i].addr);
            }
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(D_801536C0); i++) {
        if (D_801536C0[i].ttl >= 0) {
            D_801536C0[i].ttl--;
            if (D_801536C0[i].ttl == 0) {
                D_801536C0[i].ttl = -1;
                general_heap_free(D_801536C0[i].addr);
            }
        }
    }
}

Referenced by update_animated_models().

step_model_animator()

s32 step_model_animator

(

ModelAnimator *

animator

)

Definition at line 609 of file animator.c.

                                                 {
    s16* args = animator->animReadPos;
    AnimatorNode* node;
    f32 x, y, z;
    s32 flags;
    s32 nodeId;
 
    switch (*args++) {
        case AS_END:
            return -1;
        case AS_SET_RENDER_MODE:
            animator->renderMode = *args++;
            animator->animReadPos = args;
            return 1;
        case AS_WAIT:
            animator->nextUpdateTime = *args++;
            animator->animReadPos = args;
            break;
        case AS_END_LOOP:
            animator->animReadPos = animator->savedReadPos;
            return 1;
        case AS_LOOP:
            animator->animReadPos = animator->savedReadPos = args;
            return 1;
        case AS_SET_FLAGS:
            flags = *args++;
            animator->animReadPos = args;
            animator->flags |= flags & 0xFFFF;
            return 1;
        case AS_SET_NODE_FLAGS:
            node = get_animator_child_with_id(animator, animator->staticNodeIDs[*args++ - 1]);
            flags = *args++;
            node->flags |= flags;
            animator->animReadPos = args;
            return 1;
        case AS_CLEAR_NODE_FLAGS:
            node = get_animator_child_with_id(animator, animator->staticNodeIDs[*args++ - 1]);
            flags = *args++;
            node->flags &= ~flags;
            animator->animReadPos = args;
            return 1;
        case AS_OP_19:
            animator->flags |= MODEL_ANIMATOR_FLAG_NO_FLIP;
            animator->animReadPos = args;
            return 1;
        case AS_SET_ROTATION:
            nodeId = animator->staticNodeIDs[*args++ - 1];
            x = (f32)*args++ * 180.0 / 32767.0;
            y = (f32)*args++ * 180.0 / 32767.0;
            z = (f32)*args++ * 180.0 / 32767.0;
            animator->animReadPos = args;
 
            node = get_animator_child_with_id(animator, nodeId);
            ASSERT(node != nullptr);
            node->rot.x = x;
            node->rot.y = y;
            node->rot.z = z;
            return 1;
        case AS_ADD_ROTATION:
            nodeId = animator->staticNodeIDs[*args++ - 1];
            x = (f32)*args++ * 180.0 / 32767.0;
            y = (f32)*args++ * 180.0 / 32767.0;
            z = (f32)*args++ * 180.0 / 32767.0;
            animator->animReadPos = args;
 
            node = get_animator_child_with_id(animator, nodeId);
            ASSERT(node != nullptr);
            node->rot.x += x;
            node->rot.y += y;
            node->rot.z += z;
            return 1;
        case AS_SET_POS:
            nodeId = animator->staticNodeIDs[*args++ - 1];
            x = *args++;
            y = *args++;
            z = *args++;
            animator->animReadPos = args;
            node = get_animator_child_with_id(animator, nodeId);
            ASSERT(node != nullptr);
            node->pos.x = x;
            node->pos.y = y;
            node->pos.z = z;
            return 1;
        case AS_SET_SCALE:
            nodeId = animator->staticNodeIDs[*args++ - 1];
            x = (f32)*args++ * 180.0 / 32767.0;
            y = (f32)*args++ * 180.0 / 32767.0;
            z = (f32)*args++ * 180.0 / 32767.0;
            animator->animReadPos = args;
 
            node = get_animator_child_with_id(animator, nodeId);
            ASSERT(node != nullptr);
            node->scale.x = x;
            node->scale.y = y;
            node->scale.z = z;
            return 1;
    }
    return 0;
}

Referenced by update_model_animator(), and update_model_animator_with_transform().

animator_update_model_transforms()

void animator_update_model_transforms	(	ModelAnimator *	animator,
		Mtx *	rootTransform )

Definition at line 709 of file animator.c.

                                                                                   {
    Matrix4f flipMtx;
 
    if (animator->rootNode != nullptr) {
        switch (animator->flags & (MODEL_ANIMATOR_FLAG_FLIP_Z | MODEL_ANIMATOR_FLAG_FLIP_Y | MODEL_ANIMATOR_FLAG_FLIP_X)) {
            case MODEL_ANIMATOR_FLAG_FLIP_Z:
                animator_make_mirrorZ(flipMtx);
                break;
            case MODEL_ANIMATOR_FLAG_FLIP_Y:
                animator_make_mirrorY(flipMtx);
                break;
            case MODEL_ANIMATOR_FLAG_FLIP_X:
                animator_make_mirrorX(flipMtx);
                break;
            default:
                animator_make_identity(flipMtx);
                break;
        }
        animator_node_update_model_transform(animator, flipMtx, animator->rootNode, rootTransform);
    }
}

Referenced by update_model_animator(), and update_model_animator_with_transform().

animator_node_update_model_transform()

void animator_node_update_model_transform	(	ModelAnimator *	animator,
		f32(*)	flipMtx[4],
		AnimatorNode *	node,
		Mtx *	rootTransform )

Definition at line 731 of file animator.c.

                                                              {
    Matrix4f sp10;
    s32 i;
 
    guRotateRPYF(gAnimRotMtx, clamp_angle(node->rot.x), clamp_angle(node->rot.y), clamp_angle(node->rot.z));
    guScaleF(gAnimScaleMtx, node->scale.x, node->scale.y, node->scale.z);
    guTranslateF(gAnimTranslateMtx, node->basePos.x + node->pos.x, node->basePos.y + node->pos.y, node->basePos.z + node->pos.z);
    guMtxCatF(gAnimScaleMtx, gAnimRotMtx, gAnimRotScaleMtx);
    guMtxCatF(gAnimRotScaleMtx, gAnimTranslateMtx, sp10);
 
    if (!(animator->flags & MODEL_ANIMATOR_FLAG_NO_FLIP)) {
        guMtxCatF(sp10, flipMtx, sp10);
    }
 
    copy_matrix(sp10, node->mtx);
 
    if (node->flags & MODEL_ANIMATOR_FLAG_HAS_MODEL) {
        Model* model = get_model_from_list_index(get_model_list_index_from_tree_index(node->fcData.modelID));
 
        copy_matrix(sp10, model->userTransformMtx);
        guMtxL2F(sp10, rootTransform);
        guMtxCatF(model->userTransformMtx, sp10, model->userTransformMtx);
        model->flags |= MODEL_FLAG_MATRIX_DIRTY;
    }
 
    for (i = 0; i < ARRAY_COUNT(node->children); i++) {
        if (node->children[i] != nullptr) {
            animator_node_update_model_transform(animator, sp10, node->children[i], rootTransform);
        }
    }
}

Referenced by animator_node_update_model_transform(), and animator_update_model_transforms().

render_animated_model()

void render_animated_model	(	s32	animatorID,
		Mtx *	rootTransform )

Definition at line 764 of file animator.c.

                                                               {
    ModelAnimator* animator;
    RenderTask rt;
    RenderTask* rtPtr = &rt;
 
    if (gGameStatusPtr->context != CONTEXT_WORLD && !(animatorID & BATTLE_ID_BIT)) {
        return;
    }
 
    animatorID &= ~BATTLE_ID_BIT;
    animator = (*gCurrentAnimMeshListPtr)[animatorID];
 
    if (animator == nullptr || animator->flags == 0) {
        return;
    }
 
    if (!(animator->flags & MODEL_ANIMATOR_FLAG_UPDATE_PENDING)
        && animator->flags & (1 << gCurrentCamID)
        && !(animator->flags & MODEL_ANIMATOR_FLAG_HIDDEN)
    ) {
        animator->mtx = *rootTransform;
        animator->baseAddr = nullptr;
        rtPtr->appendGfxArg = animator;
        rtPtr->appendGfx = (void (*)(void*))appendGfx_animator;
        rtPtr->dist = 0;
        rtPtr->renderMode = animator->renderMode;
        queue_render_task(rtPtr);
    }
}

Referenced by render_animated_models(), render_entities(), and render_shadows().

render_animated_model_with_vertices()

void render_animated_model_with_vertices	(	s32	animatorID,
		Mtx *	rootTransform,
		s32	segment,
		void *	baseAddr )

Definition at line 794 of file animator.c.

                                                                                                          {
    ModelAnimator* animator;
    RenderTask rt;
    RenderTask* rtPtr = &rt;
 
    if (gGameStatusPtr->context != CONTEXT_WORLD && !(animatorID & BATTLE_ID_BIT)) {
        return;
    }
 
    animatorID &= ~BATTLE_ID_BIT;
    animator = (*gCurrentAnimMeshListPtr)[animatorID];
 
    if (animator == nullptr || animator->flags == 0) {
        return;
    }
 
    if (!(animator->flags & MODEL_ANIMATOR_FLAG_UPDATE_PENDING)
        && animator->flags & (1 << gCurrentCamID)
        && !(animator->flags & MODEL_ANIMATOR_FLAG_HIDDEN)
    ) {
        animator->mtx = *rootTransform;
        gAnimVtxSegment = segment;
        animator->baseAddr = baseAddr;
        rtPtr->appendGfxArg = animator;
        rtPtr->appendGfx = (void (*)(void*))appendGfx_animator;
        rtPtr->dist = 0;
        rtPtr->renderMode = animator->renderMode;
        queue_render_task(rtPtr);
    }
}

Referenced by render_entities(), and render_shadows().

appendGfx_animator()

void appendGfx_animator

(

ModelAnimator *

animator

)

Definition at line 825 of file animator.c.

                                                 {
    Matrix4f sp10;
 
    if (animator->baseAddr != nullptr) {
        gSPSegment(gMainGfxPos++, gAnimVtxSegment, VIRTUAL_TO_PHYSICAL(animator->baseAddr));
    }
 
    gDisplayContext->matrixStack[gMatrixListPos] = animator->mtx;
    gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
 
    //TODO find better match
    switch (gAnimModelFogEnabled != 0) {
        case false:
            switch (animator->renderMode) {
                case RENDER_MODE_SURFACE_OPA:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM1_SURFACE_OPA);
                    break;
                case RENDER_MODE_DECAL_OPA:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM1_DECAL_OPA);
                    break;
                case RENDER_MODE_INTERSECTING_OPA:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM1_INTERSECTING_OPA);
                    break;
                case RENDER_MODE_ALPHATEST:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM1_ALPHATEST);
                    break;
                case RENDER_MODE_SURFACE_XLU_LAYER1:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM1_SURFACE_XLU);
                    break;
                case RENDER_MODE_DECAL_XLU:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM1_DECAL_XLU);
                    break;
                case RENDER_MODE_INTERSECTING_XLU:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM1_INTERSECTING_XLU);
                    break;
            }
            break;
        case true:
            switch (animator->renderMode) {
                case RENDER_MODE_SURFACE_OPA:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM3_SURFACE_OPA);
                    break;
                case RENDER_MODE_DECAL_OPA:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM3_DECAL_OPA);
                    break;
                case RENDER_MODE_INTERSECTING_OPA:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM3_INTERSECTING_OPA);
                    break;
                case RENDER_MODE_ALPHATEST:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM3_ALPHATEST);
                    break;
                case RENDER_MODE_SURFACE_XLU_LAYER1:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM3_SURFACE_XLU);
                    break;
                case RENDER_MODE_DECAL_XLU:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM3_DECAL_XLU);
                    break;
                case RENDER_MODE_INTERSECTING_XLU:
                    gSPDisplayList(gMainGfxPos++, Gfx_RM3_INTERSECTING_XLU);
                    break;
            }
 
            gDPSetFogColor(gMainGfxPos++, gAnimModelFogR, gAnimModelFogG, gAnimModelFogB, gAnimModelFogA);
            gSPFogPosition(gMainGfxPos++, gAnimModelFogStart, gAnimModelFogEnd);
            break;
    }
 
    guMtxL2F(sp10, &animator->mtx);
    appendGfx_animator_node(animator, animator->rootNode, sp10);
    gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
}

Referenced by render_animated_model(), and render_animated_model_with_vertices().

get_animator_node_for_tree_index()

AnimatorNode * get_animator_node_for_tree_index	(	ModelAnimator *	animator,
		s32	arg1 )

Definition at line 1023 of file animator.c.

                                                                                  {
    return get_animator_child_with_id(animator, animator->staticNodeIDs[arg1 - 1]);
}

get_animator_node_with_id()

AnimatorNode * get_animator_node_with_id	(	ModelAnimator *	animator,
		s32	id )

Definition at line 1027 of file animator.c.

                                                                         {
    return get_animator_child_for_model(animator->rootNode, id);
}

set_animator_tree_to_node_map()

void set_animator_tree_to_node_map	(	ModelAnimator *	animator,
		s32 *	nodeIDs,
		s32	count )

Definition at line 1031 of file animator.c.

                                                                                     {
    s32 i;
 
    for (i = 0; i < count; i++) {
        animator->staticNodeIDs[i] = *nodeIDs;
        nodeIDs++;
    }
}

Referenced by load_model_animator_tree(), and reload_mesh_animator_tree().

get_animator_by_index()

ModelAnimator * get_animator_by_index

(

s32

animModelID

)

Definition at line 1040 of file animator.c.

                                                      {
    return (*gCurrentAnimMeshListPtr)[animModelID & ~BATTLE_ID_BIT];
}

Referenced by delete_entity(), delete_entity_and_unload_data(), entity_ItemlessBlock_init(), and entity_PinkFlower_init().

set_animator_render_callback()

ModelAnimator * set_animator_render_callback	(	s32	animModelID,
		void *	callbackArg,
		void(*)(void *)	callbackFunc )

Definition at line 1044 of file animator.c.

                                                                                                             {
    ModelAnimator* ret = (*gCurrentAnimMeshListPtr)[animModelID & ~BATTLE_ID_BIT];
 
    ret->fpRenderCallback = callbackFunc;
    ret->renderCallbackArg = callbackArg;
    return ret;
}

Referenced by render_entities().

enable_anim_model_fog()

void enable_anim_model_fog

(

void

)

Definition at line 1052 of file animator.c.

                                 {
    gAnimModelFogEnabled = true;
}

disable_anim_model_fog()

void disable_anim_model_fog

(

void

)

Definition at line 1056 of file animator.c.

                                  {
    gAnimModelFogEnabled = false;
}

set_anim_model_fog_dist()

void set_anim_model_fog_dist	(	s32	start,
		s32	end )

Definition at line 1060 of file animator.c.

                                                 {
    gAnimModelFogStart = start;
    gAnimModelFogEnd = end;
}

set_anim_model_fog_color()

void set_anim_model_fog_color	(	s32	r,
		s32	g,
		s32	b,
		s32	a )

Definition at line 1065 of file animator.c.

                                                          {
    gAnimModelFogR = r;
    gAnimModelFogG = g;
    gAnimModelFogB = b;
    gAnimModelFogA = a;
}

is_anim_model_fog_enabled()

s32 is_anim_model_fog_enabled

(

void

)

Definition at line 1072 of file animator.c.

                                    {
    return gAnimModelFogEnabled;
}

get_anim_model_fog_distance()

void get_anim_model_fog_distance	(	s32 *	start,
		s32 *	end )

Definition at line 1076 of file animator.c.

                                                       {
    *start = gAnimModelFogStart;
    *end = gAnimModelFogEnd;
}

get_anim_model_fog_color()

void get_anim_model_fog_color	(	s32 *	r,
		s32 *	g,
		s32 *	b,
		s32 *	a )

Definition at line 1081 of file animator.c.

                                                              {
    *r = gAnimModelFogR;
    *g = gAnimModelFogG;
    *b = gAnimModelFogB;
    *a = gAnimModelFogA;
}

set_animator_flags()

void set_animator_flags	(	s32	index,
		s32	bits )

Definition at line 1088 of file animator.c.

                                             {
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[index & ~BATTLE_ID_BIT];
 
    animator->flags |= bits;
}

clear_animator_flags()

void clear_animator_flags	(	s32	index,
		s32	bits )

Definition at line 1094 of file animator.c.

                                               {
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[index & ~BATTLE_ID_BIT];
 
    animator->flags &= ~bits;
}

play_model_animation()

void play_model_animation	(	s32	index,
		s16 *	animPos )

Definition at line 1100 of file animator.c.

                                                   {
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[index & ~BATTLE_ID_BIT];
 
    if (animator->animationBuffer != nullptr) {
        animPos = (s16*) (((s32)animPos & 0xFFFFFF) + (s32)animator->animationBuffer); // TODO: array access? / cleanup
    }
    animator->animReadPos = animPos;
    animator->savedReadPos = animPos;
    animator->treeIndexPos = 0;
    animator->nextUpdateTime = 1.0f;
}

Referenced by entity_BellbellPlant_idle(), entity_CymbalPlant_idle(), entity_HitItemBlock_play_anim(), entity_PinkFlower_idle(), entity_ScriptSpring_idle(), entity_SimpleSpring_idle(), entity_TrumpetPlant_idle(), and func_802BC0B8_E2E9E8().

play_model_animation_starting_from()

void play_model_animation_starting_from	(	s32	index,
		s16 *	animPos,
		s32	framesToSkip )

Definition at line 1112 of file animator.c.

                                                                                   {
    s32 indexMasked = index & ~BATTLE_ID_BIT;
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[indexMasked];
    s32 i;
 
    if (animator->animationBuffer != nullptr) {
        animPos = (s16*) (((s32)animPos & 0xFFFFFF) + (s32)animator->animationBuffer); // TODO: array access? / cleanup
    }
 
    animator->animReadPos = animPos;
    animator->savedReadPos = animPos;
    animator->treeIndexPos = 0;
    animator->nextUpdateTime = 1.0f;
 
    for (i = 0; i < framesToSkip; i++) {
        update_model_animator(indexMasked);
    }
}

load_model_animator_node()

void load_model_animator_node	(	StaticAnimatorNode *	node,
		ModelAnimator *	animator,
		s32	parentNodeID,
		s32 *	treeIndexToNodeIDs )

Definition at line 1131 of file animator.c.

                                                                                                                            {
    AnimatorNodeBlueprint bp;
    AnimatorNodeBlueprint* bpPtr = &bp;
    AnimatorNode* newNode;
    s32 i;
 
    if (node != nullptr) {
        bpPtr->displayList = node->displayList;
        bpPtr->basePos.x = 0.0f;
        bpPtr->basePos.y = 0.0f;
        bpPtr->basePos.z = 0.0f;
        bpPtr->rot.x = ((f32) node->rot.x * 180.0) / 32767.0;
        bpPtr->rot.y = ((f32) node->rot.y * 180.0) / 32767.0;
        bpPtr->rot.z = ((f32) node->rot.z * 180.0) / 32767.0;
 
        newNode = add_anim_node(animator, parentNodeID, bpPtr);
 
        if (node->modelID != 0) {
            newNode->fcData.modelID = node->modelID - 1;
            newNode->flags |= MODEL_ANIMATOR_FLAG_HAS_MODEL;
        }
 
        i = 0;
        while (gAnimTreeRoot[i] != node) {
            i++;
        }
 
        treeIndexToNodeIDs[i] = newNode->uniqueIndex;
 
        if (node->child != nullptr) {
            load_model_animator_node(node->child, animator, newNode->uniqueIndex, treeIndexToNodeIDs);
        }
 
        if (node->sibling != nullptr) {
            load_model_animator_node(node->sibling, animator, parentNodeID, treeIndexToNodeIDs);
        }
    }
}

Referenced by load_model_animator_node(), and load_model_animator_tree().

load_model_animator_tree()

void load_model_animator_tree	(	s32	index,
		StaticAnimatorNode **	tree )

Definition at line 1170 of file animator.c.

                                                                    {
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[index & ~BATTLE_ID_BIT];
    s32 nodeIDs[ARRAY_COUNT(animator->staticNodeIDs)];
 
    if (animator == nullptr || animator->flags == 0) {
        return;
    }
 
    gAnimTreeRoot = tree;
    load_model_animator_node(*tree, animator, 0, nodeIDs);
    set_animator_tree_to_node_map(animator, nodeIDs, ARRAY_COUNT(animator->staticNodeIDs));
}

Referenced by create_shadow_from_data(), load_mesh_animator_tree(), and load_split_entity_data().

load_mesh_animator_node()

void load_mesh_animator_node	(	StaticAnimatorNode *	node,
		ModelAnimator *	animator,
		s32	parentNodeID,
		s32 *	treeIndexToNodeIDs )

Definition at line 1183 of file animator.c.

                                                                                                                           {
    if (node != nullptr) {
        if (node->child != nullptr && parentNodeID == 0) {
            load_mesh_animator_node(node->child, animator, 0, treeIndexToNodeIDs);
        } else {
            do {
                animator->staticNodes[parentNodeID] = node;
                node = node->sibling;
                parentNodeID++;
            } while (node != nullptr);
        }
    }
}

Referenced by load_mesh_animator_node(), and load_mesh_animator_tree().

load_mesh_animator_tree()

void load_mesh_animator_tree	(	s32	index,
		StaticAnimatorNode **	tree )

Definition at line 1197 of file animator.c.

                                                                   {
    s32 indexMasked = index & ~BATTLE_ID_BIT;
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[indexMasked];
    s32 nodeIDs[ARRAY_COUNT(animator->staticNodeIDs)];
    s32 i;
 
    if (animator == nullptr || animator->flags == 0) {
        return;
    }
 
    if ((*tree)->vertexStartOffset == 0) {
        load_model_animator_tree(indexMasked, tree);
        return;
    }
 
    gAnimTreeRoot = tree;
    animator->staticRoot = tree;
    animator->treeIndexPos = 0;
    animator->savedTreePos = 0;
 
    for (i = 0; i < ARRAY_COUNT(animator->staticNodes); i++) {
        animator->staticNodes[i] = nullptr;
    }
 
    load_mesh_animator_node(*gAnimTreeRoot, animator, 0, nodeIDs);
    animator->flags |= MODEL_ANIMATOR_FLAG_MESH;
}

Referenced by load_split_entity_data().

reload_mesh_animator_node()

void reload_mesh_animator_node	(	StaticAnimatorNode *	node,
		ModelAnimator *	animator,
		s32	parentNodeID,
		s32 *	treeIndexToNodeIDs )

Definition at line 1225 of file animator.c.

                                                                                                                             {
    AnimatorNodeBlueprint bp;
    AnimatorNodeBlueprint* bpPtr = &bp;
    AnimatorNode* newNode;
    s32 i;
 
    if (node != nullptr) {
        bpPtr->displayList = node->displayList;
        bpPtr->basePos.x = 0.0f;
        bpPtr->basePos.y = 0.0f;
        bpPtr->basePos.z = 0.0f;
        bpPtr->rot.x = ((f32) node->rot.x * 180.0) / 32767.0;
        bpPtr->rot.y = ((f32) node->rot.y * 180.0) / 32767.0;
        bpPtr->rot.z = ((f32) node->rot.z * 180.0) / 32767.0;
 
        newNode = add_anim_node(animator, parentNodeID, bpPtr);
        newNode->vertexStartOffset = node->vertexStartOffset;
        newNode->fcData.vtxList = node->vtxList;
 
        i = 0;
        while (gAnimTreeRoot[i] != node) {
            i++;
        }
 
        treeIndexToNodeIDs[i] = newNode->uniqueIndex;
 
        if (node->child != nullptr) {
            reload_mesh_animator_node(node->child, animator, newNode->uniqueIndex, treeIndexToNodeIDs);
        }
    }
}

Referenced by reload_mesh_animator_node(), and reload_mesh_animator_tree().

reload_mesh_animator_tree()

void reload_mesh_animator_tree

(

ModelAnimator *

animator

)

Definition at line 1257 of file animator.c.

                                                        {
    s32 nodeIDs[ARRAY_COUNT(animator->staticNodeIDs)];
    s32 i;
 
    delete_model_animator_nodes(animator);
    gAnimTreeRoot = animator->staticRoot;
 
    for (i = 0; i < ARRAY_COUNT(animator->staticNodes); i++) {
        nodeIDs[i] = 0;
    }
 
    reload_mesh_animator_node(animator->staticNodes[animator->treeIndexPos], animator, 0, nodeIDs);
    nodeIDs[0] = -1;
    set_animator_tree_to_node_map(animator, nodeIDs, ARRAY_COUNT(nodeIDs));
}

Referenced by step_mesh_animator(), update_model_animator(), and update_model_animator_with_transform().

step_mesh_animator()

s32 step_mesh_animator

(

ModelAnimator *

animator

)

Definition at line 1273 of file animator.c.

                                                {
    s16* args = animator->animReadPos;
    s16* oldPos = animator->animReadPos;
    AnimatorNode* node;
    f32 x, y, z;
    s32 flags;
    s32 nodeId;
 
    switch (*args++) {
        case AS_END:
            return -1;
        case AS_SET_RENDER_MODE:
            animator->renderMode = *args++;
            animator->animReadPos = args;
            return 1;
        case AS_WAIT:
            args++;
            animator->animReadPos = args;
            return 1;
        case AS_END_LOOP:
            animator->animReadPos = animator->savedReadPos;
            animator->treeIndexPos = animator->savedTreePos;
            reload_mesh_animator_tree(animator);
            return 1;
        case AS_OP_4:
            animator->animReadPos = animator->savedReadPos;
            animator->treeIndexPos = animator->savedTreePos;
            break;
        case AS_LOOP:
            animator->animReadPos = animator->savedReadPos = args;
            animator->savedTreePos = animator->treeIndexPos;
            return 1;
        case AS_SET_FLAGS:
            flags = *args++;
            animator->animReadPos = args;
            animator->flags |= flags & 0xFFFF;
            return 1;
        case AS_SET_NODE_FLAGS:
            node = get_animator_child_with_id(animator, animator->staticNodeIDs[*args++ - 1]);
            flags = *args++;
            node->flags |= flags;
            animator->animReadPos = args;
            return 1;
        case AS_CLEAR_NODE_FLAGS:
            node = get_animator_child_with_id(animator, animator->staticNodeIDs[*args++ - 1]);
            flags = *args++;
            node->flags &= ~flags;
            animator->animReadPos = args;
            return 1;
        case AS_OP_19:
            animator->flags |= MODEL_ANIMATOR_FLAG_NO_FLIP;
            animator->animReadPos = args;
            return 1;
        case AS_SET_ROTATION:
            nodeId = animator->staticNodeIDs[*args++ - 1];
            x = (f32)*args++ * 180.0 / 32767.0;
            y = (f32)*args++ * 180.0 / 32767.0;
            z = (f32)*args++ * 180.0 / 32767.0;
            animator->animReadPos = args;
            if (nodeId != 0xFF) {
                node = get_animator_child_with_id(animator, nodeId);
                if (node != nullptr) {
                    node->rot.x = x;
                    node->rot.y = y;
                    node->rot.z = z;
                    return 1;
                } else {
                    animator->animReadPos = oldPos;
                    animator->treeIndexPos++;
                    break;
                }
            }
            return 1;
        case AS_ADD_ROTATION:
            nodeId = animator->staticNodeIDs[*args++ - 1];
            x = (f32)*args++ * 180.0 / 32767.0;
            y = (f32)*args++ * 180.0 / 32767.0;
            z = (f32)*args++ * 180.0 / 32767.0;
            animator->animReadPos = args;
            if (nodeId != 0xFF) {
                node = get_animator_child_with_id(animator, nodeId);
                if (node != nullptr) {
                    node->rot.x += x;
                    node->rot.y += y;
                    node->rot.z += z;
                    return 1;
                } else {
                    animator->animReadPos = oldPos;
                    animator->treeIndexPos++;
                    break;
                }
            }
            return 1;
        case AS_SET_POS:
            nodeId = animator->staticNodeIDs[*args++ - 1];
            x = *args++;
            y = *args++;
            z = *args++;
            animator->animReadPos = args;
            if (nodeId != 0xFF) {
                node = get_animator_child_with_id(animator, nodeId);
                if (node != nullptr) {
                    node->pos.x = x;
                    node->pos.y = y;
                    node->pos.z = z;
                    return 1;
                } else {
                    animator->animReadPos = oldPos;
                    animator->treeIndexPos++;
                    break;
                }
            }
            return 1;
        case AS_SET_SCALE:
            nodeId = animator->staticNodeIDs[*args++ - 1];
            x = (f32)*args++ * 180.0 / 32767.0;
            y = (f32)*args++ * 180.0 / 32767.0;
            z = (f32)*args++ * 180.0 / 32767.0;
            animator->animReadPos = args;
            if (nodeId != 0xFF) {
                node = get_animator_child_with_id(animator, nodeId);
                if (node != nullptr) {
                    node->scale.x = x;
                    node->scale.y = y;
                    node->scale.z = z;
                    return 1;
                } else {
                    animator->animReadPos = oldPos;
                    animator->treeIndexPos++;
                    break;
                }
            }
            return 1;
    }
    return 0;
}

Referenced by update_model_animator(), and update_model_animator_with_transform().

Variable Documentation

gAnimCount

s32 gAnimCount

Definition at line 12 of file animator.c.

Referenced by clear_animator_list(), create_mesh_animator(), create_model_animator(), delete_model_animator(), and reset_animator_list().

D_801533C0

BSS AnimatedMeshVertexCopyList D_801533C0

Definition at line 14 of file animator.c.

Referenced by animator_copy_vertices_to_buffer(), clear_animator_list(), update_model_animator(), and update_model_animator_with_transform().

D_801536C0

BSS AnimatedMeshVertexCopyList D_801536C0

Definition at line 15 of file animator.c.

Referenced by appendGfx_animator_node(), clear_animator_list(), update_model_animator(), and update_model_animator_with_transform().

D_801539C0

BSS AnimatedMeshList D_801539C0

Definition at line 16 of file animator.c.

Referenced by clear_animator_list(), and reset_animator_list().

D_80153A00

BSS AnimatedMeshList D_80153A00

Definition at line 17 of file animator.c.

Referenced by clear_animator_list(), and reset_animator_list().

gCurrentAnimMeshListPtr

BSS AnimatedMeshList* gCurrentAnimMeshListPtr

Definition at line 18 of file animator.c.

Referenced by clear_animator_list(), create_mesh_animator(), create_model_animator(), delete_model_animator(), get_animator_by_index(), and reset_animator_list().

gAnimModelFogEnabled

BSS s32 gAnimModelFogEnabled

Definition at line 19 of file animator.c.

Referenced by appendGfx_animator(), appendGfx_animator_node(), clear_animator_list(), disable_anim_model_fog(), enable_anim_model_fog(), is_anim_model_fog_enabled(), and reset_animator_list().

gAnimModelFogR

BSS s32 gAnimModelFogR

Definition at line 20 of file animator.c.

Referenced by appendGfx_animator(), clear_animator_list(), get_anim_model_fog_color(), reset_animator_list(), and set_anim_model_fog_color().

gAnimModelFogG

BSS s32 gAnimModelFogG

Definition at line 21 of file animator.c.

Referenced by appendGfx_animator(), clear_animator_list(), get_anim_model_fog_color(), reset_animator_list(), and set_anim_model_fog_color().

gAnimModelFogB

BSS s32 gAnimModelFogB

Definition at line 22 of file animator.c.

Referenced by appendGfx_animator(), clear_animator_list(), get_anim_model_fog_color(), reset_animator_list(), and set_anim_model_fog_color().

gAnimModelFogA

BSS s32 gAnimModelFogA

Definition at line 23 of file animator.c.

Referenced by appendGfx_animator(), clear_animator_list(), get_anim_model_fog_color(), reset_animator_list(), and set_anim_model_fog_color().

gAnimModelFogStart

BSS s32 gAnimModelFogStart

Definition at line 24 of file animator.c.

Referenced by appendGfx_animator(), clear_animator_list(), get_anim_model_fog_distance(), reset_animator_list(), and set_anim_model_fog_dist().

gAnimModelFogEnd

BSS s32 gAnimModelFogEnd

Definition at line 25 of file animator.c.

Referenced by appendGfx_animator(), clear_animator_list(), get_anim_model_fog_distance(), reset_animator_list(), and set_anim_model_fog_dist().

gAnimVtxSegment

BSS s32 gAnimVtxSegment

Definition at line 26 of file animator.c.

Referenced by appendGfx_animator(), and render_animated_model_with_vertices().

gAnimRotMtx

BSS Matrix4f gAnimRotMtx

Definition at line 27 of file animator.c.

Referenced by animator_node_update_model_transform().

gAnimScaleMtx

BSS Matrix4f gAnimScaleMtx

Definition at line 28 of file animator.c.

Referenced by animator_node_update_model_transform().

gAnimTranslateMtx

BSS Matrix4f gAnimTranslateMtx

Definition at line 29 of file animator.c.

Referenced by animator_node_update_model_transform().

gAnimRotScaleMtx

BSS Matrix4f gAnimRotScaleMtx

Definition at line 30 of file animator.c.

Referenced by animator_node_update_model_transform().

gAnimTreeRoot

BSS StaticAnimatorNode** gAnimTreeRoot

Definition at line 31 of file animator.c.

Referenced by load_mesh_animator_tree(), load_model_animator_node(), load_model_animator_tree(), reload_mesh_animator_node(), and reload_mesh_animator_tree().

Gfx_RM1_SURFACE_OPA

Gfx Gfx_RM1_SURFACE_OPA

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD |
                          G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 643 of file model.c.

                            {
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD |
                          G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM1_DECAL_OPA

Gfx Gfx_RM1_DECAL_OPA

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_DECAL, G_RM_AA_ZB_OPA_DECAL2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD |
                          G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 654 of file model.c.

                          {
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_DECAL, G_RM_AA_ZB_OPA_DECAL2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD |
                          G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM1_INTERSECTING_OPA

Gfx Gfx_RM1_INTERSECTING_OPA

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_INTER, G_RM_AA_ZB_OPA_INTER2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD |
                          G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 665 of file model.c.

                                 {
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_INTER, G_RM_AA_ZB_OPA_INTER2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD |
                          G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM1_ALPHATEST

Gfx Gfx_RM1_ALPHATEST

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_EDGE2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 676 of file model.c.

                          {
    gsDPSetRenderMode(G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_EDGE2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM1_SURFACE_XLU

Gfx Gfx_RM1_SURFACE_XLU

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_AA_ZB_XLU_SURF, G_RM_AA_ZB_XLU_SURF2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 686 of file model.c.

                            {
    gsDPSetRenderMode(G_RM_AA_ZB_XLU_SURF, G_RM_AA_ZB_XLU_SURF2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM1_DECAL_XLU

Gfx Gfx_RM1_DECAL_XLU

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_AA_ZB_XLU_DECAL, G_RM_AA_ZB_XLU_DECAL2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 696 of file model.c.

                          {
    gsDPSetRenderMode(G_RM_AA_ZB_XLU_DECAL, G_RM_AA_ZB_XLU_DECAL2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM1_INTERSECTING_XLU

Gfx Gfx_RM1_INTERSECTING_XLU

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_AA_ZB_XLU_INTER, G_RM_AA_ZB_XLU_INTER2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 706 of file model.c.

                                 {
    gsDPSetRenderMode(G_RM_AA_ZB_XLU_INTER, G_RM_AA_ZB_XLU_INTER2),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM3_SURFACE_OPA

Gfx Gfx_RM3_SURFACE_OPA

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_OPA_SURF2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 1067 of file model.c.

                            {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_OPA_SURF2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM3_DECAL_OPA

Gfx Gfx_RM3_DECAL_OPA

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_OPA_DECAL2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 1077 of file model.c.

                          {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_OPA_DECAL2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM3_INTERSECTING_OPA

Gfx Gfx_RM3_INTERSECTING_OPA

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_OPA_INTER2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 1087 of file model.c.

                                 {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_OPA_INTER2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BACK | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM3_ALPHATEST

Gfx Gfx_RM3_ALPHATEST

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_TEX_EDGE2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 1097 of file model.c.

                          {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_TEX_EDGE2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM3_SURFACE_XLU

Gfx Gfx_RM3_SURFACE_XLU

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_XLU_SURF2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 1107 of file model.c.

                            {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_XLU_SURF2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM3_DECAL_XLU

Gfx Gfx_RM3_DECAL_XLU

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_XLU_DECAL2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 1117 of file model.c.

                          {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_XLU_DECAL2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

Gfx_RM3_INTERSECTING_XLU

Gfx Gfx_RM3_INTERSECTING_XLU

extern

Initial value:

= {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_XLU_INTER2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
}

Definition at line 1127 of file model.c.

                                 {
    gsDPSetRenderMode(G_RM_FOG_SHADE_A, G_RM_AA_ZB_XLU_INTER2),
    gsDPSetCycleType(G_CYC_2CYCLE),
    gsSPClearGeometryMode(G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_FOG | G_LIGHTING | G_SHADING_SMOOTH),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_animator().

gAnimScriptDefault

AnimScript gAnimScriptDefault

Initial value:

= {
    AS_WAIT,  60 ,
     AS_END, 
}

Definition at line 48 of file animator.c.

                                {
    as_Wait(60)
    as_End
};

Referenced by create_model_animator().