#help_index "Graphics/Math/3D Transformation"
#help_file "::/Doc/Transform"

#define GR_SCALE                                (1<<32)

public U0 Mat4x4MulXYZ(I64 *r, I64 *_x, I64 *_y, I64 *_z)
{//Rotate 3D point using 4x4 matrix. Uses fixed-point.
        I64 x1, y1, z1, xx = *_x, yy = *_y, zz = *_z;

        x1 = (r[0 * 4 + 0] * xx + r[0 * 4 + 1] * yy + r[0 * 4 + 2] * zz + r[0 * 4 + 3]) >> 32;
        y1 = (r[1 * 4 + 0] * xx + r[1 * 4 + 1] * yy + r[1 * 4 + 2] * zz + r[1 * 4 + 3]) >> 32;
        z1 = (r[2 * 4 + 0] * xx + r[2 * 4 + 1] * yy + r[2 * 4 + 2] * zz + r[2 * 4 + 3]) >> 32;
        *_x = x1;
        *_y = y1;
        *_z = z1;
}

public U0 DCTransform(CDC *dc, I64 *_x, I64 *_y, I64 *_z)
{//This is the default dc->transform() callback.
//Uses fixed-point.
        Mat4x4MulXYZ(dc->r, _x, _y, _z);
        *_x += dc->x;
        *_y += dc->y;
        *_z += dc->z;
}

public I64 *Mat4x4IdentEqu(I64 *r)
{//Set matrix to identity. Uses fixed-point.
        MemSet(r, 0, sizeof(I64)*16);
        r[0 * 4 + 0].i32[1] = 1;
        r[1 * 4 + 1].i32[1] = 1;
        r[2 * 4 + 2].i32[1] = 1;
        r[3 * 4 + 3].i32[1] = 1;

        return r;
}

public I64 *Mat4x4IdentNew(CTask *mem_task=NULL)
{//MAlloc an identity matrix. Uses fixed-point.
        return Mat4x4IdentEqu(MAlloc(sizeof(I64) * 16, mem_task));
}

public I64 Mat4x4NormSqr65536(I64 *r)
{//Norm Squared of r.
//(1.0/Sqrt(3))*65536=37837.22
        return  SqrI64((r[0 * 4 + 0] * 37838 + r[0 * 4 + 1] * 37838 + r[0 * 4 + 2] * 37838) >> 32) +
                        SqrI64((r[1 * 4 + 0] * 37837 + r[1 * 4 + 1] * 37837 + r[1 * 4 + 2] * 37837) >> 32) +
                        SqrI64((r[2 * 4 + 0] * 37837 + r[2 * 4 + 1] * 37837 + r[2 * 4 + 2] * 37837) >> 32);
}

public U0 DCMat4x4Set(CDC *dc=NULL, I64 *r)
{//Set device context's rot matrix. Will be Freed() in DCDel().Uses fixed-point.
//The main purpose is to set matrix norm for thick scaling.
        //NULL as dc means gr.dc
        if (!dc)
                dc = gr.dc;
        dc->r = r;
        dc->r_norm = Sqrt(Mat4x4NormSqr65536(r)) * 65536; //scaled 32 bits
}

#help_index "Graphics/Mesh"
public U0 DCLighting(CDC *dc, CD3I32 *p1, CD3I32 *p2, CD3I32 *p3, CColorROPU32 color)
{//This is the default dc->lighting() callback.
        CD3I32  v1, v2;
        I64             i, vn_x, vn_y, vn_z;
        F64             d;

        v1.x = p1->x - p2->x;
        v1.y = p1->y - p2->y;
        v1.z = p1->z - p2->z;

        v2.x = p3->x - p2->x;
        v2.y = p3->y - p2->y;
        v2.z = p3->z - p2->z;

        //V1 and V2 are vects along two sides
        //of the tri joined at p2.

        vn_x = v1.y * v2.z - v1.z * v2.y;
        vn_y = v1.z * v2.x - v1.x * v2.z;
        vn_z = v1.x * v2.y - v1.y * v2.x;
        if (d =Sqrt(SqrI64(vn_x) + SqrI64(vn_y) + SqrI64(vn_z)))
                d = 1 << 16 / d;
        vn_x *= d;
        vn_y *= d;
        vn_z *= d;
//Vn is the cross product of V1 and V3
        //which means it is perpendicular. It
        //is the normal vect to the surface.
        //It has been scaled to length 65536.

        //Light source has been scaled to length 65536.
        i = (vn_x * dc->ls.x + vn_y * dc->ls.y + vn_z * dc->ls.z) >> 16;
//The dot product of the light source
        //vect and the surface normal
        //gives an illumination number.
        //65536*65536>>16=65536

        //ZealOS will generate a random U16
        //and compare to dither_probability_u16 and
        //will pick from two colors.
        //Probability dithering does not work with thick>1 at this time.
        if (color.c0.rop & ROPBF_TWO_SIDED)
        {
                color.c0.rop &= ~ROPBF_TWO_SIDED;
                i = AbsI64(i) << 1;
        }
        else
                i += 65536;
        if (color.c0.rop & ROPBF_HALF_RANGE_COLOR)
        {
                color.c0.rop &= ~ROPBF_HALF_RANGE_COLOR;
                i >>= 1;
                if (color >= 8)
                {
                        color -= 8;
                        i += 65536;
                }
        }
        if (i < 65536)
        {
                dc->color = ROPF_PROBABILITY_DITHER + color << 16 + BLACK;
                dc->dither_probability_u16 = i;
        }
        else
        {
                dc->color = ROPF_PROBABILITY_DITHER + (color ^ 8) << 16 + color;
                dc->dither_probability_u16 = i - 65536;
        }
}

#help_index "Graphics/Device Contexts"
public U0 DCFill(CDC *dc=NULL, CColorROPU32 val=TRANSPARENT)
{//Fill entire device context with color.
        if (!dc)
                dc = gr.dc;
        MemSet(dc->body, val, dc->width_internal * dc->height);
}

public U0 DCClear(CDC *dc=NULL)
{//Set entire device context image body to 0 (BLACK).
        if (!dc)
                dc = gr.dc;
        DCFill(dc, 0);
}

public U0 DCReset(CDC *dc)
{//Reset CDC structure members but not image body, itself.
        dc->color                       = BLACK;
        dc->color2                      = BLACK;
        dc->bkcolor                     = BLACK;
        dc->collision_count     = 0;
        dc->thick                       = 1;
        dc->ls.x                        = 37837; //1<<16/Sqrt(3)
        dc->ls.y                        = 37837;
        dc->ls.z                        = 37837;
        dc->x                           = 0;
        dc->y                           = 0;
        dc->z                           = 0;
        dc->transform           = &DCTransform;
        dc->lighting            = &DCLighting;
        Mat4x4IdentEqu(dc->r);
        dc->r_norm                      = GR_SCALE;
        dc->flags                  &= ~(DCF_SYMMETRY | DCF_TRANSFORMATION | DCF_JUST_MIRROR);
        MemCopy(dc->palette, gr_palette_std, sizeof(CBGR48) * COLORS_NUM);
}

public U0 DCExtentsInit(CDC *dc=NULL)
{//Init markers for extent of next newly drawn graphics.
//NULL means gr.dc
        //See ::/Demo/Graphics/Extents.CC
        //You should clear the record flag yourself
        if (!dc)
                dc = gr.dc;
        dc->flags |= DCF_RECORD_EXTENTS;
        dc->min_x = I64_MAX;
        dc->max_x = I64_MIN;
        dc->min_y = I64_MAX;
        dc->max_y = I64_MIN;
}

public CDC *DCAlias(CDC *dc=NULL, CTask *task=NULL)
{//Create alias of dc, so can change pen, color, etc.
//NULL means gr.dc
        CDC *res;

        if (!dc)
                dc = gr.dc;
        if (!task)
                task = Fs;
        if (dc->dc_signature != DCS_SIGNATURE_VAL)
                throw('Graphics');

        res = MAlloc(sizeof(CDC), task);
        MemCopy(res, dc, sizeof(CDC));
        res->win_task = res->mem_task = task;
        res->r = MAlloc(16 * sizeof(I64), task);
        DCReset(res);
        res->flags |= DCF_ALIAS;
        res->alias = dc;

        return res;
}

public CDC *DCNew(I64 width, I64 height, CTask *task=NULL, Bool null_bitmap=FALSE)
{//Create new width x height device context.
//Internally only allows widths which are divisible by 8.
        //Don't forget these sizeof(CDC).
        CDC *res;

        if (!task)
                task = Fs;
        res=CAlloc(sizeof(CDC), task);
        res->win_task           = task;
        res->mem_task           = task;
        res->width                      = width;
        res->width_internal     = (width + 7) & ~7;
        res->height                     = height;
        if (null_bitmap)
                res->flags |= DCF_DONT_DRAW;
        else
                res->body               = CAlloc(res->width_internal * res->height, task);
        res->r                          = MAlloc(16 * sizeof(I64), task);
        DCReset(res);
        res->dc_signature       = DCS_SIGNATURE_VAL;

        return res;
}

public U0 DCDel(CDC *dc)
{//Free dc, image body, rot mat and depth buf.
        if (!dc)
                return;
        if (dc->dc_signature != DCS_SIGNATURE_VAL)
                throw('Graphics');
        dc->dc_signature = 0;
        Free(dc->r);
        if (!(dc->flags & DCF_ALIAS))
                Free(dc->body);
        Free(dc->depth_buf);
        Free(dc);
}

public I64 DCSize(CDC *dc)
{//Mem size of header, image body and depth buffer.
        if (dc)
                return MSize2(dc) + MSize2(dc->body) + MSize2(dc->depth_buf);
        else
                return 0;
}

public I32 *DCDepthBufReset(CDC *dc)
{//Reset device context depth buf to far away.
        if (dc->depth_buf)
                MemSetU32(dc->depth_buf, I32_MAX, dc->width_internal * dc->height);

        return dc->depth_buf;
}

public I32 *DCDepthBufAlloc(CDC *dc)
{//Alloc a 32-bit depth buffer for device context.
        Free(dc->depth_buf);
        dc->depth_buf = MAlloc(dc->width_internal * dc->height * sizeof(I32), dc->mem_task);

        return DCDepthBufReset(dc);
}

public CDC *DCCopy(CDC *dc, CTask *task=NULL)
{//Alloc copy of dc, including image body, rot mat and depth buf.
        CDC *res;

        if (!dc)
                return NULL;
        if (dc->dc_signature != DCS_SIGNATURE_VAL)
                throw('Graphics');
        res = MAllocIdent(dc, task);
        DCMat4x4Set(res, Mat4x4New(dc->r, task));
        res->mem_task   = task;
        res->body               = MAllocIdent(dc->body, task);
        res->depth_buf  = MAllocIdent(dc->depth_buf, task);

        return res;
}

public U0 DCMono(CDC *dc, I64 quest=TRANSPARENT, I64 true_color=0, I64 false_color=COLOR_MONO)
{//Set entire device context to one of two colors.
        I64 i;
        U8 *dst;

        dst = dc->body;
        i = dc->width_internal * dc->height;
        while (i--)
                if (*dst == quest)
                        *dst++ = true_color;
                else
                        *dst++ = false_color;
}

public I64 DCColorChange(CDC *dc, I64 src_color, I64 dst_color=TRANSPARENT)
{//Find and replace src color with dst in device context.
        I64 i, res = 0;
        U8 *dst;

        dst = dc->body;
        i = dc->width_internal * dc->height;
        while (i--)
                if (*dst == src_color)
                {
                        *dst++ = dst_color;
                        res++;
                }
                else
                        dst++;

        return res;
}

public U8 *DCSave(CDC *dc, I64 *_size=NULL, I64 dcsf_flags=NONE)
{//Stores device context to mem, perhaps, with compression.
        U8              *res, *ptr, *body;
        I64              body_size = dc->width_internal * dc->height, total_size, flags;
        CBGR48   palette[COLORS_NUM];

        body = dc->body;

        total_size = offset(CDC.end) - offset(CDC.start) + body_size;
        flags = 0;

        if (dcsf_flags & DCSF_PALETTE_GET)
                GrPaletteGet(palette);
        else
                MemCopy(palette, &dc->palette, COLORS_NUM * sizeof(CBGR48));
        if (MemCompare(palette, gr_palette_std, COLORS_NUM * sizeof(CBGR48)))
        {
                flags |= DCF_PALETTE;
                total_size += COLORS_NUM * sizeof(CBGR48);
        }

        ptr = res = MAlloc(total_size);

#assert !offset(CDC.start)
        MemCopy(ptr, &dc->start, offset(CDC.end) - offset(CDC.start));
        ptr(CDC *)->flags = flags;
        ptr += offset(CDC.end) - offset(CDC.start);

#assert offset(CDC.end) == offset(CDC.palette)
        if (flags & DCF_PALETTE)
        {
                MemCopy(ptr, palette, COLORS_NUM * sizeof(CBGR48));
                ptr += COLORS_NUM * sizeof(CBGR48);
        }

        MemCopy(ptr, body, body_size);
        ptr += body_size;

        if (_size)
                *_size = total_size;

        return res;
}

public CDC *DCLoad(U8 *src, I64 *_size=NULL, CTask *task=NULL)
{//Loads device context from mem.
        CDC *res;
        U8  *ptr = src;
        I64  body_size;

        if (!task)
                task = Fs;
        res = CAlloc(sizeof(CDC), task);
        res->win_task = task;
        res->mem_task = task;
        MemCopy(&res->start, ptr, offset(CDC.end) - offset(CDC.start));
        ptr += offset(CDC.end) - offset(CDC.start);

        if (res->flags & DCF_PALETTE)
        {
                MemCopy(&res->palette, ptr, COLORS_NUM * sizeof(CBGR48));
                ptr += COLORS_NUM * sizeof(CBGR48);
        }
        else
                MemCopy(&res->palette, gr_palette_std, COLORS_NUM * sizeof(CBGR48));

        body_size = res->width_internal * res->height;
        res->body                       = MAlloc(body_size, task);
        MemCopy(res->body, ptr, body_size);
        ptr += body_size;
        res->thick                      = 1;
        res->r                          = Mat4x4IdentNew(task);
        res->r_norm.u32[1]      = 1;
        res->dc_signature       = DCS_SIGNATURE_VAL;
        if (_size)
                *_size = ptr - src;

        return res;
}

#help_index "Graphics/GR Files"
#help_file "::/Doc/GRFiles"
#help_index "Graphics/Device Contexts;Graphics/GR Files"

#define GR_FILE_MAX     (offset(CDC.end) - offset(CDC.start) + COLORS_NUM * sizeof(CBGR48) + GR_WIDTH * GR_HEIGHT)

public I64 GRWrite(U8 *filename, CDC *dc, I64 dcsf_flags=NONE)
{//ZealOS GR File.
        I64 size;
        U8 *st = ExtDefault(filename, "GR"), *src = DCSave(dc, &size, dcsf_flags);
        FileWrite(st, src, size);
        Free(st);
        Free(src);

        return size;
}

public CDC *GRRead(U8 *filename, CTask *task=NULL)
{//ZealOS GR File.
        CDC *dc = NULL;
        U8  *st = ExtDefault(filename, "GR"), *src = FileRead(st);
        if (src)
                dc = DCLoad(src,, task);
        Free(src);
        Free(st);

        return dc;
}

#help_index "Graphics/Sprite;Graphics/GR Files;DolDoc/Output;StdOut/DolDoc"
public U0 DocGR(CDoc *doc=NULL, U8 *filename)
{//Put a GR file into a document as asprite.
        CDC             *dc = GRRead(filename);
        CSprite *elems = DC2Sprite(dc);

        DocSprite(doc, elems);
        Free(elems);
        DCDel(dc);
}

#help_index "Graphics/Device Contexts;Graphics/Screen"
public CDC *DCScreenCapture(Bool include_zoom=TRUE, CTask *task=NULL)
{//Capture screen to a device context.
        CDC *dc;
        U8  *dst;

        Refresh(0, FALSE);
        if (include_zoom)
                dc = DCCopy(gr.screen_image, task);
        else
                dc = DCCopy(gr.dc1, task);
        dc->flags &= ~DCF_SCREEN_BITMAP;
        dst = MAlloc(dc->width_internal * dc->height, task);
//Pick background color that never occurs. COLOR_INVALID
        GrBitMap4ToBitMap8(dst, dc->body, (dc->width_internal * dc->height) >> 1, COLOR_INVALID);
        Free(dc->body);
        dc->body = dst;

        return dc;
}