ui_render.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_font.h"
#include "ui_render.h"
#include "../cl_video.h"
#include "../renderer/r_draw.h"
#include "../renderer/r_misc.h"

void UI_DrawFill (int x, int y, int w, int h, const vec4_t color)
{
    R_DrawFill(x, y, w, h, color);
}

void UI_Transform (const vec3_t transform, const vec3_t rotate, const vec3_t scale)
{
    vec3_t pos;

    if (transform != NULL) {
        R_PushMatrix();
        VectorCopy(transform, pos);
        pos[0] *= viddef.rx;
        pos[1] *= viddef.ry;

        R_Transform(pos, rotate, scale);
    } else {
        R_PopMatrix();
    }
}

const struct image_s *UI_LoadImage (const char *name)
{
    const struct image_s *image = R_FindImage(va("pics/%s", name), it_pic);
    if (image == r_noTexture)
        return NULL;
    return image;
}

void UI_DrawNormImage (float x, float y, float w, float h, float sh, float th, float sl, float tl, const image_t *image)
{
    float nw, nh, x1, x2, x3, x4, y1, y2, y3, y4;

    if (!image)
        return;

    /* normalize to the screen resolution */
    x1 = x * viddef.rx;
    y1 = y * viddef.ry;

    /* provided width and height (if any) take precedence */
    if (w)
        nw = w * viddef.rx;
    else
        nw = 0;

    if (h)
        nh = h * viddef.ry;
    else
        nh = 0;

    /* horizontal texture mapping */
    if (sh) {
        if (!w)
            nw = (sh - sl) * viddef.rx;
        sh /= image->width;
    } else {
        if (!w)
            nw = ((float)image->width - sl) * viddef.rx;
        sh = 1.0f;
    }
    sl /= image->width;

    /* vertical texture mapping */
    if (th) {
        if (!h)
            nh = (th - tl) * viddef.ry;
        th /= image->height;
    } else {
        if (!h)
            nh = ((float)image->height - tl) * viddef.ry;
        th = 1.0f;
    }
    tl /= image->height;

    /* fill the rest of the coordinates to make a rectangle */
    x4 = x1;
    x3 = x2 = x1 + nw;
    y2 = y1;
    y4 = y3 = y1 + nh;

    {
        const vec2_t imageTexcoords[4] = {{sl, tl}, {sh, tl}, {sh, th}, {sl, th}};
        const vec2_t imageVerts[4] = {{x1, y1}, {x2, y2}, {x3, y3}, {x4, y4}};
        R_DrawImageArray(imageTexcoords, imageVerts, image);
    }
}

const image_t *UI_DrawNormImageByName (float x, float y, float w, float h, float sh, float th, float sl, float tl, const char *name)
{
    const struct image_s *image;

    image = UI_LoadImage(name);
    if (!image) {
        Com_Printf("Can't find pic: %s\n", name);
        return NULL;
    }

    UI_DrawNormImage(x, y, w, h, sh, th, sl, tl, image);
    return image;
}

void UI_DrawPanel (const vec2_t pos, const vec2_t size, const char *texture, int texX, int texY, const int panelDef[6])
{
    const int leftWidth = panelDef[0];
    const int midWidth = panelDef[1];
    const int rightWidth = panelDef[2];
    const int topHeight = panelDef[3];
    const int midHeight = panelDef[4];
    const int bottomHeight = panelDef[5];
    const int marge = panelDef[6];

    const int firstPos = 0;
    const int secondPos = firstPos + leftWidth + marge;
    const int thirdPos = secondPos + midWidth + marge;
    const int firstPosY = 0;
    const int secondPosY = firstPosY + topHeight + marge;
    const int thirdPosY = secondPosY + midHeight + marge;

    int y, h;

    const image_t *image = UI_LoadImage(texture);
    if (!image)
        return;

    /* draw top (from left to right) */
    UI_DrawNormImage(pos[0], pos[1], leftWidth, topHeight, texX + firstPos + leftWidth, texY + firstPosY + topHeight,
        texX + firstPos, texY + firstPosY, image);
    UI_DrawNormImage(pos[0] + leftWidth, pos[1], size[0] - leftWidth - rightWidth, topHeight, texX + secondPos + midWidth, texY + firstPosY + topHeight,
        texX + secondPos, texY + firstPosY, image);
    UI_DrawNormImage(pos[0] + size[0] - rightWidth, pos[1], rightWidth, topHeight, texX + thirdPos + rightWidth, texY + firstPosY + topHeight,
        texX + thirdPos, texY + firstPosY, image);

    /* draw middle (from left to right) */
    y = pos[1] + topHeight;
    h = size[1] - topHeight - bottomHeight; /* height of middle */
    UI_DrawNormImage(pos[0], y, leftWidth, h, texX + firstPos + leftWidth, texY + secondPosY + midHeight,
        texX + firstPos, texY + secondPosY, image);
    UI_DrawNormImage(pos[0] + leftWidth, y, size[0] - leftWidth - rightWidth, h, texX + secondPos + midWidth, texY + secondPosY + midHeight,
        texX + secondPos, texY + secondPosY, image);
    UI_DrawNormImage(pos[0] + size[0] - rightWidth, y, rightWidth, h, texX + thirdPos + rightWidth, texY + secondPosY + midHeight,
        texX + thirdPos, texY + secondPosY, image);

    /* draw bottom (from left to right) */
    y = pos[1] + size[1] - bottomHeight;
    UI_DrawNormImage(pos[0], y, leftWidth, bottomHeight, texX + firstPos + leftWidth, texY + thirdPosY + bottomHeight,
        texX + firstPos, texY + thirdPosY, image);
    UI_DrawNormImage(pos[0] + leftWidth, y, size[0] - leftWidth - rightWidth, bottomHeight, texX + secondPos + midWidth, texY + thirdPosY + bottomHeight,
        texX + secondPos, texY + thirdPosY, image);
    UI_DrawNormImage(pos[0] + size[0] - bottomHeight, y, rightWidth, bottomHeight, texX + thirdPos + rightWidth, texY + thirdPosY + bottomHeight,
        texX + thirdPos, texY + thirdPosY, image);
}

int UI_DrawStringInBox (const char *fontID, align_t align, int x, int y, int width, int height, const char *text, longlines_t method)
{
    const align_t horizontalAlign = align % 3; /* left, center, right */
    const align_t verticalAlign = align / 3;  /* top, center, bottom */

    /* position of the text for UI_DrawString */
    const int xx = x + ((width * horizontalAlign) >> 1);
    const int yy = y + ((height * verticalAlign) >> 1);

    return UI_DrawString(fontID, align, xx, yy, xx, width, 0, text, 0, 0, NULL, qfalse, method);
}

int UI_DrawString (const char *fontID, align_t align, int x, int y, int absX, int maxWidth,
        int lineHeight, const char *c, int boxHeight, int scrollPos, int *curLine, qboolean increaseLine, longlines_t method)
{
    const uiFont_t *font = UI_GetFontByID(fontID);
    const align_t verticalAlign = align / 3;  /* top, center, bottom */
    int lines;

    if (!font)
        Com_Error(ERR_FATAL, "Could not find font with id: '%s'", fontID);

    if (lineHeight <= 0)
        lineHeight = UI_FontGetHeight(font->name);

    /* vertical alignment makes only a single-line adjustment in this
     * function. That means that ALIGN_Lx values will not show more than
     * one line in any case. */
    if (verticalAlign == 1)
        y += -(lineHeight / 2);
    else if (verticalAlign == 2)
        y += -lineHeight;

    lines = R_FontDrawString(fontID, align, x, y, absX, maxWidth, lineHeight,
            c, boxHeight, scrollPos, curLine, method);

    if (curLine && increaseLine)
        *curLine += lines;

    return lines * lineHeight;
}