Ejemplo n.º 1
0
 /*-------------------------------------------------
 *   union_render_bounds - compute the union of two
 *   render_bounds
 *  -------------------------------------------------*/
 public static void union_render_bounds(render_bounds dest, render_bounds src)
 {
     dest.x0 = Math.Min(dest.x0, src.x0);
     dest.x1 = Math.Max(dest.x1, src.x1);
     dest.y0 = Math.Min(dest.y0, src.y0);
     dest.y1 = Math.Max(dest.y1, src.y1);
 }
Ejemplo n.º 2
0
 /*-------------------------------------------------
 *   set_render_bounds_wh - cleaner way to set the
 *   bounds
 *  -------------------------------------------------*/
 public static void set_render_bounds_wh(render_bounds bounds, float x0, float y0, float width, float height)
 {
     bounds.x0 = x0;
     bounds.y0 = y0;
     bounds.x1 = x0 + width;
     bounds.y1 = y0 + height;
 }
Ejemplo n.º 3
0
 /*-------------------------------------------------
 *   set_render_bounds_xy - cleaner way to set the
 *   bounds
 *  -------------------------------------------------*/
 public static void set_render_bounds_xy(render_bounds bounds, float x0, float y0, float x1, float y1)
 {
     bounds.x0 = x0;
     bounds.y0 = y0;
     bounds.x1 = x1;
     bounds.y1 = y1;
 }
Ejemplo n.º 4
0
        public uint32_t screen_update(screen_device screen, bitmap_rgb32 bitmap, rectangle cliprect)
        {
            uint32_t  flags   = PRIMFLAG_ANTIALIAS(1) | PRIMFLAG_BLENDMODE(BLENDMODE_ADD) | PRIMFLAG_VECTOR(1);
            rectangle visarea = screen.visible_area();
            float     xscale  = 1.0f / (65536 * visarea.width());
            float     yscale  = 1.0f / (65536 * visarea.height());
            float     xoffs   = (float)visarea.min_x;
            float     yoffs   = (float)visarea.min_y;

            int curpointIdx = 0;  //point *curpoint;
            int lastx       = 0;
            int lasty       = 0;

            curpointIdx = 0;  //curpoint = m_vector_list.get();
            var curpoint = m_vector_list;

            screen.container().empty();
            screen.container().add_rect(0.0f, 0.0f, 1.0f, 1.0f, new rgb_t(0xff, 0x00, 0x00, 0x00), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_VECTORBUF(1));

            for (int i = 0; i < m_vector_index; i++)
            {
                render_bounds coords = new render_bounds();

                float intensity        = (float)curpoint[curpointIdx].intensity / 255.0f; //float intensity = (float)curpoint->intensity / 255.0f;
                float intensity_weight = normalized_sigmoid(intensity, vector_options.s_beam_intensity_weight);

                // check for static intensity
                float beam_width = m_min_intensity == m_max_intensity
                    ? vector_options.s_beam_width_min
                    : vector_options.s_beam_width_min + intensity_weight * (vector_options.s_beam_width_max - vector_options.s_beam_width_min);

                // normalize width
                beam_width *= 1.0f / (float)VECTOR_WIDTH_DENOM;

                // apply point scale for points
                if (lastx == curpoint[curpointIdx].x && lasty == curpoint[curpointIdx].y)  //if (lastx == curpoint->x && lasty == curpoint->y)
                {
                    beam_width *= vector_options.s_beam_dot_size;
                }

                coords.x0 = ((float)lastx - xoffs) * xscale;
                coords.y0 = ((float)lasty - yoffs) * yscale;
                coords.x1 = ((float)curpoint[curpointIdx].x - xoffs) * xscale; //coords.x1 = ((float)curpoint->x - xoffs) * xscale;
                coords.y1 = ((float)curpoint[curpointIdx].y - yoffs) * yscale; //coords.y1 = ((float)curpoint->y - yoffs) * yscale;

                if (curpoint[curpointIdx].intensity != 0)                      //if (curpoint->intensity != 0)
                {
                    screen.container().add_line(
                        coords.x0, coords.y0, coords.x1, coords.y1,
                        beam_width,
                        new rgb_t(((uint32_t)curpoint[curpointIdx].intensity << 24) | (curpoint[curpointIdx].col & 0xffffff)),  //(curpoint->intensity << 24) | (curpoint->col & 0xffffff),
                        flags);
                }

                lastx = curpoint[curpointIdx].x; //lastx = curpoint->x;
                lasty = curpoint[curpointIdx].y; //lasty = curpoint->y;

                curpointIdx++;                   //curpoint++;
            }

            return(0);
        }
Ejemplo n.º 5
0
        /*-------------------------------------------------
        *   render_clip_line - clip a line to a rectangle
        *  -------------------------------------------------*/
        public static bool render_clip_line(ref render_bounds bounds, render_bounds clip)
        {
            /* loop until we get a final result */
            while (true)
            {
                u8    code0 = 0;
                u8    code1 = 0;
                u8    thiscode;
                float x;
                float y;

                /* compute Cohen Sutherland bits for first coordinate */
                if (bounds.y0 > clip.y1)
                {
                    code0 |= 1;
                }
                if (bounds.y0 < clip.y0)
                {
                    code0 |= 2;
                }
                if (bounds.x0 > clip.x1)
                {
                    code0 |= 4;
                }
                if (bounds.x0 < clip.x0)
                {
                    code0 |= 8;
                }

                /* compute Cohen Sutherland bits for second coordinate */
                if (bounds.y1 > clip.y1)
                {
                    code1 |= 1;
                }
                if (bounds.y1 < clip.y0)
                {
                    code1 |= 2;
                }
                if (bounds.x1 > clip.x1)
                {
                    code1 |= 4;
                }
                if (bounds.x1 < clip.x0)
                {
                    code1 |= 8;
                }

                /* trivial accept: just return FALSE */
                if ((code0 | code1) == 0)
                {
                    return(false);
                }

                /* trivial reject: just return TRUE */
                if ((code0 & code1) != 0)
                {
                    return(true);
                }

                /* fix one of the OOB cases */
                thiscode = code0 > 0 ? code0 : code1;

                /* off the bottom */
                if ((thiscode & 1) != 0)
                {
                    x = bounds.x0 + (bounds.x1 - bounds.x0) * (clip.y1 - bounds.y0) / (bounds.y1 - bounds.y0);
                    y = clip.y1;
                }

                /* off the top */
                else if ((thiscode & 2) != 0)
                {
                    x = bounds.x0 + (bounds.x1 - bounds.x0) * (clip.y0 - bounds.y0) / (bounds.y1 - bounds.y0);
                    y = clip.y0;
                }

                /* off the right */
                else if ((thiscode & 4) != 0)
                {
                    y = bounds.y0 + (bounds.y1 - bounds.y0) * (clip.x1 - bounds.x0) / (bounds.x1 - bounds.x0);
                    x = clip.x1;
                }

                /* off the left */
                else
                {
                    y = bounds.y0 + (bounds.y1 - bounds.y0) * (clip.x0 - bounds.x0) / (bounds.x1 - bounds.x0);
                    x = clip.x0;
                }

                /* fix the appropriate coordinate */
                if (thiscode == code0)
                {
                    bounds.x0 = x;
                    bounds.y0 = y;
                }
                else
                {
                    bounds.x1 = x;
                    bounds.y1 = y;
                }
            }
        }
Ejemplo n.º 6
0
        /*-------------------------------------------------
        *   render_clip_quad - clip a quad to a rectangle
        *  -------------------------------------------------*/
        public static bool render_clip_quad(ref render_bounds bounds, render_bounds clip, ref render_quad_texuv texcoords, bool use_texcoords)
        {
            /* ensure our assumptions about the bounds are correct */
            assert(bounds.x0 <= bounds.x1);
            assert(bounds.y0 <= bounds.y1);

            /* trivial reject */
            if (bounds.y1 < clip.y0)
            {
                return(true);
            }
            if (bounds.y0 > clip.y1)
            {
                return(true);
            }
            if (bounds.x1 < clip.x0)
            {
                return(true);
            }
            if (bounds.x0 > clip.x1)
            {
                return(true);
            }

            /* clip top (x0,y0)-(x1,y1) */
            if (bounds.y0 < clip.y0)
            {
                float frac = (clip.y0 - bounds.y0) / (bounds.y1 - bounds.y0);
                bounds.y0 = clip.y0;
                if (use_texcoords)  //if (texcoords != nullptr)
                {
                    texcoords.tl.u += (texcoords.bl.u - texcoords.tl.u) * frac;
                    texcoords.tl.v += (texcoords.bl.v - texcoords.tl.v) * frac;
                    texcoords.tr.u += (texcoords.br.u - texcoords.tr.u) * frac;
                    texcoords.tr.v += (texcoords.br.v - texcoords.tr.v) * frac;
                }
            }

            /* clip bottom (x3,y3)-(x2,y2) */
            if (bounds.y1 > clip.y1)
            {
                float frac = (bounds.y1 - clip.y1) / (bounds.y1 - bounds.y0);
                bounds.y1 = clip.y1;
                if (use_texcoords)  //if (texcoords != nullptr)
                {
                    texcoords.bl.u -= (texcoords.bl.u - texcoords.tl.u) * frac;
                    texcoords.bl.v -= (texcoords.bl.v - texcoords.tl.v) * frac;
                    texcoords.br.u -= (texcoords.br.u - texcoords.tr.u) * frac;
                    texcoords.br.v -= (texcoords.br.v - texcoords.tr.v) * frac;
                }
            }

            /* clip left (x0,y0)-(x3,y3) */
            if (bounds.x0 < clip.x0)
            {
                float frac = (clip.x0 - bounds.x0) / (bounds.x1 - bounds.x0);
                bounds.x0 = clip.x0;
                if (use_texcoords)  //if (texcoords != nullptr)
                {
                    texcoords.tl.u += (texcoords.tr.u - texcoords.tl.u) * frac;
                    texcoords.tl.v += (texcoords.tr.v - texcoords.tl.v) * frac;
                    texcoords.bl.u += (texcoords.br.u - texcoords.bl.u) * frac;
                    texcoords.bl.v += (texcoords.br.v - texcoords.bl.v) * frac;
                }
            }

            /* clip right (x1,y1)-(x2,y2) */
            if (bounds.x1 > clip.x1)
            {
                float frac = (bounds.x1 - clip.x1) / (bounds.x1 - bounds.x0);
                bounds.x1 = clip.x1;
                if (use_texcoords)  //if (texcoords != nullptr)
                {
                    texcoords.tr.u -= (texcoords.tr.u - texcoords.tl.u) * frac;
                    texcoords.tr.v -= (texcoords.tr.v - texcoords.tl.v) * frac;
                    texcoords.br.u -= (texcoords.br.u - texcoords.bl.u) * frac;
                    texcoords.br.v -= (texcoords.br.v - texcoords.bl.v) * frac;
                }
            }

            return(false);
        }
Ejemplo n.º 7
0
        // texture/bitmap queries

        //-------------------------------------------------
        //  get_char_texture_and_bounds - return the
        //  texture for a character and compute the
        //  bounds of the final bitmap
        //-------------------------------------------------
        public render_texture get_char_texture_and_bounds(float height, float aspect, char32_t chnum, ref render_bounds bounds)
        {
            glyph gl = get_char(chnum);

            // on entry, assume x0,y0 are the top,left coordinate of the cell and add
            // the character bounding box to that position
            float scale = m_scale * height;

            bounds.x0 += (float)gl.xoffs * scale * aspect;

            // compute x1,y1 from there based on the bitmap size
            bounds.x1 = bounds.x0 + (float)gl.bmwidth * scale * aspect;
            bounds.y1 = bounds.y0 + (float)m_height * scale;

            // return the texture
            return(gl.texture);
        }
Ejemplo n.º 8
0
        public float y1;                 // bottommost Y coordinate


        public render_bounds(render_bounds rhs)
        {
            x0 = rhs.x0; y0 = rhs.y0; x1 = rhs.x1; y1 = rhs.y1;
        }