model.h File Reference

Go to the source code of this file.

Data Structures
union	ModelNodePropertyData
struct	ModelBoundingBox
struct	ModelNodeProperty
struct	ModelGroupData
struct	ModelDisplayData
struct	ModelNode
struct	Model
struct	ModelTransformGroup
struct	ModelIDList
struct	ModelLocalVertexCopy
struct	ModelTreeInfo
struct	TextureHandle
struct	ModelBlueprint
struct	ShapeFileHeader
struct	ShapeFile

Macros
#define	SHAPE_SIZE_LIMIT   0x8000

Typedefs
typedef Model *	ModelList[256]
typedef ModelTransformGroup *	ModelTransformGroupList[4]
typedef ModelLocalVertexCopy *	ModelLocalVertexCopyList[16]
typedef void(*	ModelCustomGfxBuilderFunc) (s32 index)
typedef Gfx *	ModelCustomGfxList[32]
typedef ModelCustomGfxBuilderFunc	ModelCustomGfxBuilderList[32]
typedef ModelTreeInfo	ModelTreeInfoList[0x200]

Enumerations
enum	ModelPropertyKeys {   MODEL_PROP_KEY_RENDER_MODE = 0x5C , MODEL_PROP_KEY_CAMERA_DATA = 0x5D , MODEL_PROP_KEY_TEXTURE_NAME = 0x5E , MODEL_PROP_KEY_SPECIAL = 0x5F ,   MODEL_PROP_KEY_GROUP_INFO = 0x60 , MODEL_PROP_KEY_BOUNDING_BOX = 0x61 , MODEL_PROP_KEY_62 = 0x62 }
enum	ShapeTypes { SHAPE_TYPE_MODEL = 2 , SHAPE_TYPE_GROUP = 5 , SHAPE_TYPE_ROOT = 7 , SHAPE_TYPE_SPECIAL_GROUP = 10 }
enum	GroupTypes { GROUP_TYPE_0 = 0 , GROUP_TYPE_1 = 1 }
enum	ExtraTileTypes {   EXTRA_TILE_NONE = 0 , EXTRA_TILE_MIPMAPS = 1 , EXTRA_TILE_AUX_SAME_AS_MAIN = 2 , EXTRA_TILE_AUX_INDEPENDENT = 3 ,   EXTRA_TILE_4 = 4 }

Functions
void	mdl_set_depth_tint_params (u8 primR, u8 primG, u8 primB, u8 primA, u8 fogR, u8 fogG, u8 fogB, s32 fogStart, s32 fogEnd)
void	mdl_set_remap_tint_params (u8 primR, u8 primG, u8 primB, u8 envR, u8 envG, u8 envB)
void	mdl_get_remap_tint_params (u8 *primR, u8 *primG, u8 *primB, u8 *envR, u8 *envG, u8 *envB)
void	init_model_data (void)
void	update_model_animator (s32)
void	update_model_animator_with_transform (s32 animatorID, Mtx *mtx)
void	set_mdl_custom_gfx_set (Model *, s32, u32)
ModelNodeProperty *	get_model_property (ModelNode *node, ModelPropertyKeys key)
void	load_texture_variants (u32 romOffset, s32 textureID, s32 baseOffset, s32 size)
s32	step_model_animator (ModelAnimator *animator)
AnimatorNode *	get_animator_node_for_tree_index (ModelAnimator *animator, s32 treeIndex)
AnimatorNode *	get_animator_node_with_id (ModelAnimator *animator, s32 id)
void	animator_update_model_transforms (ModelAnimator *animator, Mtx *rootTransform)
void	render_animated_model (s32 animatorID, Mtx *rootTransform)
void	animator_node_update_model_transform (ModelAnimator *animator, f32(*flipMtx)[4], AnimatorNode *node, Mtx *rootTransform)
void	init_worker_list (void)
ModelAnimator *	get_animator_by_index (s32 animModelID)
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)
void	render_animated_model_with_vertices (s32 animatorID, Mtx *rootTransform, s32 segment, void *baseAddr)
void	appendGfx_animator (ModelAnimator *animator)
ModelAnimator *	set_animator_render_callback (s32 animModelID, void *callbackArg, void(*callbackFunc)(void *))
void	reload_mesh_animator_tree (ModelAnimator *animator)
s32	step_mesh_animator (ModelAnimator *animator)
void	set_custom_gfx_builders (s32 customGfxIndex, ModelCustomGfxBuilderFunc pre, ModelCustomGfxBuilderFunc post)
void	mdl_make_local_vertex_copy (s32 arg0, u16 treeIdx, s32)
void	play_model_animation_starting_from (s32 index, s16 *animPos, s32 framesToSkip)
void	mdl_set_shroud_tint_params (u8 r, u8 g, u8 b, u8 a)

Variables
ModelTreeInfoList *	gCurrentModelTreeNodeInfo
ModelList *	gCurrentModels

---

Data Structure Documentation

ModelNodePropertyData

union ModelNodePropertyData

Data Fields
s32	s
f32	f
void *	p

ModelBoundingBox

struct ModelBoundingBox

Data Fields
s32	key
s32	halfSizeX
f32	minX
char	unk_0C[0x04]
s32	halfSizeY
f32	minY
char	unk_18[0x04]
s32	halfSizeZ
f32	minZ
char	unk_24[0x8]
f32	maxX
char	unk_30[0x8]
f32	maxY
char	unk_3C[0x8]
f32	maxZ

ModelNodeProperty

struct ModelNodeProperty

Data Fields
s32	key
s32	dataType
ModelNodePropertyData	data

ModelGroupData

struct ModelGroupData

Data Fields
Mtx *	transformMatrix
Lightsn *	lightingGroup
s32	numLights
s32	numChildren
struct ModelNode **	childList

ModelDisplayData

struct ModelDisplayData

Data Fields
Gfx *	displayList
char	unk_04[0x4]

ModelNode

struct ModelNode

Data Fields
s32	type
ModelDisplayData *	displayData
s32	numProperties
ModelNodeProperty *	propertyList
struct ModelGroupData *	groupData

Model

struct Model

Data Fields
u16	flags
u16	modelID
Mtx *	bakedMtx
ModelNode *	modelNode
ModelGroupData *	groupData
Mtx *	finalMtx
char	unk_14[4]
Mtx	savedMtx
Matrix4f	userTransformMtx
Vec3f	center
u8	texPannerID
u8	customGfxIndex
s8	renderMode
u8	matrixFreshness
u8	textureID
s8	textureVariation
char	unk_AA[6]

ModelTransformGroup

struct ModelTransformGroup

Data Fields
u16	flags
u16	groupModelID
Mtx *	bakedMtx
ModelNode *	baseModelNode
Mtx *	finalMtx
Mtx	savedMtx
Matrix4f	userTransformMtx
Vec3f	center
u8	minChildModelIndex
u8	maxChildModelIndex
u8	renderMode
u8	matrixFreshness

ModelIDList

struct ModelIDList

Data Fields
u16	count
u16	list[]

ModelLocalVertexCopy

struct ModelLocalVertexCopy

Data Fields
s32	numVertices
Vtx *	minVertexAddr
Gfx *	gfxCopy[2]
Vtx *	vtxCopy[2]
s32	selector

ModelTreeInfo

struct ModelTreeInfo

Data Fields
u8	modelIndex
u8	treeDepth
u8	textureID
char	unk_03

TextureHandle

struct TextureHandle

Data Fields
Gfx *	gfx
TextureHeader	header
u8 *	raster
u16 *	palette
u8 *	auxRaster
u16 *	auxPalette

ModelBlueprint

struct ModelBlueprint

Data Fields
s16	flags
char	unk_02[0x2]
ModelNode *	mdlNode
ModelGroupData *	groupData
Mtx *	mtx

ShapeFileHeader

struct ShapeFileHeader

Data Fields
ModelNode *	root
Vtx_t *	vertexTable
char **	modelNames
char **	colliderNames
char **	zoneNames
unsigned char	pad_14[0xC]

ShapeFile

struct ShapeFile

Data Fields
ShapeFileHeader	header
u8	data[0x8000 - sizeof(ShapeFileHeader)]

Macro Definition Documentation

SHAPE_SIZE_LIMIT

#define SHAPE_SIZE_LIMIT   0x8000

Definition at line 171 of file model.h.

Typedef Documentation

ModelList

typedef Model* ModelList[256]

Definition at line 94 of file model.h.

ModelTransformGroupList

typedef ModelTransformGroup* ModelTransformGroupList[4]

Definition at line 95 of file model.h.

ModelLocalVertexCopyList

typedef ModelLocalVertexCopy* ModelLocalVertexCopyList[16]

Definition at line 110 of file model.h.

ModelCustomGfxBuilderFunc

typedef void(* ModelCustomGfxBuilderFunc) (s32 index)

Definition at line 136 of file model.h.

ModelCustomGfxList

typedef Gfx* ModelCustomGfxList[32]

Definition at line 138 of file model.h.

ModelCustomGfxBuilderList

typedef ModelCustomGfxBuilderFunc ModelCustomGfxBuilderList[32]

Definition at line 139 of file model.h.

ModelTreeInfoList

typedef ModelTreeInfo ModelTreeInfoList[0x200]

Definition at line 187 of file model.h.

Enumeration Type Documentation

ModelPropertyKeys

enum ModelPropertyKeys

Enumerator
MODEL_PROP_KEY_RENDER_MODE
MODEL_PROP_KEY_CAMERA_DATA
MODEL_PROP_KEY_TEXTURE_NAME
MODEL_PROP_KEY_SPECIAL
MODEL_PROP_KEY_GROUP_INFO
MODEL_PROP_KEY_BOUNDING_BOX
MODEL_PROP_KEY_62

Definition at line 141 of file model.h.

                               {
    MODEL_PROP_KEY_RENDER_MODE      = 0x5C,
    MODEL_PROP_KEY_CAMERA_DATA      = 0x5D,
    MODEL_PROP_KEY_TEXTURE_NAME     = 0x5E,
    MODEL_PROP_KEY_SPECIAL          = 0x5F,
    MODEL_PROP_KEY_GROUP_INFO       = 0x60,
    MODEL_PROP_KEY_BOUNDING_BOX     = 0x61,
    MODEL_PROP_KEY_62               = 0x62,
} ModelPropertyKeys;

ShapeTypes

enum ShapeTypes

Enumerator
SHAPE_TYPE_MODEL
SHAPE_TYPE_GROUP
SHAPE_TYPE_ROOT
SHAPE_TYPE_SPECIAL_GROUP

Definition at line 151 of file model.h.

                        {
    SHAPE_TYPE_MODEL                = 2,
    SHAPE_TYPE_GROUP                = 5,
    SHAPE_TYPE_ROOT                 = 7,
    SHAPE_TYPE_SPECIAL_GROUP        = 10,
} ShapeTypes;

GroupTypes

enum GroupTypes

Enumerator
GROUP_TYPE_0
GROUP_TYPE_1

Definition at line 158 of file model.h.

                        {
    GROUP_TYPE_0                    = 0,
    GROUP_TYPE_1                    = 1,
} GroupTypes;

ExtraTileTypes

enum ExtraTileTypes

Enumerator
EXTRA_TILE_NONE
EXTRA_TILE_MIPMAPS
EXTRA_TILE_AUX_SAME_AS_MAIN
EXTRA_TILE_AUX_INDEPENDENT
EXTRA_TILE_4

Definition at line 163 of file model.h.

                            {
    EXTRA_TILE_NONE                 = 0, // texture contains only a single tile
    EXTRA_TILE_MIPMAPS              = 1, // texture contais mipmaps
    EXTRA_TILE_AUX_SAME_AS_MAIN     = 2, // texture contains main and aux images with identical fmt and size
    EXTRA_TILE_AUX_INDEPENDENT      = 3, // texture contains main and aux images with independent fmt and size
    EXTRA_TILE_4                    = 4, // only use-case may be a mistake? unused and mostly unimplemented
} ExtraTileTypes;

Function Documentation

mdl_set_depth_tint_params()

void mdl_set_depth_tint_params	(	u8	primR,
		u8	primG,
		u8	primB,
		u8	primA,
		u8	fogR,
		u8	fogG,
		u8	fogB,
		s32	fogStart,
		s32	fogEnd )

Definition at line 3916 of file model.c.

                                                                                                                            {
    DepthTintBaseR = primR;
    DepthTintBaseG = primG;
    DepthTintBaseB = primB;
    DepthTintBaseA = primA;
    DepthTintColR = fogR;
    DepthTintColG = fogG;
    DepthTintColB = fogB;
    DepthTintStart = fogStart;
    DepthTintEnd = fogEnd;
}

mdl_set_remap_tint_params()

void mdl_set_remap_tint_params	(	u8	primR,
		u8	primG,
		u8	primB,
		u8	envR,
		u8	envG,
		u8	envB )

Definition at line 3941 of file model.c.

                                                                                     {
    RemapTintMaxR = maxR;
    RemapTintMaxG = maxG;
    RemapTintMaxB = maxB;
    RemapTintMinR = minR;
    RemapTintMinG = minG;
    RemapTintMinB = minB;
}

mdl_get_remap_tint_params()

void mdl_get_remap_tint_params	(	u8 *	primR,
		u8 *	primG,
		u8 *	primB,
		u8 *	envR,
		u8 *	envG,
		u8 *	envB )

Definition at line 3950 of file model.c.

                                                                                              {
    *primR = RemapTintMaxR;
    *primG = RemapTintMaxG;
    *primB = RemapTintMaxB;
    *envR = RemapTintMinR;
    *envG = RemapTintMinG;
    *envB = RemapTintMinB;
}

Referenced by appendGfx_background_texture().

init_model_data()

void init_model_data

(

void

)

Definition at line 2430 of file model.c.

                           {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentModels = &wModelList;
        gCurrentTransformGroups = &wTransformGroups;
        gCurrentCustomModelGfxPtr = &wCustomModelGfx;
        gCurrentCustomModelGfxBuildersPtr = &wCustomModelGfxBuilders;
        gCurrentModelTreeRoot = &wModelTreeRoot;
        gCurrentModelLocalVtxBuffers = &wModelLocalVtxBuffers;
        gCurrentModelTreeNodeInfo = &wModelTreeNodeInfo;
        gBackgroundTintModePtr = &wBackgroundTintMode;
        gFogSettings = &wFogSettings;
    } else {
        gCurrentModels = &bModelList;
        gCurrentTransformGroups = &bTransformGroups;
        gCurrentCustomModelGfxPtr = &bCustomModelGfx;
        gCurrentCustomModelGfxBuildersPtr = &bCustomModelGfxBuilders;
        gCurrentModelTreeRoot = &bModelTreeRoot;
        gCurrentModelLocalVtxBuffers = &bModelLocalVtxBuffers;
        gCurrentModelTreeNodeInfo = &bModelTreeNodeInfo;
        gBackgroundTintModePtr = &bBackgroundTintMode;
        gFogSettings = &bFogSettings;
    }
}

Referenced by state_step_end_battle(), and state_step_unpause().

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().

set_mdl_custom_gfx_set()

void set_mdl_custom_gfx_set	(	Model *	model,
		s32	customGfxIndex,
		u32	tintType )

Definition at line 3828 of file model.c.

                                                                            {
    if (customGfxIndex == -1) {
        customGfxIndex = model->customGfxIndex & 0xF;
    }
 
    if (tintType == -1) {
        tintType = model->customGfxIndex >> 4;
    }
 
    model->customGfxIndex = (customGfxIndex & 0xF) + ((tintType & 0xF) << 4);
}

Referenced by mdl_set_all_tint_type().

get_model_property()

ModelNodeProperty * get_model_property	(	ModelNode *	node,
		ModelPropertyKeys	key )

Definition at line 2284 of file model.c.

                                                                              {
    s32 numProperties = node->numProperties;
    ModelNodeProperty* propertyList = node->propertyList;
    s32 i;
 
    for (i = 0; i < numProperties; i++, propertyList++) {
        if (propertyList->key == key) {
            return propertyList;
        }
    }
    return nullptr;
}

Referenced by appendGfx_model(), func_80117D00(), func_8011B1D8(), get_model_center_and_size(), load_model_transforms(), load_next_model_textures(), mdl_calculate_model_sizes(), mdl_create_model(), mdl_make_transform_group(), mdl_update_transform_matrices(), and render_transform_group_node().

load_texture_variants()

void load_texture_variants	(	u32	romOffset,
		s32	textureID,
		s32	baseOffset,
		s32	size )

Definition at line 2172 of file model.c.

                                                                                   {
    u32 offset;
    TextureHeader iterTextureHeader;
    TextureHeader* header;
    TextureHandle* textureHandle;
    u32 rasterSize;
    s32 paletteSize;
    u32 auxRasterSize;
    u32 auxPaletteSize;
    s32 mainSize;
    s32 currentTextureID = textureID;
 
    for (offset = romOffset; offset < baseOffset + size;) {
        dma_copy((u8*)offset, (u8*)offset + sizeof(iterTextureHeader), &iterTextureHeader);
        header = &iterTextureHeader;
 
        if (strcmp(header->name, "end_of_textures") == 0) {
            return;
        }
 
        if (!header->isVariant) {
            // done reading variants
            break;
        }
 
        rasterSize = header->mainW * header->mainH;
 
        // compute mipmaps size
        if (header->mainBitDepth == G_IM_SIZ_4b) {
            if (header->extraTiles == EXTRA_TILE_MIPMAPS) {
                s32 d = 2;
                while (header->mainW / d >= 16 && header->mainH / d > 0) {
                    rasterSize += header->mainW / d * header->mainH / d;
                    d *= 2;
                }
            }
            rasterSize /= 2;
        } else if (header->mainBitDepth == G_IM_SIZ_8b) {
            if (header->extraTiles == EXTRA_TILE_MIPMAPS) {
                s32 d = 2;
                while (header->mainW / d >= 8 && header->mainH / d > 0) {
                    rasterSize += header->mainW / d * header->mainH / d;
                    d *= 2;
                }
            }
        } else if (header->mainBitDepth == G_IM_SIZ_16b) {
            if (header->extraTiles == EXTRA_TILE_MIPMAPS) {
                s32 d = 2;
                while (header->mainW / d >= 4 && header->mainH / d > 0) {
                    rasterSize += header->mainW / d * header->mainH / d;
                    d *= 2;
                }
            }
            rasterSize *= 2;
        } else if (header->mainBitDepth == G_IM_SIZ_32b) {
            if (header->extraTiles == EXTRA_TILE_MIPMAPS) {
                s32 d = 2;
                while (header->mainW / d >= 2 && header->mainH / d > 0) {
                    rasterSize += header->mainW / d * header->mainH / d;
                    d *= 2;
                }
            }
            rasterSize *= 4;
        }
 
        // compute palette size
        if (header->mainFmt == G_IM_FMT_CI) {
            paletteSize = 0x20;
            if (header->mainBitDepth == G_IM_SIZ_8b) {
                paletteSize = 0x200;
            }
        } else {
            paletteSize = 0;
        }
 
        // compute aux tile size
        if (header->extraTiles == EXTRA_TILE_AUX_INDEPENDENT) {
            auxRasterSize = header->auxW * header->auxH;
            if (header->auxBitDepth == G_IM_SIZ_4b) {
                auxRasterSize /= 2;
            } else if (header->auxBitDepth == G_IM_SIZ_8b) {
            } else if (header->auxBitDepth == G_IM_SIZ_16b) {
                auxRasterSize *= 2;
            } else {
                if (header->auxBitDepth == G_IM_SIZ_32b) {
                    auxRasterSize *= 4;
                }
            }
            if (header->auxFmt == G_IM_FMT_CI) {
                auxPaletteSize = 0x20;
                if (header->auxBitDepth == G_IM_SIZ_8b) {
                    auxPaletteSize = 0x200;
                }
            } else {
                auxPaletteSize = 0;
            }
        } else {
            auxPaletteSize = 0;
            auxRasterSize = 0;
        }
 
        textureID++;
        currentTextureID = textureID;
        textureHandle = &TextureHandles[currentTextureID];
        load_texture_impl(offset + sizeof(*header), textureHandle, header, rasterSize, paletteSize, auxRasterSize, auxPaletteSize);
 
        mainSize = rasterSize + paletteSize + sizeof(*header);
        offset += mainSize;
        offset += auxRasterSize + auxPaletteSize;
    }
}

Referenced by load_texture_by_name().

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().

get_animator_node_for_tree_index()

AnimatorNode * get_animator_node_for_tree_index	(	ModelAnimator *	animator,
		s32	treeIndex )

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);
}

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().

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().

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().

init_worker_list()

void init_worker_list

(

void

)

Definition at line 24 of file worker.c.

                            {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentWorkerListPtr = &gWorldWorkerList;
    } else {
        gCurrentWorkerListPtr = &gBattleWorkerList;
    }
}

Referenced by state_step_end_battle(), and state_step_unpause().

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().

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().

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().

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().

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().

set_custom_gfx_builders()

void set_custom_gfx_builders	(	s32	customGfxIndex,
		ModelCustomGfxBuilderFunc	pre,
		ModelCustomGfxBuilderFunc	post )

Definition at line 3845 of file model.c.

                                                                                                                {
    (*gCurrentCustomModelGfxBuildersPtr)[customGfxIndex * 2] = pre;
    (*gCurrentCustomModelGfxBuildersPtr)[customGfxIndex * 2 + 1] = post;
}

mdl_make_local_vertex_copy()

void mdl_make_local_vertex_copy	(	s32	arg0,
		u16	treeIdx,
		s32	isMakingCopy )

Definition at line 4035 of file model.c.

                                                                              {
    s32 numVertices;
    Vtx* baseVtx;
    s32 gfxCount;
    Gfx* nodeDlist;
    Model* model;
    ModelLocalVertexCopy* copy;
    s32 i;
 
    model = get_model_from_list_index(get_model_list_index_from_tree_index(modelID));
    nodeDlist = model->modelNode->displayData->displayList;
    mdl_get_vertex_count(nodeDlist, &numVertices, &baseVtx, &gfxCount, nullptr);
 
    copy = (*gCurrentModelLocalVtxBuffers)[copyIndex] = heap_malloc(sizeof(*copy));
 
    if (isMakingCopy) {
        for (i = 0; i < ARRAY_COUNT(copy->gfxCopy); i++) {
            copy->gfxCopy[i] = heap_malloc(gfxCount * sizeof(*copy->gfxCopy[i]));
            copy->vtxCopy[i] = heap_malloc(numVertices * sizeof(*copy->vtxCopy[i]));
            mdl_local_gfx_update_vtx_pointers(nodeDlist, baseVtx, copy->gfxCopy[i], copy->vtxCopy[i]);
            mdl_local_gfx_copy_vertices(baseVtx, numVertices, copy->vtxCopy[i]);
        }
        model->flags |= MODEL_FLAG_HAS_LOCAL_VERTEX_COPY;
    } else {
        for (i = 0; i < ARRAY_COUNT(copy->gfxCopy); i++) {
            copy->gfxCopy[i] = nullptr;
            copy->vtxCopy[i] = nullptr;
        }
        model->flags |= MODEL_FLAG_HIDDEN;
    }
 
    copy->selector = 0;
    copy->numVertices = numVertices;
    copy->minVertexAddr = baseVtx;
}

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);
    }
}

mdl_set_shroud_tint_params()

void mdl_set_shroud_tint_params	(	u8	r,
		u8	g,
		u8	b,
		u8	a )

Definition at line 3902 of file model.c.

                                                        {
    ShroudTintR = r;
    ShroudTintG = g;
    ShroudTintB = b;
    ShroudTintAmt = a;
}

Referenced by btl_state_update_celebration().

Variable Documentation

gCurrentModelTreeNodeInfo

ModelTreeInfoList* gCurrentModelTreeNodeInfo

extern

Definition at line 107 of file model.c.

gCurrentModels

ModelList* gCurrentModels

extern

Definition at line 106 of file model.c.

Referenced by clear_model_data(), clone_model(), get_model_from_list_index(), init_model_data(), mdl_calculate_model_sizes(), mdl_create_model(), mdl_reset_transform_flags(), mdl_set_all_tint_type(), mdl_update_transform_matrices(), and render_models().