Example #1
0
 void Input()
 {
     this.BeginOrtho();
     foreach (var v in vs)
     {
         var verts = UITool.GetVS(v, size, pivot);
         GLUI.DrawQuad(verts, Color.black);
     }
 }
Example #2
0
File: UI_Desc.cs Project: wjk17/WSA
    void _Input()
    {
        var rtBg     = new RectTrans(BgRT);
        var rtTitle  = new RectTrans(titleRT);
        var rtDesc   = new RectTrans(descRT);
        var rtDescBg = new RectTrans(descBgRT);

        this.BeginOrtho();
        this.DrawBG();
        GLUI.DrawString(rtTitle.cornerLB, name);
        GLUI.DrawString(rtDesc.cornerLT - 24.Y(), desc);
    }
Example #3
0
 public void Update()
 {
     if (exp >= expMax)
     {
         exp -= expMax;
         lvl++; // 升级
         hpMax += 10;
         mpMax += 5;
     }
     hpBar.Update((float)hp / hpMax);
     mpBar.Update((float)mp / mpMax);
     agilityBar.Update(agilityStoring);
     GLUI.DrawString(charName, pos, Vectors.half2d);
 }
Example #4
0
        void Input()
        {
            this.BeginOrtho(5);
            GLUI.SetFontColor(Color.black);
            //this.Draw(Palette.L8, true);
            //this.Draw(Color.black, false);

            var rtNum = new RectTrans(chordNum);

            GLUI.SetFontColor(Color.black);
            var sNum = "(" + InstKeyboard.I.chordIdx.ToString() + ")";

            GLUI.DrawString(sNum, rtNum.center, fontSizeNum, Vectors.half2d);

            var rtSS = new Rect(this.rtSS);

            rtSS.Draw(scaleShift ? colorSSOn : colorSSOff, true);
            rtSS.Draw(Color.black, false);

            var rt       = new RectTrans(this);
            var startpos = rt.center;

            var os = rt.sizeAbs.x / names.Length;
            var ps = startpos.Average(os, names.Length, Vectors.halfRight2d);

            for (int i = 0; i < names.Length; i++)
            {
                var rect = new Rect(ps[i], os * Vector2.right + sizeOs, Vectors.half2d);
                if (idx == i)
                {
                    rect.Draw(colorSel, true);
                    GLUI.SetFontColor(Color.white);
                    GLUI.DrawString(names[i], ps[i]);
                }
                else
                {
                    rect.Draw(colorNormal, true);
                    GLUI.SetFontColor(Color.black);
                    GLUI.DrawString(names[i], ps[i]);
                }
                rect.Draw(Color.black, false);
            }
        }
Example #5
0
        void Input()
        {
            this.BeginOrtho(-2);
            GLUI.SetFontColor(Color.black);
            this.Draw(Palette.L8, true);
            this.Draw(Color.black, false);
            var rt      = new RectTrans(this);
            var basePos = rt.centerT + Vector2.down * margin.y;


            // title
            var fn = loader.fileName.Split('.')[0];
            var ss = fn.Split('-');

            var songName = ss[1];

            GLUI.DrawString(songName, basePos, fontSizeH1, Vector2.up + Vectors.halfRight2d);

            var singerName = ss[0];

            GLUI.DrawString("演唱: " + singerName, basePos + h2Os, fontSizeH2, Vector2.up + Vectors.halfRight2d);
            basePos += Vector2.down * bodyOs;

            // average
            float barWidth = (rt.sizeAbs.x - margin.x * 2) / barPerLine;
            var   psBar    = basePos.Average(barWidth, barPerLine, Vectors.halfRight);

            int noteIdx = -1;

            //var notes = loader.notesTotal;
            //for (int i = 0; i < notes.Count; i++)
            //{
            //    var x = i % barPerLine;
            //    var y = i / barPerLine;
            //    var posBar = psBar[x] + Vector2.down * y * (lineSpace + fontSize);
            //    var psNote = posBar.Average(barWidth, barPerLine, Vectors.halfRight);

            //    // 弹过的音符变色
            //    GLUI.SetFontColor(Color.black);
            //    noteIdx++;
            //    if (passIdx >= noteIdx)
            //        GLUI.SetFontColor(passFontColor);

            //    var note = notes[i];
            //    var str = note.ToString().Reverse(); ;
            //    if (str.Length == 2)
            //    {
            //        GLUI.DrawString(str[1], psNote[x] + fontSize * shiftOSNor, fontSizeShift, Vector2.up + Vectors.halfRight2d);
            //    }
            //    GLUI.DrawString(str[0], psNote[x], fontSize, Vector2.up + Vectors.halfRight2d);

            //    // 变调小圆点
            //    var scaleShift = note.scale - middleScale5;
            //    var factor = Mathf.Sign(scaleShift);
            //    scaleShift = Mathf.Abs(scaleShift);
            //    for (int m = 0; m < scaleShift; m++)
            //    {
            //        var dir = Vector2.up * factor;
            //        GLUI.DrawString(shiftMark,
            //            psNote[x] + Vector2.down * fontSize * 0.5f +
            //            dir * fontSize * shiftMarkOS +
            //            dir * shiftMarkFontSize * m * shiftMarkOSFactor,
            //            fontSize, Vectors.half2d);

            //    }
            //}

            for (int i = 0; i < para.bars.Count; i++)
            {
                var bar   = para.bars[i];
                var beats = bar.beats;
                var x     = i % barPerLine;
                var y     = i / barPerLine;

                var posBar = psBar[x] + Vector2.down * y * (lineSpace + fontSize);

                var beatWid = beatSpaceAdd + barWidth / beats.Count;
                var psBeat  = posBar.Average(beatWid, beats.Count, Vectors.halfRight);

                for (int j = 0; j < bar.beats.Count; j++)
                {
                    var beat  = beats[j];
                    var notes = beat.notes;

                    var noteWid = noteSpaceAdd + beatWid / notes.Count;
                    var psNote  = psBeat[j].Average(noteWid, notes.Count, Vectors.halfRight);
                    for (int k = 0; k < notes.Count; k++)
                    {
                        GLUI.SetFontColor(Color.black);
                        noteIdx++;
                        if (passIdx >= noteIdx)
                        {
                            GLUI.SetFontColor(passFontColor);
                        }
                        var note = notes[k];
                        var str  = note.ToString().Reverse();;
                        if (str.Length == 2)
                        {
                            GLUI.DrawString(str[1], psNote[k] + fontSize * shiftOSNor, fontSizeShift, Vector2.up + Vectors.halfRight2d);
                        }
                        GLUI.DrawString(str[0], psNote[k], fontSize, Vector2.up + Vectors.halfRight2d);

                        if (drawLyric)
                        {
                            // 歌词
                            var word = loader.lyric[noteIdx];
                            var sp   = Vectors.halfDown2d * (lineSpace + fontSize);
                            var pos  = psNote[k] + sp;
                            GLUI.DrawString(word, pos, fontSizeLyric, Vector2.up + Vectors.halfRight2d);
                        }
                        // 变调小圆点
                        var scaleShift = note.scale - middleScale5;
                        var factor     = Mathf.Sign(scaleShift);
                        scaleShift = Mathf.Abs(scaleShift);
                        for (int m = 0; m < scaleShift; m++)
                        {
                            var dir = Vector2.up * factor;
                            GLUI.DrawString(shiftMark,
                                            psNote[k] + Vector2.down * fontSize * 0.5f +
                                            dir * fontSize * shiftMarkOS +
                                            dir * shiftMarkFontSize * m * shiftMarkOSFactor,
                                            fontSize, Vectors.half2d);
                        }
                    }
                }
            }
        }
Example #6
0
        void Input()
        {
            this.StartGLWorld(200);
            var v3 = new List <Vector3>();

            foreach (var v in mq.vertexShared)
            {
                v3.Add(transform.TransformPoint(v));
            }
            foreach (var q in mq.quads)
            {
                var ps     = q.index;
                var colors = new List <Color>();
                foreach (var p in ps)
                {
                    var sel = idxs.Contains(p);
                    colors.Add(sel ? Color.yellow : Color.black);
                }
                GLUI.DrawLineDirect(v3[q.a], v3[q.b], colors[0], colors[1]);
                GLUI.DrawLineDirect(v3[q.b], v3[q.c], colors[1], colors[2]);
                GLUI.DrawLineDirect(v3[q.c], v3[q.d], colors[2], colors[3]);
                GLUI.DrawLineDirect(v3[q.d], v3[q.a], colors[3], colors[0]);
            }
            var vRectSize = (size * 10).ToNDC();
            var vSize     = size.ToNDC();

            GLUI.BeginOrder(1);
            if (Events.KeyDown(KeyCode.A))
            {
                GizmosAxis.I.Disactive();
                idx = -1;
            }
            int  i     = 0;
            bool click = false;

            foreach (var v in mq.vertexShared)
            {
                var vp = cam.WorldToViewportPoint(v3[i]);
                // 点击
                if (!click && Events.MouseDown1)
                {
                    var rect = new Rect(vp, vRectSize, Vectors.half2d);
                    if (rect.Contains(UI.mousePosView))
                    {
                        click = true;
                        idxs.Clear();
                        idxs.Add(i);
                        idx = i;
                        GizmosAxis.I.Active();
                        GizmosAxis.I.transform.position = v3[i];
                    }
                }
                // 绘制
                var vps  = UITool.GetVS(vp, vSize, Vectors.half2d);
                var vps3 = vps.SetZ(vp.z + zOffset);
                for (int j = 0; j < vps.Length; j++)
                {
                    vps3[j] = cam.ViewportToWorldPoint(vps3[j]);
                }

                GLUI.DrawQuadDirect(i == idx ? Color.yellow : Color.black, vps3);
                i++;
            }
            if (idx > -1)
            {
                mq.vertexShared[idx] = GizmosAxis.I.transform.position;
            }
            //mq.Apply();
            mq.ApplyShared();
        }