quizmo_audience.c File Reference

Go to the source code of this file.

Data Structures
struct	QuizmoAudiencePositonOffsets

Functions
void	quizmo_audience_appendGfx (void *effect)
void	quizmo_audience_init (EffectInstance *effect)
void	quizmo_audience_update (EffectInstance *effect)
void	quizmo_audience_render (EffectInstance *effect)
EffectInstance *	quizmo_audience_main (s32 arg0, f32 posX, f32 posY, f32 posZ)
void	func_E00A8318 (void)

Variables
Gfx	D_09002EE0_3AA680 []
Gfx	D_09002F18_3AA6B8 []
Gfx	D_09002F50_3AA6F0 []
Gfx	D_09002F88_3AA728 []
Gfx	D_09002FC0_3AA760 []
Gfx	D_09002FF8_3AA798 []
Gfx	D_09003030_3AA7D0 []
Gfx	D_09003068_3AA808 []
Gfx	D_090030A0_3AA840 []
Gfx	D_090030D8_3AA878 []
Gfx	D_09003110_3AA8B0 []
Gfx *	quizmo_audience_renderAudienceMember []
Vec2b	quizmo_audience_horizontalPosOffsets []
Vec2b	quizmo_audience_verticalPosOffsets []
QuizmoAudiencePositonOffsets	quizmo_audience_positionOffsets []

---

Data Structure Documentation

QuizmoAudiencePositonOffsets

struct QuizmoAudiencePositonOffsets

Data Fields
Vec2b *	offsets
u8	count

Function Documentation

quizmo_audience_appendGfx()

void quizmo_audience_appendGfx

(

void *

effect

)

Definition at line 183 of file quizmo_audience.c.

                                             {
    Matrix4f sp18;
    Matrix4f sp58;
    QuizmoAudienceFXData* data = ((EffectInstance*)effect)->data.quizmoAudience;
    s32 primColor = data->primColor;
    s32 i;
 
    gDPPipeSync(gMainGfxPos++);
    gSPSegment(gMainGfxPos++, 0x09, VIRTUAL_TO_PHYSICAL(((EffectInstance*)effect)->graphics->data));
 
    guTranslateF(sp18, data->pos.x, data->pos.y, data->pos.z);
    guRotateF(sp58, -gCameras[gCurrentCameraID].curYaw, 0.0f, 1.0f, 0.0f);
    guMtxCatF(sp58, sp18, sp18);
    guMtxF2L(sp18, &gDisplayContext->matrixStack[gMatrixListPos]);
 
    gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++],
              G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
    gDPSetPrimColor(gMainGfxPos++, 0, 0, primColor, primColor, primColor, 255);
    gSPDisplayList(gMainGfxPos++, D_09003110_3AA8B0);
 
    for (i = 0; i < MAX_QUIZMO_AUDIENCE; i++) {
        guTranslateF(sp18, data->compX[i], data->compY[i], 0.0f);
        guMtxF2L(sp18, &gDisplayContext->matrixStack[gMatrixListPos]);
 
        gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++],
                  G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
        gSPDisplayList(gMainGfxPos++, quizmo_audience_renderAudienceMember[i]);
        gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
    }
 
    gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
    gDPPipeSync(gMainGfxPos++);
}

Referenced by quizmo_audience_render().

quizmo_audience_init()

void quizmo_audience_init

(

EffectInstance *

effect

)

Definition at line 114 of file quizmo_audience.c.

                                                  {
}

Referenced by quizmo_audience_main().

quizmo_audience_update()

void quizmo_audience_update

(

EffectInstance *

effect

)

Definition at line 117 of file quizmo_audience.c.

                                                    {
    QuizmoAudienceFXData* data = effect->data.quizmoAudience;
    QuizmoAudiencePositonOffsets* unkStruct;
    s32 posIdx;
    s32 i;
 
    if (effect->flags & FX_INSTANCE_FLAG_DISMISS) {
        effect->flags &= ~FX_INSTANCE_FLAG_DISMISS;
        data->timeLeft = 30;
    }
 
    if (data->timeLeft < 100) {
        data->timeLeft--;
    }
 
    data->lifeTime++;
    if (data->timeLeft < 0) {
        remove_effect(effect);
        return;
    }
 
    if (data->timeLeft < 16) {
        data->primColor = data->timeLeft * 16;
    }
 
    for (i = 0; i < MAX_QUIZMO_AUDIENCE; i++) {
        switch (data->compState[i]) {
            case 0:
                if (rand_int(10) == 10) {
                    data->compState[i] = 1;
                    data->compType[i] = rand_int(1);
                    data->compPosIdx[i] = 0;
                    data->compMoveMagnitude[i] = (rand_int(50) * 0.01) + 0.5;
                }
                break;
            case 1:
                posIdx = data->compPosIdx[i];
                unkStruct = &quizmo_audience_positionOffsets[data->compType[i]];
                if (data->compPosIdx[i] >= unkStruct->count) {
                    data->compState[i] = 0;
                } else {
                    data->compX[i] = unkStruct->offsets[posIdx].x * data->compMoveMagnitude[i];
                    data->compY[i] = unkStruct->offsets[posIdx].y * data->compMoveMagnitude[i];
                    data->compPosIdx[i]++;
                }
                break;
        }
    }
}

Referenced by quizmo_audience_main().

quizmo_audience_render()

void quizmo_audience_render

(

EffectInstance *

effect

)

Definition at line 167 of file quizmo_audience.c.

                                                    {
    RenderTask renderTask;
    RenderTask* retTask;
 
    renderTask.appendGfx = quizmo_audience_appendGfx;
    renderTask.appendGfxArg = effect;
    renderTask.dist = 0;
    renderTask.renderMode = RENDER_MODE_CLOUD_NO_ZCMP;
 
    retTask = queue_render_task(&renderTask);
    retTask->renderMode |= RENDER_TASK_FLAG_REFLECT_FLOOR;
}

Referenced by quizmo_audience_main().

quizmo_audience_main()

EffectInstance * quizmo_audience_main	(	s32	arg0,
		f32	posX,
		f32	posY,
		f32	posZ )

Definition at line 78 of file quizmo_audience.c.

                                                                             {
    EffectBlueprint effectBp;
    EffectInstance* effect;
    QuizmoAudienceFXData* data;
    s32 numParts = 1;
    s32 i;
 
    effectBp.init = quizmo_audience_init;
    effectBp.update = quizmo_audience_update;
    effectBp.renderWorld = quizmo_audience_render;
    effectBp.unk_00 = 0;
    effectBp.renderUI = NULL;
    effectBp.effectID = EFFECT_QUIZMO_AUDIENCE;
 
    effect = create_effect_instance(&effectBp);
    effect->numParts = numParts;
 
    data = effect->data.quizmoAudience = general_heap_malloc(numParts * sizeof(*data));
    ASSERT(data != NULL);
 
    data->timeLeft = 100;
    data->unk_00 = arg0;
    data->primColor = 255;
    data->pos.x = posX;
    data->pos.y = posY;
    data->pos.z = posZ;
    data->lifeTime = 0;
 
    for (i = 0; i < ARRAY_COUNT(data->compState); i++) {
        data->compState[i] = 0;
        data->compX[i] = data->compY[i] = 0.0f;
    }
 
    return effect;
}

func_E00A8318()

void func_E00A8318

(

void

)

Definition at line 180 of file quizmo_audience.c.

                         {
}

Variable Documentation

D_09002EE0_3AA680

Gfx D_09002EE0_3AA680[]

extern

D_09002F18_3AA6B8

Gfx D_09002F18_3AA6B8[]

extern

D_09002F50_3AA6F0

Gfx D_09002F50_3AA6F0[]

extern

D_09002F88_3AA728

Gfx D_09002F88_3AA728[]

extern

D_09002FC0_3AA760

Gfx D_09002FC0_3AA760[]

extern

D_09002FF8_3AA798

Gfx D_09002FF8_3AA798[]

extern

D_09003030_3AA7D0

Gfx D_09003030_3AA7D0[]

extern

D_09003068_3AA808

Gfx D_09003068_3AA808[]

extern

D_090030A0_3AA840

Gfx D_090030A0_3AA840[]

extern

D_090030D8_3AA878

Gfx D_090030D8_3AA878[]

extern

D_09003110_3AA8B0

Gfx D_09003110_3AA8B0[]

extern

Referenced by quizmo_audience_appendGfx().

quizmo_audience_renderAudienceMember

Gfx* quizmo_audience_renderAudienceMember[]

Initial value:

= {
    D_090030D8_3AA878, D_090030A0_3AA840, D_09003068_3AA808, D_09003030_3AA7D0, D_09002FF8_3AA798,
    D_09002FC0_3AA760, D_09002F88_3AA728, D_09002F50_3AA6F0, D_09002F18_3AA6B8, D_09002EE0_3AA680
}

Definition at line 21 of file quizmo_audience.c.

                                              {
    D_090030D8_3AA878, D_090030A0_3AA840, D_09003068_3AA808, D_09003030_3AA7D0, D_09002FF8_3AA798,
    D_09002FC0_3AA760, D_09002F88_3AA728, D_09002F50_3AA6F0, D_09002F18_3AA6B8, D_09002EE0_3AA680
};

Referenced by quizmo_audience_appendGfx().

quizmo_audience_horizontalPosOffsets

Vec2b quizmo_audience_horizontalPosOffsets[]

Initial value:

= {
    {0, 0},
    {1, 0},
    {2, 0},
    {2, 0},
    {3, 0},
    {3, 0},
    {3, 0},
    {2, 0},
    {2, 0},
    {1, 0},
    {1, 0},
    {0, 0},
    {0, 0},
    {-1, 0},
    {-2, 0},
    {-2, 0},
    {-3, 0},
    {-3, 0},
    {-3, 0},
    {-2, 0},
    {-2, 0},
    {-1, 0},
    {-1, 0},
    {0, 0},
}

Definition at line 26 of file quizmo_audience.c.

                                               {
    {0, 0},
    {1, 0},
    {2, 0},
    {2, 0},
    {3, 0},
    {3, 0},
    {3, 0},
    {2, 0},
    {2, 0},
    {1, 0},
    {1, 0},
    {0, 0},
    {0, 0},
    {-1, 0},
    {-2, 0},
    {-2, 0},
    {-3, 0},
    {-3, 0},
    {-3, 0},
    {-2, 0},
    {-2, 0},
    {-1, 0},
    {-1, 0},
    {0, 0},
};

quizmo_audience_verticalPosOffsets

Vec2b quizmo_audience_verticalPosOffsets[]

Initial value:

= {
    {0, 0},
    {0, 1},
    {0, 2},
    {0, 2},
    {0, 3},
    {0, 3},
    {0, 3},
    {0, 2},
    {0, 2},
    {0, 1},
    {0, 1},
    {0, 0},
}

Definition at line 53 of file quizmo_audience.c.

                                             {
    {0, 0},
    {0, 1},
    {0, 2},
    {0, 2},
    {0, 3},
    {0, 3},
    {0, 3},
    {0, 2},
    {0, 2},
    {0, 1},
    {0, 1},
    {0, 0},
};

quizmo_audience_positionOffsets

QuizmoAudiencePositonOffsets quizmo_audience_positionOffsets[]

Initial value:

= {
    { quizmo_audience_horizontalPosOffsets, ARRAY_COUNT(quizmo_audience_horizontalPosOffsets) },
    { quizmo_audience_verticalPosOffsets, ARRAY_COUNT(quizmo_audience_verticalPosOffsets) },
}

Definition at line 68 of file quizmo_audience.c.

                                                                 {
    { quizmo_audience_horizontalPosOffsets, ARRAY_COUNT(quizmo_audience_horizontalPosOffsets) },
    { quizmo_audience_verticalPosOffsets, ARRAY_COUNT(quizmo_audience_verticalPosOffsets) },
};

Referenced by quizmo_audience_update().