Example #1
0
        public static void drawScissor(NvgContext vg, float x, float y, float t)
        {
            vg.Save();

            // Draw first rect and set scissor to it's area.
            vg.Translate(x, y);
            vg.Rotate(NvgUtility.DegToRad(5));
            vg.BeginPath();
            vg.Rect(-20, -20, 60, 40);
            vg.FillColor(new Color(255, 0, 0, 255));
            vg.Fill();
            vg.Scissor(-20, -20, 60, 40);

            // Draw second rectangle with offset and rotation.
            vg.Translate(40, 0);
            vg.Rotate(t);

            // Draw the intended second rectangle without any scissoring.
            vg.Save();
            vg.ResetScissor();
            vg.BeginPath();
            vg.Rect(-20, -10, 60, 30);
            vg.FillColor(new Color(255, 128, 0, 64));
            vg.Fill();
            vg.Restore();

            // Draw second rectangle with combined scissoring.
            vg.IntersectScissor(-20, -10, 60, 30);
            vg.BeginPath();
            vg.Rect(-20, -10, 60, 30);
            vg.FillColor(new Color(255, 128, 0, 255));
            vg.Fill();

            vg.Restore();
        }
Example #2
0
        public static void drawColorwheel(NvgContext vg, float x, float y, float w, float h, float t)
        {
            int   i;
            float r0, r1, ax, ay, bx, by, cx, cy, aeps, r;
            float hue = (float)Math.Sin(t * 0.12f);
            Paint paint;

            vg.Save();

            /*	vg.BeginPath();
             *      vg.Rect(x,y,w,h);
             *      vg.FillColor(new Color(255,0,0,128));
             *      vg.Fill();*/

            cx   = x + w * 0.5f;
            cy   = y + h * 0.5f;
            r1   = (w < h ? w : h) * 0.5f - 5.0f;
            r0   = r1 - 20.0f;
            aeps = 0.5f / r1;               // half a pixel arc length in radians (2pi cancels out).

            for (i = 0; i < 6; i++)
            {
                float a0 = (float)i / 6.0f * (float)Math.PI * 2.0f - aeps;
                float a1 = (float)(i + 1.0f) / 6.0f * (float)Math.PI * 2.0f + aeps;
                vg.BeginPath();
                vg.Arc(cx, cy, r0, a0, a1, Winding.ClockWise);
                vg.Arc(cx, cy, r1, a1, a0, Winding.CounterClockWise);
                vg.ClosePath();
                ax    = cx + (float)Math.Cos(a0) * (r0 + r1) * 0.5f;
                ay    = cy + (float)Math.Sin(a0) * (r0 + r1) * 0.5f;
                bx    = cx + (float)Math.Cos(a1) * (r0 + r1) * 0.5f;
                by    = cy + (float)Math.Sin(a1) * (r0 + r1) * 0.5f;
                paint = vg.LinearGradient(ax, ay, bx, by, NvgUtility.HSLA(a0 / ((float)Math.PI * 2), 1.0f, 0.55f, 255), NvgUtility.HSLA(a1 / ((float)Math.PI * 2), 1.0f, 0.55f, 255));
                vg.FillPaint(paint);
                vg.Fill();
            }

            vg.BeginPath();
            vg.Circle(cx, cy, r0 - 0.5f);
            vg.Circle(cx, cy, r1 + 0.5f);
            vg.StrokeColor(new Color(0, 0, 0, 64));
            vg.StrokeWidth(1.0f);
            vg.Stroke();

            // Selector
            vg.Save();
            vg.Translate(cx, cy);
            vg.Rotate(hue * (float)Math.PI * 2);

            // Marker on
            vg.StrokeWidth(2.0f);
            vg.BeginPath();
            vg.Rect(r0 - 1, -3, r1 - r0 + 2, 6);
            vg.StrokeColor(new Color(255, 255, 255, 192));
            vg.Stroke();

            paint = vg.BoxGradient(r0 - 3, -5, r1 - r0 + 6, 10, 2, 4, new Color(0, 0, 0, 128), new Color(0, 0, 0, 0));
            vg.BeginPath();
            vg.Rect(r0 - 2 - 10, -4 - 10, r1 - r0 + 4 + 20, 8 + 20);
            vg.Rect(r0 - 2, -4, r1 - r0 + 4, 8);
            vg.PathWinding(Solidity.Hole);
            vg.FillPaint(paint);
            vg.Fill();

            // Center triangle
            r  = r0 - 6;
            ax = (float)Math.Cos(120.0f / 180.0f * (float)Math.PI) * r;
            ay = (float)Math.Sin(120.0f / 180.0f * (float)Math.PI) * r;
            bx = (float)Math.Cos(-120.0f / 180.0f * (float)Math.PI) * r;
            by = (float)Math.Sin(-120.0f / 180.0f * (float)Math.PI) * r;
            vg.BeginPath();
            vg.MoveTo(r, 0);
            vg.LineTo(ax, ay);
            vg.LineTo(bx, by);
            vg.ClosePath();
            paint = vg.LinearGradient(r, 0, ax, ay, NvgUtility.HSLA(hue, 1.0f, 0.5f, 255), new Color(255, 255, 255, 255));
            vg.FillPaint(paint);
            vg.Fill();
            paint = vg.LinearGradient((r + ax) * 0.5f, (0 + ay) * 0.5f, bx, by, new Color(0, 0, 0, 0), new Color(0, 0, 0, 255));
            vg.FillPaint(paint);
            vg.Fill();
            vg.StrokeColor(new Color(0, 0, 0, 64));
            vg.Stroke();

            // Select circle on triangle
            ax = (float)Math.Cos(120.0f / 180.0f * (float)Math.PI) * r * 0.3f;
            ay = (float)Math.Sin(120.0f / 180.0f * (float)Math.PI) * r * 0.4f;
            vg.StrokeWidth(2.0f);
            vg.BeginPath();
            vg.Circle(ax, ay, 5);
            vg.StrokeColor(new Color(255, 255, 255, 192));
            vg.Stroke();

            paint = vg.RadialGradient(ax, ay, 7, 9, new Color(0, 0, 0, 64), new Color(0, 0, 0, 0));
            vg.BeginPath();
            vg.Rect(ax - 20, ay - 20, 40, 40);
            vg.Circle(ax, ay, 7);
            vg.PathWinding(Solidity.Hole);
            vg.FillPaint(paint);
            vg.Fill();

            vg.Restore();

            vg.Restore();
        }
Example #3
0
        public static void drawThumbnails(NvgContext vg, float x, float y, float w, float h, int[] images, float t)
        {
            float cornerRadius = 3.0f;
            Paint shadowPaint, imgPaint, fadePaint;
            float ix, iy, iw, ih;
            float thumb = 60.0f;
            float arry = 30.5f;
            int   imgw, imgh;
            float stackh = (images.Length / 2) * (thumb + 10) + 10;
            int   i;
            float u = (1 + (float)Math.Cos(t * 0.5f)) * 0.5f;
            float u2 = (1 - (float)Math.Cos(t * 0.2f)) * 0.5f;
            float scrollh, dv;

            vg.Save();
            //	ClearState(vg);

            // Drop shadow
            shadowPaint = vg.BoxGradient(x, y + 4, w, h, cornerRadius * 2, 20, new Color(0, 0, 0, 128), new Color(0, 0, 0, 0));
            vg.BeginPath();
            vg.Rect(x - 10, y - 10, w + 20, h + 30);
            vg.RoundedRect(x, y, w, h, cornerRadius);
            vg.PathWinding(Solidity.Hole);
            vg.FillPaint(shadowPaint);
            vg.Fill();

            // Window
            vg.BeginPath();
            vg.RoundedRect(x, y, w, h, cornerRadius);
            vg.MoveTo(x - 10, y + arry);
            vg.LineTo(x + 1, y + arry - 11);
            vg.LineTo(x + 1, y + arry + 11);
            vg.FillColor(new Color(200, 200, 200, 255));
            vg.Fill();

            vg.Save();
            vg.Scissor(x, y, w, h);
            vg.Translate(0, -(stackh - h) * u);

            dv = 1.0f / (float)(images.Length - 1);

            for (i = 0; i < images.Length; i++)
            {
                float tx, ty, v, a;
                tx  = x + 10;
                ty  = y + 10;
                tx += (i % 2) * (thumb + 10);
                ty += (i / 2) * (thumb + 10);
                vg.ImageSize(images[i], out imgw, out imgh);
                if (imgw < imgh)
                {
                    iw = thumb;
                    ih = iw * (float)imgh / (float)imgw;
                    ix = 0;
                    iy = -(ih - thumb) * 0.5f;
                }
                else
                {
                    ih = thumb;
                    iw = ih * (float)imgw / (float)imgh;
                    ix = -(iw - thumb) * 0.5f;
                    iy = 0;
                }

                v = i * dv;
                a = clampf((u2 - v) / dv, 0, 1);

                if (a < 1.0f)
                {
                    drawSpinner(vg, tx + thumb / 2, ty + thumb / 2, thumb * 0.25f, t);
                }

                imgPaint = vg.ImagePattern(tx + ix, ty + iy, iw, ih, 0.0f / 180.0f * (float)Math.PI, images[i], a);
                vg.BeginPath();
                vg.RoundedRect(tx, ty, thumb, thumb, 5);
                vg.FillPaint(imgPaint);
                vg.Fill();

                shadowPaint = vg.BoxGradient(tx - 1, ty, thumb + 2, thumb + 2, 5, 3, new Color(0, 0, 0, 128), new Color(0, 0, 0, 0));
                vg.BeginPath();
                vg.Rect(tx - 5, ty - 5, thumb + 10, thumb + 10);
                vg.RoundedRect(tx, ty, thumb, thumb, 6);
                vg.PathWinding(Solidity.Hole);
                vg.FillPaint(shadowPaint);
                vg.Fill();

                vg.BeginPath();
                vg.RoundedRect(tx + 0.5f, ty + 0.5f, thumb - 1, thumb - 1, 4 - 0.5f);
                vg.StrokeWidth(1.0f);
                vg.StrokeColor(new Color(255, 255, 255, 192));
                vg.Stroke();
            }
            vg.Restore();

            // Hide fades
            fadePaint = vg.LinearGradient(x, y, x, y + 6, new Color(200, 200, 200, 255), new Color(200, 200, 200, 0));
            vg.BeginPath();
            vg.Rect(x + 4, y, w - 8, 6);
            vg.FillPaint(fadePaint);
            vg.Fill();

            fadePaint = vg.LinearGradient(x, y + h, x, y + h - 6, new Color(200, 200, 200, 255), new Color(200, 200, 200, 0));
            vg.BeginPath();
            vg.Rect(x + 4, y + h - 6, w - 8, 6);
            vg.FillPaint(fadePaint);
            vg.Fill();

            // Scroll bar
            shadowPaint = vg.BoxGradient(x + w - 12 + 1, y + 4 + 1, 8, h - 8, 3, 4, new Color(0, 0, 0, 32), new Color(0, 0, 0, 92));
            vg.BeginPath();
            vg.RoundedRect(x + w - 12, y + 4, 8, h - 8, 3);
            vg.FillPaint(shadowPaint);
            //	vg.FillColor(new Color(255,0,0,128));
            vg.Fill();

            scrollh     = (h / stackh) * (h - 8);
            shadowPaint = vg.BoxGradient(x + w - 12 - 1, y + 4 + (h - 8 - scrollh) * u - 1, 8, scrollh, 3, 4, new Color(220, 220, 220, 255), new Color(128, 128, 128, 255));
            vg.BeginPath();
            vg.RoundedRect(x + w - 12 + 1, y + 4 + 1 + (h - 8 - scrollh) * u, 8 - 2, scrollh - 2, 2);
            vg.FillPaint(shadowPaint);
            //	vg.FillColor(new Color(0,0,0,128));
            vg.Fill();

            vg.Restore();
        }
Example #4
0
        public void Render(NvgContext vg, int x, int y, float w, float h, float gameTime)
        {
            vg.Save();
            vg.Translate(x, y);

            vg.bndSplitterWidgets(0, 0, w, h);

            x = 10;
            y = 10;

            vg.bndToolButton(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_DEFAULT,
                             BNDicon.BND_ICON_GHOST, "Default");
            y += 25;
            vg.bndToolButton(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_HOVER,
                             BNDicon.BND_ICON_GHOST, "Hovered");
            y += 25;
            vg.bndToolButton(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_ACTIVE,
                             BNDicon.BND_ICON_GHOST, "Active");

            y += 40;
            vg.bndRadioButton(x, y, 80, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_DEFAULT,
                              null, "Default");
            y += 25;
            vg.bndRadioButton(x, y, 80, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_HOVER,
                              null, "Hovered");
            y += 25;
            vg.bndRadioButton(x, y, 80, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_ACTIVE,
                              null, "Active");

            y += 25;
            vg.bndLabel(x, y, 120, Blendish.BND_WIDGET_HEIGHT, null, "Label:");
            y += Blendish.BND_WIDGET_HEIGHT;
            vg.bndChoiceButton(x, y, 80, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_DEFAULT,
                               null, "Default");
            y += 25;
            vg.bndChoiceButton(x, y, 80, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_HOVER,
                               null, "Hovered");
            y += 25;
            vg.bndChoiceButton(x, y, 80, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_ACTIVE,
                               null, "Active");

            y += 25;
            int ry = y;
            int rx = x;

            y  = 10;
            x += 130;
            vg.bndOptionButton(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDwidgetState.BND_DEFAULT, "Default");
            y += 25;
            vg.bndOptionButton(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDwidgetState.BND_HOVER, "Hovered");
            y += 25;
            vg.bndOptionButton(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDwidgetState.BND_ACTIVE, "Active");

            y += 40;
            vg.bndNumberField(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_DOWN, BNDwidgetState.BND_DEFAULT,
                              "Top", "100");
            y += Blendish.BND_WIDGET_HEIGHT - 2;
            vg.bndNumberField(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL, BNDwidgetState.BND_DEFAULT,
                              "Center", "100");
            y += Blendish.BND_WIDGET_HEIGHT - 2;
            vg.bndNumberField(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_TOP, BNDwidgetState.BND_DEFAULT,
                              "Bottom", "100");

            int mx = x - 30;
            int my = y - 12;
            int mw = 120;

            vg.bndMenuBackground(mx, my, mw, 120, BNDcornerFlags.BND_CORNER_TOP);
            vg.bndMenuLabel(mx, my, mw, Blendish.BND_WIDGET_HEIGHT, null, "Menu Title");
            my += Blendish.BND_WIDGET_HEIGHT - 2;
            vg.bndMenuItem(mx, my, mw, Blendish.BND_WIDGET_HEIGHT, BNDwidgetState.BND_DEFAULT,
                           BNDicon.BND_ICON_FILE_FOLDER, "Default");
            my += Blendish.BND_WIDGET_HEIGHT - 2;
            vg.bndMenuItem(mx, my, mw, Blendish.BND_WIDGET_HEIGHT, BNDwidgetState.BND_HOVER,
                           BNDicon.BND_ICON_FILE_BLANK, "Hovered");
            my += Blendish.BND_WIDGET_HEIGHT - 2;
            vg.bndMenuItem(mx, my, mw, Blendish.BND_WIDGET_HEIGHT, BNDwidgetState.BND_ACTIVE,
                           BNDicon.BND_ICON_FILE_BLEND, "Active");

            y  = 10;
            x += 130;
            int ox = x;

            vg.bndNumberField(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_DEFAULT,
                              "Default", "100");
            y += 25;
            vg.bndNumberField(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_HOVER,
                              "Hovered", "100");
            y += 25;
            vg.bndNumberField(x, y, 120, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_ACTIVE,
                              "Active", "100");

            y += 40;
            vg.bndRadioButton(x, y, 60, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_RIGHT, BNDwidgetState.BND_DEFAULT,
                              null, "One");
            x += 60 - 1;
            vg.bndRadioButton(x, y, 60, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL, BNDwidgetState.BND_DEFAULT,
                              null, "Two");
            x += 60 - 1;
            vg.bndRadioButton(x, y, 60, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL, BNDwidgetState.BND_DEFAULT,
                              null, "Three");
            x += 60 - 1;
            vg.bndRadioButton(x, y, 60, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_LEFT, BNDwidgetState.BND_ACTIVE,
                              null, "Butts");

            x  = ox;
            y += 40;

            float  progress_value = fmodf(gameTime / 10.0f, 1.0f);
            string progress_label;

            progress_label = string.Format("{0:0.00}", progress_value * 100 + 0.5f);
            vg.bndSlider(x, y, 240, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_DEFAULT,
                         progress_value, "Default", progress_label);
            y += 25;
            vg.bndSlider(x, y, 240, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_HOVER,
                         progress_value, "Hovered", progress_label);
            y += 25;
            vg.bndSlider(x, y, 240, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_ACTIVE,
                         progress_value, "Active", progress_label);

            int   rw       = x + 240 - rx;
            float s_offset = (float)Math.Sin(gameTime / 2.0f) * 0.5f + 0.5f;
            float s_size   = (float)Math.Cos(gameTime / 3.11f) * 0.5f + 0.5f;

            vg.bndScrollBar(rx, ry, rw, Blendish.BND_SCROLLBAR_HEIGHT, BNDwidgetState.BND_DEFAULT, s_offset, s_size);
            ry += 20;
            vg.bndScrollBar(rx, ry, rw, Blendish.BND_SCROLLBAR_HEIGHT, BNDwidgetState.BND_HOVER, s_offset, s_size);
            ry += 20;
            vg.bndScrollBar(rx, ry, rw, Blendish.BND_SCROLLBAR_HEIGHT, BNDwidgetState.BND_ACTIVE, s_offset, s_size);

            string edit_text = "The quick brown fox";
            int    t         = (int)(gameTime * 2);
            int    idx1      = (t / edit_text.Length) % edit_text.Length;
            int    idx2      = idx1 + (t % (edit_text.Length - idx1));

            ry += 25;
            vg.bndTextField(rx, ry, 240, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_DEFAULT,
                            null, edit_text, idx1, idx2);
            ry += 25;
            vg.bndTextField(rx, ry, 240, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_HOVER,
                            null, edit_text, idx1, idx2);
            ry += 25;
            vg.bndTextField(rx, ry, 240, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_NONE, BNDwidgetState.BND_ACTIVE,
                            null, edit_text, idx1, idx2);

            draw_noodles(vg, 20, ry + 50);

            rx += rw + 20;
            ry  = 10;
            vg.bndScrollBar(rx, ry, Blendish.BND_SCROLLBAR_WIDTH, 240, BNDwidgetState.BND_DEFAULT, s_offset, s_size);
            rx += 20;
            vg.bndScrollBar(rx, ry, Blendish.BND_SCROLLBAR_WIDTH, 240, BNDwidgetState.BND_HOVER, s_offset, s_size);
            rx += 20;
            vg.bndScrollBar(rx, ry, Blendish.BND_SCROLLBAR_WIDTH, 240, BNDwidgetState.BND_ACTIVE, s_offset, s_size);

            x  = ox;
            y += 40;
            vg.bndToolButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_RIGHT,
                             BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_REC, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndToolButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL,
                             BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_PLAY, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndToolButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL,
                             BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_FF, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndToolButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL,
                             BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_REW, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndToolButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL,
                             BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_PAUSE, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndToolButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_LEFT,
                             BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_PREV_KEYFRAME, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            x += 5;
            vg.bndRadioButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_RIGHT,
                              BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_MOD_CLOTH, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndRadioButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL,
                              BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_MOD_EXPLODE, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndRadioButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL,
                              BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_MOD_FLUIDSIM, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndRadioButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL,
                              BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_MOD_MULTIRES, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndRadioButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_ALL,
                              BNDwidgetState.BND_ACTIVE, BNDicon.BND_ICON_MOD_SMOKE, null);
            x += Blendish.BND_TOOL_WIDTH - 1;
            vg.bndRadioButton(x, y, Blendish.BND_TOOL_WIDTH, Blendish.BND_WIDGET_HEIGHT, BNDcornerFlags.BND_CORNER_LEFT,
                              BNDwidgetState.BND_DEFAULT, BNDicon.BND_ICON_MOD_SOLIDIFY, null);

            vg.Restore();
        }