MegaDoom Adventures/PMWMEGADOOM.iso/doom/creators/ibsp101s/drawing.c

C/C++ Source or Header | 1994-07-10 | 6KB | 292 lines

/* drawing.m */
#include "idbsp.h"

/* id           window_i, view_i; */
STORAGE            *window_i,
                   *view_i;
float               scale = 0.125;
NXRect              worldbounds;

/*
   ================
   =
   = IDRectFromPoints
   =
   = Makes the rectangle just touch the two points
   =
   ================
 */

void                IDRectFromPoints(NXRect * rect, NXPoint const *p1, NXPoint const *p2)
{
/* return a rectangle that encloses the two points */
    if (p1 -> x < p2 -> x)
        {
        rect -> origin.x = p1 -> x;
        rect -> size.width = p2 -> x - p1 -> x + 1;
        }
    else
        {
        rect -> origin.x = p2 -> x;
        rect -> size.width = p1 -> x - p2 -> x + 1;
        }

    if (p1 -> y < p2 -> y)
        {
        rect -> origin.y = p1 -> y;
        rect -> size.height = p2 -> y - p1 -> y + 1;
        }
    else
        {
        rect -> origin.y = p2 -> y;
        rect -> size.height = p1 -> y - p2 -> y + 1;
        }
}


/*
   ==================
   =
   = IDEnclosePoint
   =
   = Make the rect enclose the point if it doesn't allready
   =
   ==================
 */

void                IDEnclosePoint(NXRect * rect, NXPoint const *point)
{
    float               right,
                        top;

    right = rect -> origin.x + rect -> size.width - 1;
    top = rect -> origin.y + rect -> size.height - 1;

    if (point -> x < rect -> origin.x)
        rect -> origin.x = point -> x;
    if (point -> y < rect -> origin.y)
        rect -> origin.y = point -> y;
    if (point -> x > right)
        right = point -> x;
    if (point -> y > top)
        top = point -> y;

    rect -> size.width = right - rect -> origin.x + 1;
    rect -> size.height = top - rect -> origin.y + 1;
}


/*
   ===========
   =
   = BoundLineStore
   =
   ===========
 */

/* void BoundLineStore (id lines_i, NXRect *r) */
void                BoundLineStore(STORAGE * lines_i, NXRect * r)
{
    int                 i,
                        c;
    worldline_t        *line_p;

/*  c = [lines_i count]; */
    c = lines_i -> count;
    if (!c)
        Error("BoundLineStore: empty list");

/* line_p = [lines_i elementAt:0]; */
    line_p = lines_i -> data;
    IDRectFromPoints(r, &line_p -> p1, &line_p -> p2);

    for (i = 1; i < c; i++)
        {
/*      line_p = [lines_i elementAt:i]; */
        line_p = (worldline_t *) lines_i -> data + i;
        IDEnclosePoint(r, &line_p -> p1);
        IDEnclosePoint(r, &line_p -> p2);
        }
}


/*
   ===========
   =
   = DrawLineStore
   =
   = Draws all of the lines in the given storage object
   =
   ===========
 */

/* void DrawLineStore (id lines_i) */
void                DrawLineStore(STORAGE * lines_i)
{

#if 0
    int                 i,
                        c;
    worldline_t        *line_p;

    if (!draw)
        return;

/*  c = [lines_i count]; */
    c = lines_i -> count;

    for (i = 0; i < c; i++)
        {
/*      line_p = [lines_i elementAt:i]; */
        line_p = (worldline_t *) lines_i -> data + i;
        PSmoveto(line_p -> p1.x, line_p -> p1.y);
        PSlineto(line_p -> p2.x, line_p -> p2.y);
        PSstroke();
        }
    NXPing();
#endif
}

/*
   ===========
   =
   = DrawLine
   =
   = Draws all of the lines in the given storage object
   =
   ===========
 */

void                DrawLineDef(maplinedef_t * ld)
{

#if 0
    mapvertex_t        *v1,
                       *v2;

    if (!draw)
        return;
/*
   v1 = [mapvertexstore_i elementAt: ld->v1];
   v2 = [mapvertexstore_i elementAt: ld->v2];
 */
    v1 = mapvertexstore_i -> data + ld -> v1;
    v2 = mapvertexstore_i -> data + ld -> v2;
    PSmoveto(v1 -> x, v1 -> y);
    PSlineto(v2 -> x, v2 -> y);
    PSstroke();
    NXPing();
#endif
}


/*
   ===========
   =
   = DrawMap
   =
   ===========
 */

void                DrawMap(void)
{
    NXRect              scaled;

    BoundLineStore(linestore_i, &worldbounds);
    worldbounds.origin.x -= 8;
    worldbounds.origin.y -= 8;
    worldbounds.size.width += 16;
    worldbounds.size.height += 16;

#if 0
    if (!draw)
        return;

    scaled.origin.x = 300;
    scaled.origin.y = 80;
    scaled.size.width = worldbounds.size.width * scale;
    scaled.size.height = worldbounds.size.height * scale;
/*
   window_i =
   [[Window alloc]
   initContent: &scaled
   style:           NX_TITLEDSTYLE
   backing:     NX_RETAINED
   buttonMask:      0
   defer:           NO
   ];

   [window_i display];
   [window_i orderFront: nil];
   view_i = [window_i contentView];

   [view_i
   setDrawSize: worldbounds.size.width
   :                worldbounds.size.height];
   [view_i
   setDrawOrigin:   worldbounds.origin.x
   :                worldbounds.origin.y];

   [view_i lockFocus];
   PSsetgray (NX_BLACK);
   DrawLineStore (linestore_i);
 */
#endif
}


/*
   ===========
   =
   = EraseWindow
   =
   ===========
 */

void                EraseWindow(void)
{

#if 0
    if (!draw)
        return;

    NXEraseRect(&worldbounds);
    NXPing();
#endif
}


/*
   ============================
   =
   = DrawDivLine
   =
   ============================
 */

void                DrawDivLine(divline_t * div)
{

#if 0
    float               vx,
                        vy,
                        dist;

    if (!draw)
        return;

    PSsetgray(NX_BLACK);

    dist = sqrt(pow(div -> dx, 2) + pow(div -> dy, 2));
    vx = div -> dx / dist;
    vy = div -> dy / dist;

    dist = MAX(worldbounds.size.width, worldbounds.size.height);

    PSmoveto(div -> pt.x - vx * dist, div -> pt.y - vy * dist);
    PSlineto(div -> pt.x + vx * dist, div -> pt.y + vy * dist);
    PSstroke();
    NXPing();
#endif
}