ui_node_model.c

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 UFO: Alien Invasion.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "../ui_main.h"
#include "../ui_internal.h"
#include "../ui_nodes.h"
#include "../ui_parse.h"
#include "../ui_input.h"
#include "../ui_internal.h"
#include "ui_node_model.h"
#include "ui_node_abstractnode.h"

#include "../../client.h"
#include "../../renderer/r_draw.h"
#include "../../renderer/r_mesh.h"
#include "../../renderer/r_mesh_anim.h"

#define EXTRADATA_TYPE modelExtraData_t
#define EXTRADATA(node) UI_EXTRADATA(node, EXTRADATA_TYPE)

#define ROTATE_SPEED    0.5
#define MAX_OLDREFVALUE MAX_VAR

static const uiBehaviour_t const *localBehaviour;

uiModel_t *UI_GetUIModel (const char *modelName)
{
    int i;
    uiModel_t *m;

    for (i = 0; i < ui_global.numModels; i++) {
        m = &ui_global.models[i];
        if (!strncmp(m->id, modelName, MAX_VAR))
            return m;
    }
    return NULL;
}

static void UI_ListUIModels_f (void)
{
    int i;

    /* search for UI models with same name */
    Com_Printf("UI models: %i\n", ui_global.numModels);
    for (i = 0; i < ui_global.numModels; i++)
        Com_Printf("id: %s\n...model: %s\n...need: %s\n\n", ui_global.models[i].id, ui_global.models[i].model, ui_global.models[i].need);
}

static void UI_ModelNodeDraw (uiNode_t *node)
{
    const char* ref = UI_GetReferenceString(node, EXTRADATA(node).model);
    char source[MAX_VAR];
    if (ref == NULL || ref[0] == '\0')
        source[0] = '\0';
    else
        Q_strncpyz(source, ref, sizeof(source));
    UI_DrawModelNode(node, source);
}

static vec3_t nullVector = {0, 0, 0};

static inline void UI_InitModelInfoView (uiNode_t *node, modelInfo_t *mi, uiModel_t *model)
{
    vec3_t nodeorigin;
    UI_GetNodeAbsPos(node, nodeorigin);
    nodeorigin[0] += node->size[0] / 2 + EXTRADATA(node).origin[0];
    nodeorigin[1] += node->size[1] / 2 + EXTRADATA(node).origin[1];
    nodeorigin[2] = EXTRADATA(node).origin[2];

    VectorCopy(EXTRADATA(node).scale, mi->scale);
    VectorCopy(EXTRADATA(node).angles, mi->angles);
    VectorCopy(nodeorigin, mi->origin);

    VectorCopy(nullVector, mi->center);
}

static void UI_DrawModelNodeWithUIModel (uiNode_t *node, const char *source, modelInfo_t *mi, uiModel_t *model)
{
    qboolean autoScaleComputed = qfalse;
    vec3_t autoScale;
    vec3_t autoCenter;

    while (model) {
        /* no animation */
        mi->frame = 0;
        mi->oldframe = 0;
        mi->backlerp = 0;

        assert(model->model);
        mi->model = R_RegisterModelShort(model->model);
        if (!mi->model) {
            model = model->next;
            continue;
        }

        mi->skin = model->skin;
        mi->name = model->model;

        /* set mi pointers to model */
        mi->origin = model->origin;
        mi->angles = model->angles;
        mi->center = model->center;
        mi->color = model->color;
        mi->scale = model->scale;

        if (model->tag && model->parent) {
            /* tag and parent defined */
            uiModel_t *parentModel;
            modelInfo_t pmi;
            vec3_t pmiorigin;
            animState_t *as;
            /* place this model part on an already existing model tag */
            parentModel = UI_GetUIModel(model->parent);
            if (!parentModel) {
                Com_Printf("UI Model: Could not get the model '%s'\n", model->parent);
                break;
            }
            pmi.model = R_RegisterModelShort(parentModel->model);
            if (!pmi.model) {
                Com_Printf("UI Model: Could not get the model '%s'\n", parentModel->model);
                break;
            }

            pmi.name = parentModel->model;

            pmi.origin = pmiorigin;
            pmi.angles = parentModel->angles;
            pmi.scale = parentModel->scale;
            pmi.center = parentModel->center;
            pmi.color = parentModel->color;

            pmi.origin[0] = parentModel->origin[0] + mi->origin[0];
            pmi.origin[1] = parentModel->origin[1] + mi->origin[1];
            pmi.origin[2] = parentModel->origin[2];
            /* don't count window offset twice for tagged models */
            mi->origin[0] -= node->root->pos[0];
            mi->origin[1] -= node->root->pos[1];

            /* autoscale? */
            if (EXTRADATA(node).autoscale) {
                if (!autoScaleComputed)
                    Sys_Error("Wrong order of model nodes - the tag and parent model node must be after the base model node");
                pmi.scale = autoScale;
                pmi.center = autoCenter;
            }

            as = &parentModel->animState;
            if (!as)
                Com_Error(ERR_DROP, "Model %s should have animState_t for animation %s - but doesn't\n", pmi.name, parentModel->anim);
            pmi.frame = as->frame;
            pmi.oldframe = as->oldframe;
            pmi.backlerp = as->backlerp;

            R_DrawModelDirect(mi, &pmi, model->tag);
        } else {
            /* no tag and no parent means - base model or single model */
            const char *ref;
            UI_InitModelInfoView(node, mi, model);
            Vector4Copy(node->color, mi->color);

            /* compute the scale and center for the first model.
             * it think its the bigger of composite models.
             * All next elements use the same result
             */
            if (EXTRADATA(node).autoscale) {
                if (!autoScaleComputed) {
                    vec2_t size;
                    size[0] = node->size[0] - node->padding;
                    size[1] = node->size[1] - node->padding;
                    R_ModelAutoScale(size, mi, autoScale, autoCenter);
                    autoScaleComputed = qtrue;
                } else {
                    mi->scale = autoScale;
                    mi->center = autoCenter;
                }
            }

            /* get the animation given by node properties */
            if (EXTRADATA(node).animation && *(char *) EXTRADATA(node).animation) {
                ref = UI_GetReferenceString(node, EXTRADATA(node).animation);
            /* otherwise use the standard animation from UI model definition */
            } else
                ref = model->anim;

            /* only base models have animations */
            if (ref && *ref) {
                animState_t *as = &model->animState;
                const char *anim = R_AnimGetName(as, mi->model);
                /* initial animation or animation change */
                if (!anim || (anim && strncmp(anim, ref, MAX_VAR)))
                    R_AnimChange(as, mi->model, ref);
                else
                    R_AnimRun(as, mi->model, cls.frametime * 1000);

                mi->frame = as->frame;
                mi->oldframe = as->oldframe;
                mi->backlerp = as->backlerp;
            }
            R_DrawModelDirect(mi, NULL, NULL);
        }

        /* next */
        model = model->next;
    }
}

void UI_DrawModelNode (uiNode_t *node, const char *source)
{
    modelInfo_t mi;
    uiModel_t *model;
    vec3_t nodeorigin;
    vec3_t autoScale;
    vec3_t autoCenter;

    assert(UI_NodeInstanceOf(node, "model"));           
    if (source[0] == '\0')
        return;

    model = UI_GetUIModel(source);
    /* direct model name - no UI model definition */
    if (!model) {
        /* prevent the searching for a model def in the next frame */
        mi.model = R_RegisterModelShort(source);
        mi.name = source;
        if (!mi.model) {
            Com_Printf("Could not find model '%s'\n", source);
            return;
        }
    }

    /* compute the absolute origin ('origin' property is relative to the node center) */
    UI_GetNodeAbsPos(node, nodeorigin);
    R_CleanupDepthBuffer(nodeorigin[0], nodeorigin[1], node->size[0], node->size[1]);
    if (EXTRADATA(node).clipOverflow)
        R_PushClipRect(nodeorigin[0], nodeorigin[1], node->size[0], node->size[1]);
    nodeorigin[0] += node->size[0] / 2 + EXTRADATA(node).origin[0];
    nodeorigin[1] += node->size[1] / 2 + EXTRADATA(node).origin[1];
    nodeorigin[2] = EXTRADATA(node).origin[2];

    mi.origin = nodeorigin;
    mi.angles = EXTRADATA(node).angles;
    mi.scale = EXTRADATA(node).scale;
    mi.center = nullVector;
    mi.color = node->color;
    mi.mesh = 0;

    /* special case to draw models with UI model */
    if (model) {
        UI_DrawModelNodeWithUIModel(node, source, &mi, model);
        if (EXTRADATA(node).clipOverflow)
            R_PopClipRect();
        return;
    }

    /* if the node is linked to a parent, the parent will display it */
    if (EXTRADATA(node).tag) {
        if (EXTRADATA(node).clipOverflow)
            R_PopClipRect();
        return;
    }

    /* autoscale? */
    if (EXTRADATA(node).autoscale) {
        vec2_t size;
        size[0] = node->size[0] - node->padding;
        size[1] = node->size[1] - node->padding;
        R_ModelAutoScale(size, &mi, autoScale, autoCenter);
    }

    /* no animation */
    mi.frame = 0;
    mi.oldframe = 0;
    mi.backlerp = 0;

    /* get skin */
    if (EXTRADATA(node).skin && *(char *) EXTRADATA(node).skin)
        mi.skin = atoi(UI_GetReferenceString(node, EXTRADATA(node).skin));
    else
        mi.skin = 0;

    /* do animations */
    if (EXTRADATA(node).animation && *(char *) EXTRADATA(node).animation) {
        animState_t *as;
        const char *ref;
        ref = UI_GetReferenceString(node, EXTRADATA(node).animation);

        /* check whether the cvar value changed */
        if (strncmp(EXTRADATA(node).oldRefValue, source, MAX_OLDREFVALUE)) {
            Q_strncpyz(EXTRADATA(node).oldRefValue, source, MAX_OLDREFVALUE);
            /* model has changed but mem is already reserved in pool */
            if (EXTRADATA(node).animationState) {
                Mem_Free(EXTRADATA(node).animationState);
                EXTRADATA(node).animationState = NULL;
            }
        }
        if (!EXTRADATA(node).animationState) {
            as = (animState_t *) Mem_PoolAlloc(sizeof(*as), cl_genericPool, 0);
            if (!as)
                Com_Error(ERR_DROP, "Model %s should have animState_t for animation %s - but doesn't\n", mi.name, ref);
            R_AnimChange(as, mi.model, ref);
            EXTRADATA(node).animationState = as;
        } else {
            const char *anim;
            /* change anim if needed */
            as = EXTRADATA(node).animationState;
            if (!as)
                Com_Error(ERR_DROP, "Model %s should have animState_t for animation %s - but doesn't\n", mi.name, ref);
            anim = R_AnimGetName(as, mi.model);
            if (anim && strcmp(anim, ref))
                R_AnimChange(as, mi.model, ref);
            R_AnimRun(as, mi.model, cls.frametime * 1000);
        }

        mi.frame = as->frame;
        mi.oldframe = as->oldframe;
        mi.backlerp = as->backlerp;
    }

    /* draw the main model on the node */
    R_DrawModelDirect(&mi, NULL, NULL);

    /* draw all childs */
    if (node->firstChild) {
        uiNode_t *child;
        modelInfo_t pmi = mi;
        for (child = node->firstChild; child; child = child->next) {
            const char *tag;
            char childSource[MAX_VAR];
            const char* childRef;

            /* skip non "model" nodes */
            if (child->behaviour != node->behaviour)
                continue;

            /* skip invisible child */
            if (child->invis || !UI_CheckVisibility(child))
                continue;

            memset(&mi, 0, sizeof(mi));
            mi.angles = EXTRADATA(child).angles;
            mi.scale = EXTRADATA(child).scale;
            mi.center = nullVector;
            mi.origin = EXTRADATA(child).origin;
            mi.color = pmi.color;

            /* get the anchor name to link the model into the parent */
            tag = EXTRADATA(child).tag;

            /* init model name */
            childRef = UI_GetReferenceString(child, EXTRADATA(child).model);
            if (childRef == NULL || childRef[0] == '\0')
                childSource[0] = '\0';
            else
                Q_strncpyz(childSource, childRef, sizeof(childSource));
            mi.model = R_RegisterModelShort(childSource);
            mi.name = childSource;

            /* init skin */
            if (EXTRADATA(child).skin && *(char *) EXTRADATA(child).skin)
                mi.skin = atoi(UI_GetReferenceString(child, EXTRADATA(child).skin));
            else
                mi.skin = 0;

            R_DrawModelDirect(&mi, &pmi, tag);
        }
    }

    if (EXTRADATA(node).clipOverflow)
        R_PopClipRect();
}

static int oldMousePosX = 0;
static int oldMousePosY = 0;

static void UI_ModelNodeCapturedMouseMove (uiNode_t *node, int x, int y)
{
    float *rotateAngles = EXTRADATA(node).angles;

    /* rotate a model */
    rotateAngles[YAW] -= ROTATE_SPEED * (x - oldMousePosX);
    rotateAngles[ROLL] += ROTATE_SPEED * (y - oldMousePosY);

    /* clamp the angles */
    while (rotateAngles[YAW] > 360.0)
        rotateAngles[YAW] -= 360.0;
    while (rotateAngles[YAW] < 0.0)
        rotateAngles[YAW] += 360.0;

    if (rotateAngles[ROLL] < 0.0)
        rotateAngles[ROLL] = 0.0;
    else if (rotateAngles[ROLL] > 180.0)
        rotateAngles[ROLL] = 180.0;

    oldMousePosX = x;
    oldMousePosY = y;
}

static void UI_ModelNodeMouseDown (uiNode_t *node, int x, int y, int button)
{
    if (button != K_MOUSE1)
        return;
    if (!EXTRADATA(node).rotateWithMouse)
        return;
    UI_SetMouseCapture(node);
    oldMousePosX = x;
    oldMousePosY = y;
}

static void UI_ModelNodeMouseUp (uiNode_t *node, int x, int y, int button)
{
    if (button != K_MOUSE1)
        return;
    if (UI_GetMouseCapture() != node)
        return;
    UI_MouseRelease();
}

static void UI_ModelNodeLoading (uiNode_t *node)
{
    Vector4Set(node->color, 1, 1, 1, 1);
    VectorSet(EXTRADATA(node).scale, 1, 1, 1);
    EXTRADATA(node).clipOverflow = qtrue;
}

static void UI_ModelNodeClone (const uiNode_t *source, uiNode_t *clone)
{
    localBehaviour->super->clone(source, clone);
    if (!clone->dynamic)
        EXTRADATA(clone).oldRefValue = UI_AllocStaticString("", MAX_OLDREFVALUE);
}

static void UI_ModelNodeNew (uiNode_t *node)
{
    EXTRADATA(node).oldRefValue = (char*) Mem_PoolAlloc(MAX_OLDREFVALUE, ui_dynPool, 0);
    EXTRADATA(node).oldRefValue[0] = '\0';
}

static void UI_ModelNodeDelete (uiNode_t *node)
{
    Mem_Free(EXTRADATA(node).oldRefValue);
    EXTRADATA(node).oldRefValue = NULL;
}

static void UI_ModelNodeLoaded (uiNode_t *node)
{
    /* a tag without but not a submodel */
    if (EXTRADATA(node).tag != NULL && node->behaviour != node->parent->behaviour) {
        Com_Printf("UI_ModelNodeLoaded: '%s' use a tag but is not a submodel. Tag removed.\n", UI_GetPath(node));
        EXTRADATA(node).tag = NULL;
    }

    if (EXTRADATA(node).oldRefValue == NULL)
        EXTRADATA(node).oldRefValue = UI_AllocStaticString("", MAX_OLDREFVALUE);

    /* no tag but no size */
    if (EXTRADATA(node).tag == NULL && (node->size[0] == 0 || node->size[1] == 0)) {
        Com_Printf("UI_ModelNodeLoaded: Please set a pos and size to the node '%s'. Note: 'origin' is a relative value to the center of the node\n", UI_GetPath(node));
    }
}

static const value_t properties[] = {
    /* Both. Name of the animation for the model */
    {"anim", V_CVAR_OR_STRING, UI_EXTRADATA_OFFSETOF(modelExtraData_t, animation), 0},
    /* Main model only. Point of view. */
    {"angles", V_VECTOR, UI_EXTRADATA_OFFSETOF(modelExtraData_t, angles), MEMBER_SIZEOF(modelExtraData_t, angles)},
    /* Main model only. Position of the model relative to the center of the node. */
    {"origin", V_VECTOR, UI_EXTRADATA_OFFSETOF(modelExtraData_t, origin), MEMBER_SIZEOF(modelExtraData_t, origin)},
    /* Both. Scale the model */
    {"scale", V_VECTOR, UI_EXTRADATA_OFFSETOF(modelExtraData_t, scale), MEMBER_SIZEOF(modelExtraData_t, scale)},
    /* Submodel only. A tag name to link the model to the parent model. */
    {"tag", V_CVAR_OR_STRING, UI_EXTRADATA_OFFSETOF(modelExtraData_t, tag), 0},
    /* Main model only. Auto compute the "better" scale for the model. The function dont work
     * very well at the moment because it dont check the angle and no more submodel bounding box.
     */
    {"autoscale", V_BOOL, UI_EXTRADATA_OFFSETOF(modelExtraData_t, autoscale), MEMBER_SIZEOF(modelExtraData_t, autoscale)},
    /* Main model only. Allow to change the POV of the model with the mouse (only for main model) */
    {"rotatewithmouse", V_BOOL, UI_EXTRADATA_OFFSETOF(modelExtraData_t, rotateWithMouse), MEMBER_SIZEOF(modelExtraData_t, rotateWithMouse)},
    /* Main model only. Clip the model with the node rect */
    {"clipoverflow", V_BOOL, UI_EXTRADATA_OFFSETOF(modelExtraData_t, clipOverflow), MEMBER_SIZEOF(modelExtraData_t, clipOverflow)},
    /* Source of the model. The path to the model, relative to <code>base/models</code> */
    {"src", V_CVAR_OR_STRING, UI_EXTRADATA_OFFSETOF(modelExtraData_t, model), 0},
    /* Both. Name of the skin for the model. */
    {"skin", V_CVAR_OR_STRING, UI_EXTRADATA_OFFSETOF(modelExtraData_t, skin), 0},

    {NULL, V_NULL, 0, 0}
};

void UI_RegisterModelNode (uiBehaviour_t *behaviour)
{
    localBehaviour = behaviour;
    behaviour->name = "model";
    behaviour->drawItselfChild = qtrue;
    behaviour->draw = UI_ModelNodeDraw;
    behaviour->mouseDown = UI_ModelNodeMouseDown;
    behaviour->mouseUp = UI_ModelNodeMouseUp;
    behaviour->loading = UI_ModelNodeLoading;
    behaviour->loaded = UI_ModelNodeLoaded;
    behaviour->clone = UI_ModelNodeClone;
    behaviour->new = UI_ModelNodeNew;
    behaviour->delete = UI_ModelNodeDelete;
    behaviour->capturedMouseMove = UI_ModelNodeCapturedMouseMove;
    behaviour->properties = properties;
    behaviour->extraDataSize = sizeof(EXTRADATA_TYPE);

    Cmd_AddCommand("uimodelslist", UI_ListUIModels_f, NULL);
}