/**
* @brief Draw 3D Marker on the 2D geoscape.
* @param[in] screenPos Position on screenlongitude and latitude of the model to draw.
* @param[in] direction angle giving the direction the model is heading toward.
*/
void R_Draw2DMapMarkers (const vec2_t screenPos, float direction, const char *model, int skin)
{
modelInfo_t mi;
vec2_t size;
vec3_t scale, center, position, angles;
float zoom = 0.4f;
OBJZERO(mi);
VectorCopy(vec3_origin, position);
VectorCopy(vec3_origin, angles);
mi.model = R_FindModel(model);
if (!mi.model) {
Com_Printf("Could not find model '%s'\n", model);
return;
}
mi.name = model;
mi.origin = position;
mi.angles = angles;
mi.skin = skin;
size[0] = size[1] = MARKER_SIZE * zoom;
R_ModelAutoScale(size, &mi, scale, center);
/* reset the center, as we want to place the models onto the surface of the earth */
mi.center = nullptr;
/* go to a new matrix */
glPushMatrix();
/* Apply all transformation to model. Note that the transformations are applied starting
* from the last one and ending with the first one */
/* move model to its location */
glTranslatef(screenPos[0]* viddef.rx, screenPos[1]* viddef.ry, 0);
/* scale model to proper resolution */
glScalef(viddef.rx, viddef.ry, 1.0f);
/* rotate model to proper direction. */
glRotatef(-90.f + direction, 0, 0, 1);
R_DrawModelDirect(&mi, nullptr, nullptr);
/* restore previous matrix */
glPopMatrix();
}
/**
* @brief Draw 3D Marker on the 3D geoscape.
* @param[in] rotate vector giving the angles of earth rotation due to player view.
* @param[in] pos longitude and latitude of the model to draw.
* @param[in] direction angle giving the direction the model is heading toward.
* @param[in] earthRadius Radius of earth on screen (this include zoom).
*/
void R_Draw3DMapMarkers (const vec2_t nodePos, const vec2_t nodeSize, const vec3_t rotate, const vec2_t pos, float direction, float earthRadius, const char *model, int skin)
{
/* normalize */
const float nx = nodePos[0] * viddef.rx;
const float ny = nodePos[1] * viddef.ry;
const float nw = nodeSize[0] * viddef.rx;
const float nh = nodeSize[1] * viddef.ry;
/* Earth center is in the middle of node.
* Due to Orthographic view, this is also camera position */
const vec3_t earthPos = {nx + nw / 2.0f, ny + nh / 2.0f, 0.0f};
modelInfo_t mi;
vec2_t size;
vec3_t scale, center, position, angles;
float zoom = 0.4f;
OBJZERO(mi);
VectorCopy(vec3_origin, position);
VectorCopy(vec3_origin, angles);
mi.model = R_FindModel(model);
if (!mi.model) {
Com_Printf("Could not find model '%s'\n", model);
return;
}
mi.name = model;
mi.origin = position;
mi.angles = angles;
mi.skin = skin;
size[0] = size[1] = MARKER_SIZE * zoom;
R_ModelAutoScale(size, &mi, scale, center);
/* reset the center, as we want to place the models onto the surface of the earth */
mi.center = nullptr;
/* go to a new matrix */
glPushMatrix();
/* Apply all transformation to model. Note that the transformations are applied starting
* from the last one and ending with the first one */
/* center model on earth. Translate also along z to avoid seeing
* bottom part of the model through earth (only half of earth is drawn) */
glTranslatef(earthPos[0], earthPos[1], 10.0f);
/* scale model to proper resolution */
glScalef(viddef.rx, viddef.ry, 1.0f);
/* place model on earth: make it tangent to earth surface, heading toward it if direction is used. */
glRotatef(-rotate[1], 1, 0, 0);
glRotatef(rotate[2], 0, 1, 0);
glRotatef(rotate[0] - pos[0], 0, 0, 1);
glRotatef(90.0f - pos[1], 1, 0, 0);
glTranslatef(0, 0, earthRadius);
glRotatef(90.0f + direction, 0, 0, 1);
R_DrawModelDirect(&mi, nullptr, nullptr);
/* restore previous matrix */
glPopMatrix();
}
/**
* @todo need to merge UI model case, and the common case (looks to be a copy-pasted code)
*/
void UI_DrawModelNode (uiNode_t* node, const char* source)
{
modelInfo_t mi;
uiModel_t* model;
vec3_t nodeorigin;
vec2_t screenPos;
assert(UI_NodeInstanceOf(node, "model")); /**< We use model extradata */
if (!source || 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_FindModel(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_GetNodeScreenPos(node, screenPos);
UI_GetNodeAbsPos(node, nodeorigin);
R_CleanupDepthBuffer(nodeorigin[0], nodeorigin[1], node->box.size[0], node->box.size[1]);
if (EXTRADATA(node).clipOverflow) {
UI_PushClipRect(screenPos[0], screenPos[1], node->box.size[0], node->box.size[1]);
}
nodeorigin[0] += node->box.size[0] / 2 + EXTRADATA(node).origin[0];
nodeorigin[1] += node->box.size[1] / 2 + EXTRADATA(node).origin[1];
nodeorigin[2] = EXTRADATA(node).origin[2];
VectorMA(EXTRADATA(node).angles, cls.frametime, EXTRADATA(node).omega, EXTRADATA(node).angles);
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)
UI_PopClipRect();
return;
}
/* if the node is linked to a parent, the parent will display it */
if (EXTRADATA(node).tag) {
if (EXTRADATA(node).clipOverflow)
UI_PopClipRect();
return;
}
/* autoscale? */
if (EXTRADATA(node).autoscale) {
vec3_t autoScale;
vec3_t autoCenter;
const vec2_t size = {node->box.size[0] - node->padding, node->box.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 && *EXTRADATA(node).skin)
mi.skin = atoi(UI_GetReferenceString(node, EXTRADATA(node).skin));
else
mi.skin = 0;
/* do animations */
if (EXTRADATA(node).animation && *EXTRADATA(node).animation) {
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 */
Mem_Free(EXTRADATA(node).animationState);
EXTRADATA(node).animationState = nullptr;
}
animState_t* as = EXTRADATA(node).animationState;
if (!as) {
as = Mem_PoolAllocType(animState_t, cl_genericPool);
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 */
anim = R_AnimGetName(as, mi.model);
if (anim && !Q_streq(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, nullptr, nullptr);
/* draw all children */
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;
OBJZERO(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 (Q_strnull(childRef))
childSource[0] = '\0';
else
Q_strncpyz(childSource, childRef, sizeof(childSource));
mi.model = R_FindModel(childSource);
mi.name = childSource;
/* init skin */
if (EXTRADATA(child).skin && *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)
UI_PopClipRect();
}
/**
* @brief Draws an item to the screen
* @param[in] node Context node
* @param[in] org Node position on the screen (pixel). Single nodes: Use the center of the node.
* @param[in] item The item to draw.
* @param[in] x Position in container. Set this to -1 if it's drawn in a single container.
* @param[in] y Position in container. Set this to -1 if it's drawn in a single container.
* @param[in] scale
* @param[in] color
* @sa SCR_DrawCursor
* Used to draw an item to the equipment containers. First look whether the objDef_t
* includes an image - if there is none then draw the model
*/
void UI_DrawItem (uiNode_t *node, const vec3_t org, const item_t *item, int x, int y, const vec3_t scale, const vec4_t color)
{
const objDef_t *od = item->item;
vec4_t col;
vec3_t origin;
assert(od);
assert(org[2] > -1000 && org[2] < 1000); /*< prevent use of vec2_t for org */
Vector4Copy(color, col);
/* no ammo in this weapon - highlight this item */
if (od->weapon && od->reload && !item->ammoLeft) {
col[1] *= 0.5;
col[2] *= 0.5;
}
VectorCopy(org, origin);
/* Calculate correct location of the image or the model (depends on rotation) */
/** @todo Change the rotation of the image as well, right now only the location is changed.
* How is image-rotation handled right now? */
if (x >= 0 || y >= 0) {
/* Add offset of location in container. */
origin[0] += x * C_UNIT;
origin[1] += y * C_UNIT;
/* Add offset for item-center (depends on rotation). */
if (item->rotated) {
origin[0] += od->sy * C_UNIT / 2.0;
origin[1] += od->sx * C_UNIT / 2.0;
/** @todo Image size calculation depends on handling of image-rotation.
imgWidth = od->sy * C_UNIT;
imgHeight = od->sx * C_UNIT;
*/
} else {
origin[0] += od->sx * C_UNIT / 2.0;
origin[1] += od->sy * C_UNIT / 2.0;
}
}
/* don't handle the od->tech->image here - it's very ufopedia specific in most cases */
if (od->image[0] != '\0') {
const int imgWidth = od->sx * C_UNIT;
const int imgHeight = od->sy * C_UNIT;
origin[0] -= od->sx * C_UNIT / 2.0;
origin[1] -= od->sy * C_UNIT / 2.0;
/* Draw the image. */
R_Color(color);
UI_DrawNormImageByName(false, origin[0], origin[1], imgWidth, imgHeight, 0, 0, 0, 0, od->image);
R_Color(NULL);
} else {
uiModel_t *model = NULL;
const char *modelName = GAME_GetModelForItem(od, &model);
/* no model definition in the tech struct, not in the fallback object definition */
if (Q_strnull(modelName)) {
Com_Printf("UI_DrawItem: No model given for item: '%s'\n", od->id);
return;
}
if (model && node) {
UI_DrawModelNode(node, modelName);
} else {
modelInfo_t mi;
vec3_t angles = {-10, 160, 70};
vec3_t size = {scale[0], scale[1], scale[2]};
vec3_t center;
if (item->rotated)
angles[0] -= 90;
if (od->scale)
VectorScale(size, od->scale, size);
VectorNegate(od->center, center);
OBJZERO(mi);
mi.origin = origin;
mi.angles = angles;
mi.center = center;
mi.scale = size;
mi.color = col;
mi.name = modelName;
/* draw the model */
R_DrawModelDirect(&mi, NULL, NULL);
}
}
}
/**
* @brief Draw a model using UI model definition
*/
static void UI_DrawModelNodeWithUIModel (uiNode_t* node, const char* source, modelInfo_t* mi, uiModel_t* model)
{
bool autoScaleComputed = false;
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_FindModel(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_FindModel(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->box.pos[0];
mi->origin[1] -= node->root->box.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;
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->box.size[0] - node->padding;
size[1] = node->box.size[1] - node->padding;
R_ModelAutoScale(size, mi, autoScale, autoCenter);
autoScaleComputed = true;
} else {
mi->scale = autoScale;
mi->center = autoCenter;
}
}
/* get the animation given by node properties */
if (EXTRADATA(node).animation && *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 == nullptr || !Q_streq(anim, ref))
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, nullptr, nullptr);
}
/* next */
model = model->next;
}
}