Exemple #1
0
 public void Join(GCodePath path)
 {
     foreach (LinkedList<GCodePoint> frag in path.pointsLists)
     {
         pointsLists.AddLast(frag);
     }
     pointsCount += path.pointsCount;
     if (elements != null && path.elements != null)
     {
         if (/*normals!=null && */path.elements != null && drawMethod == path.drawMethod) // both parts are already up to date, so just join them
         {
             int[] newelements = new int[elementsLength + path.elementsLength];
             int p, l = elementsLength, i;
             for (p = 0; p < l; p++) newelements[p] = elements[p];
             int[] pe = path.elements;
             l = path.elementsLength;
             int pointsold = positions.Length / 3;
             for (i = 0; i < l; i++) newelements[p++] = pe[i] + pointsold;
             elements = newelements;
             elementsLength = elements.Length;
             float[] newnormals = null;
             if (normals != null) newnormals = new float[normals.Length + path.normals.Length];
             float[] newpoints = new float[positions.Length + path.positions.Length];
             if (normals != null)
             {
                 l = normals.Length;
                 for (p = 0; p < l; p++)
                 {
                     newnormals[p] = normals[p];
                     newpoints[p] = positions[p];
                 }
                 float[] pn = path.normals;
                 float[] pp = path.positions;
                 l = pp.Length;
                 for (i = 0; i < l; i++)
                 {
                     newnormals[p] = pn[i];
                     newpoints[p++] = pp[i];
                 }
                 normals = newnormals;
                 positions = newpoints;
             }
             else
             {
                 l = positions.Length;
                 for (p = 0; p < l; p++)
                 {
                     newpoints[p] = positions[p];
                 }
                 float[] pp = path.positions;
                 l = pp.Length;
                 for (i = 0; i < l; i++)
                 {
                     newpoints[p++] = pp[i];
                 }
                 positions = newpoints;
             }
         }
         else
         {
             elements = null;
             normals = null;
             positions = null;
             drawMethod = -1;
         }
         if (hasBuf)
         {
             GL.DeleteBuffers(3, buf);
             hasBuf = false;
         }
     }
     else
     {
         drawMethod = -1;
     }
 }
Exemple #2
0
        void OnPosChangeFast(float x, float y, float z, float e)
        {
            if (!ana.drawing || ana.layer < minLayer || ana.layer > maxLayer)
            {
                lastx = x;
                lasty = y;
                lastz = z;
                laste = ana.emax;
                lastLayer = ana.layer;
                return;
            }
            float locDist = (float)Math.Sqrt((x - lastx) * (x - lastx) + (y - lasty) * (y - lasty) + (z - lastz) * (z - lastz));
            bool isLastPos = locDist < 0.00001;
            int segpos = ana.activeExtruder;
            if (ana.eChanged == false)
            {
                GCodeTravel travel = new GCodeTravel();
                travel.fline = GCodePoint.toFileLine(fileid, actLine);
                travel.p1.X = lastx;
                travel.p1.Y = lasty;
                travel.p1.Z = lastz;
                travel.p2.X = x;
                travel.p2.Y = y;
                travel.p2.Z = z;
                travelMoves.Add(travel);
            }
            if (segpos < 0 || segpos >= MaxExtruder) segpos = 0;
            LinkedList<GCodePath> seg = segments[segpos];
            //if (!act.hasG || (act.G > 1 && act.G != 28)) return;
            if (lastLayer == minLayer - 1 && laste < e)
            {
                GCodePath p = new GCodePath();
                p.Add(new Vector3(lastx, lasty, lastz), laste, totalDist, GCodePoint.toFileLine(fileid, actLine));

                if (seg.Count > 0 && seg.Last.Value.pointsLists.Last.Value.Count == 1)
                {
                    seg.RemoveLast();
                }
                seg.AddLast(p);
            }

            if (seg.Count == 0 || laste >= ana.e) // start new segment
            {
                if (!isLastPos) // no move, no action
                {
                    GCodePath p = new GCodePath();
                    p.Add(new Vector3(x, y, z), ana.emax, totalDist, GCodePoint.toFileLine(fileid, actLine));
                    if (seg.Count > 0 && seg.Last.Value.pointsLists.Last.Value.Count == 1)
                    {
                        seg.RemoveLast();
                    }
                    seg.AddLast(p);
                    //changed = true;
                }
            }
            else
            {
                if (!isLastPos)
                {
                    totalDist += locDist;
                    seg.Last.Value.Add(new Vector3(x, y, z), ana.emax, totalDist, GCodePoint.toFileLine(fileid, actLine));
                    //changed = true;
                }
            }
            lastx = x;
            lasty = y;
            lastz = z;
            laste = ana.emax;
            lastLayer = ana.layer;
        }
Exemple #3
0
        public void drawSegment(GCodePath path)
        {
            if (Main.threeDSettings.drawMethod == 2)
            {
                GL.Material(MaterialFace.FrontAndBack, MaterialParameter.AmbientAndDiffuse, defaultColor);
                GL.EnableClientState(ArrayCap.VertexArray);
                if (path.drawMethod != method || recompute)
                {
                    path.UpdateVBO(true);
                }
                else if (path.hasBuf == false && path.elements != null)
                    path.RefillVBO();
                if (path.elements == null) return;
                GL.BindBuffer(BufferTarget.ArrayBuffer, path.buf[0]);
                GL.VertexPointer(3, VertexPointerType.Float, 0, 0);
                float[] cp;
                if (liveView && path.lastDist > minHotDist)
                {
                    GL.EnableClientState(ArrayCap.ColorArray);
                    cp = new float[path.positions.Length];
                    int nv = 8 * (method - 1);
                    if (method == 1) nv = 4;
                    if (method == 0) nv = 1;
                    int p = 0;
                    foreach (LinkedList<GCodePoint> points in path.pointsLists)
                    {
                        if (points.Count < 2) continue;
                        foreach (GCodePoint pt in points)
                        {
                            computeColor(pt.dist);
                            for (int j = 0; j < nv; j++)
                            {
                                cp[p++] = curColor[0];
                                cp[p++] = curColor[1];
                                cp[p++] = curColor[2];
                            }
                        }
                    }
                    GL.Enable(EnableCap.ColorMaterial);
                    GL.ColorMaterial(MaterialFace.FrontAndBack, ColorMaterialParameter.AmbientAndDiffuse);
                    if (colbufSize < cp.Length)
                    {
                        if (colbufSize != 0)
                            GL.DeleteBuffers(1, colbuf);
                        GL.GenBuffers(1, colbuf);
                        colbufSize = cp.Length;
                        GL.BindBuffer(BufferTarget.ArrayBuffer, colbuf[0]);
                        GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(cp.Length * sizeof(float) * 2), (IntPtr)0, BufferUsageHint.StaticDraw);
                    }
                    GL.BindBuffer(BufferTarget.ArrayBuffer, colbuf[0]);
                    GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)0, (IntPtr)(cp.Length * sizeof(float)), cp);
                    GL.ColorPointer(3, ColorPointerType.Float, 0, 0);
                }
                if (method == 0)
                {
                    GL.BindBuffer(BufferTarget.ElementArrayBuffer, path.buf[2]);
                    GL.DrawElements(BeginMode.Lines, path.elementsLength, DrawElementsType.UnsignedInt, 0);
                }
                else
                {
                    GL.EnableClientState(ArrayCap.NormalArray);
                    GL.BindBuffer(BufferTarget.ArrayBuffer, path.buf[1]);
                    GL.NormalPointer(NormalPointerType.Float, 0, 0);
                    GL.BindBuffer(BufferTarget.ElementArrayBuffer, path.buf[2]);
                    GL.DrawElements(BeginMode.Quads, path.elementsLength, DrawElementsType.UnsignedInt, 0);
                    GL.DisableClientState(ArrayCap.NormalArray);
                }
                if (liveView && path.lastDist > minHotDist)
                {
                    GL.Disable(EnableCap.ColorMaterial);
                    GL.DisableClientState(ArrayCap.ColorArray);
                }
                GL.DisableClientState(ArrayCap.VertexArray);
                GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
            }
            else
            {
                if (path.drawMethod != method || recompute || path.hasBuf)
                    path.UpdateVBO(false);
                if (Main.threeDSettings.drawMethod > 0) // Is also fallback for vbos with dynamic colors
                {
                    GL.EnableClientState(ArrayCap.VertexArray);
                    if (path.elements == null) return;
                    GL.VertexPointer(3, VertexPointerType.Float, 0, path.positions);
                    float[] cp;
                    if (liveView && path.lastDist > minHotDist)
                    {
                        GL.EnableClientState(ArrayCap.ColorArray);
                        cp = new float[path.positions.Length];
                        int nv = 8 * (method - 1);
                        if (method == 1) nv = 4;
                        if (method == 0) nv = 1;
                        int p = 0;
                        foreach (LinkedList<GCodePoint> points in path.pointsLists)
                        {
                            foreach (GCodePoint pt in points)
                            {
                                computeColor(pt.dist);
                                for (int j = 0; j < nv; j++)
                                {
                                    cp[p++] = curColor[0];
                                    cp[p++] = curColor[1];
                                    cp[p++] = curColor[2];
                                }
                            }
                        }
                        GL.Enable(EnableCap.ColorMaterial);
                        GL.ColorMaterial(MaterialFace.FrontAndBack, ColorMaterialParameter.AmbientAndDiffuse);
                        GL.ColorPointer(3, ColorPointerType.Float, 0, cp);
                    }
                    if (method == 0)
                        GL.DrawElements(BeginMode.Lines, path.elementsLength, DrawElementsType.UnsignedInt, path.elements);
                    else
                    {
                        GL.EnableClientState(ArrayCap.NormalArray);
                        GL.NormalPointer(NormalPointerType.Float, 0, path.normals);
                        GL.DrawElements(BeginMode.Quads, path.elementsLength, DrawElementsType.UnsignedInt, path.elements);
                        GL.DisableClientState(ArrayCap.NormalArray);
                    }
                    /*ErrorCode err = GL.GetError();
                    if (err != ErrorCode.NoError)
                    {
                        PrinterConnection.logInfo("D1 error" + err);
                    }*/
                    if (liveView && path.lastDist > minHotDist)
                    {
                        GL.Disable(EnableCap.ColorMaterial);
                        GL.DisableClientState(ArrayCap.ColorArray);
                    }
                    GL.DisableClientState(ArrayCap.VertexArray);
                }
                else
                {
                    if (!liveView || path.lastDist < minHotDist)
                    {
                        int i, l = path.elementsLength;
                        if (method == 0)
                        {
                            GL.Begin(BeginMode.Lines);
                            for (i = 0; i < l; i++)
                            {
                                int p = path.elements[i] * 3;
                                GL.Vertex3(ref path.positions[p]);
                            }
                            GL.End();
                        }
                        else
                        {
                            GL.Begin(BeginMode.Quads);
                            for (i = 0; i < l; i++)
                            {
                                int p = path.elements[i] * 3;
                                GL.Normal3(ref path.normals[p]);
                                GL.Vertex3(ref path.positions[p]);
                            }
                            GL.End();
                        }
                    }
                    else
                    {
                        if (method > 0)
                        {
                            int nv = 8 * (method - 1), i;
                            if (method == 1) nv = 4;
                            float alpha, dalpha = (float)Math.PI * 2f / nv;
                            float[] dir = new float[3];
                            float[] dirs = new float[3];
                            float[] diru = new float[3];
                            float[] n = new float[3];
                            float dh = 0.5f * h;
                            float dw = 0.5f * w;
                            if (path.pointsCount < 2) return;
                            GL.Begin(BeginMode.Quads);
                            bool first = true;
                            Vector3 last = new Vector3();
                            foreach (LinkedList<GCodePoint> points in path.pointsLists)
                            {
                                first = true;
                                foreach (GCodePoint pt in points)
                                {
                                    Vector3 v = pt.p;
                                    setColor(pt.dist);
                                    if (first)
                                    {
                                        last = v;
                                        first = false;
                                        continue;
                                    }
                                    bool isLast = pt == points.Last.Value;
                                    dir[0] = v.X - last.X;
                                    dir[1] = v.Y - last.Y;
                                    dir[2] = v.Z - last.Z;
                                    if (!fixedH)
                                    {
                                        float dist = (float)Math.Sqrt(dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2]);
                                        if (dist > 0)
                                        {
                                            h = (float)Math.Sqrt((pt.e - laste) * dfac / dist);
                                            w = h * wfac;
                                            dh = 0.5f * h;
                                            dw = 0.5f * w;
                                        }
                                    }
                                    normalize(ref dir);
                                    dirs[0] = -dir[1];
                                    dirs[1] = dir[0];
                                    dirs[2] = dir[2];
                                    diru[0] = diru[1] = 0;
                                    diru[2] = 1;
                                    alpha = 0;
                                    float c = (float)Math.Cos(alpha) * dh;
                                    float s = (float)Math.Sin(alpha) * dw;
                                    n[0] = (float)(s * dirs[0] + c * diru[0]);
                                    n[1] = (float)(s * dirs[1] + c * diru[1]);
                                    n[2] = (float)(s * dirs[2] + c * diru[2]);
                                    normalize(ref n);
                                    GL.Normal3(n[0], n[1], n[2]);
                                    for (i = 0; i < nv; i++)
                                    {
                                        GL.Vertex3(last.X + s * dirs[0] + c * diru[0], last.Y + s * dirs[1] + c * diru[1], last.Z - dh + s * dirs[2] + c * diru[2]);
                                        GL.Vertex3(v.X + s * dirs[0] + c * diru[0], v.Y + s * dirs[1] + c * diru[1], v.Z - dh + s * dirs[2] + c * diru[2]);
                                        alpha += dalpha;
                                        c = (float)Math.Cos(alpha) * dh;
                                        s = (float)Math.Sin(alpha) * dw;
                                        n[0] = (float)(s * dirs[0] + c * diru[0]);
                                        n[1] = (float)(s * dirs[1] + c * diru[1]);
                                        n[2] = (float)(s * dirs[2] + c * diru[2]);
                                        normalize(ref n);
                                        GL.Normal3(n[0], n[1], n[2]);
                                        GL.Vertex3(v.X + s * dirs[0] + c * diru[0], v.Y + s * dirs[1] + c * diru[1], v.Z - dh + s * dirs[2] + c * diru[2]);
                                        GL.Vertex3(last.X + s * dirs[0] + c * diru[0], last.Y + s * dirs[1] + c * diru[1], last.Z - dh + s * dirs[2] + c * diru[2]);
                                    }
                                    last = v;
                                }
                            }
                            GL.End();
                        }
                        else if (method == 0)
                        {
                            // Draw edges
                            if (path.pointsCount < 2) return;
                            GL.Material(MaterialFace.Front, MaterialParameter.Emission, defaultColor);
                            GL.Begin(BeginMode.Lines);
                            bool first = true;
                            foreach (LinkedList<GCodePoint> points in path.pointsLists)
                            {
                                first = true;
                                foreach (GCodePoint pt in points)
                                {
                                    Vector3 v = pt.p;
                                    if (liveView && pt.dist >= minHotDist)
                                    {
                                        float fak = (totalDist - pt.dist) / hotFilamentLength; // 1 = default 0 = hot
                                        float fak2 = 1 - fak;
                                        curColor[0] = defaultColor[0] * fak + hotColor[0] * fak2;
                                        curColor[1] = defaultColor[1] * fak + hotColor[1] * fak2;
                                        curColor[2] = defaultColor[2] * fak + hotColor[2] * fak2;
                                        GL.Material(MaterialFace.FrontAndBack, MaterialParameter.Emission, curColor);
                                    }

                                    GL.Vertex3(v);
                                    if (!first && pt != points.Last.Value)
                                        GL.Vertex3(v);
                                    first = false;
                                }
                            }
                            GL.End();
                        }
                    }
                }
            }
        }
Exemple #4
0
        /// <summary>
        /// Used to mark a section of the path. Is called after drawSegment so VBOs are already
        /// computed. Not used inside live preview.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="mstart"></param>
        /// <param name="mend"></param>
        public void drawSegmentMarked(GCodePath path, int mstart, int mend)
        {
            // Check if inside mark area
            int estart = 0;
            int eend = path.elementsLength;
            GCodePoint lastP = null, startP = null, endP = null;
            foreach (LinkedList<GCodePoint> plist in path.pointsLists)
            {
                if (plist.Count > 1)
                    foreach (GCodePoint point in plist)
                    {
                        if (startP == null)
                        {
                            if (point.fline >= mstart && point.fline <= mend)
                                startP = point;
                        }
                        else
                        {
                            if (point.fline > mend)
                            {
                                endP = point;
                                break;
                            }
                        }
                        lastP = point;
                    }
                if (endP != null) break;
            }
            if (startP == null) return;
            estart = startP.element;
            if (endP != null) eend = endP.element;
            if (estart == eend) return;
            if (Main.threeDSettings.drawMethod == 2)
            {
                GL.Material(MaterialFace.FrontAndBack, MaterialParameter.AmbientAndDiffuse, defaultColor);
                GL.EnableClientState(ArrayCap.VertexArray);
                if (path.elements == null) return;
                GL.BindBuffer(BufferTarget.ArrayBuffer, path.buf[0]);
                GL.VertexPointer(3, VertexPointerType.Float, 0, 0);
                if (method == 0)
                {
                    GL.BindBuffer(BufferTarget.ElementArrayBuffer, path.buf[2]);
                    GL.DrawElements(BeginMode.Lines, eend - estart, DrawElementsType.UnsignedInt, sizeof(int) * estart);
                }
                else
                {
                    GL.EnableClientState(ArrayCap.NormalArray);
                    GL.BindBuffer(BufferTarget.ArrayBuffer, path.buf[1]);
                    GL.NormalPointer(NormalPointerType.Float, 0, 0);
                    GL.BindBuffer(BufferTarget.ElementArrayBuffer, path.buf[2]);
                    //GL.DrawElements(BeginMode.Quads, path.elementsLength, DrawElementsType.UnsignedInt, 0);
                    //GL.DrawRangeElements(BeginMode.Quads, estart, eend, path.elementsLength, DrawElementsType.UnsignedInt, 0);
                    GL.DrawElements(BeginMode.Quads, eend - estart, DrawElementsType.UnsignedInt, sizeof(int) * estart);
                    GL.DisableClientState(ArrayCap.NormalArray);
                }

                GL.DisableClientState(ArrayCap.VertexArray);
                GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
            }
            else
            {
                if (path.drawMethod != method || recompute || path.hasBuf)
                    path.UpdateVBO(false);
                if (Main.threeDSettings.drawMethod > 0) // Is also fallback for vbos with dynamic colors
                {
                    GL.EnableClientState(ArrayCap.VertexArray);
                    if (path.elements == null) return;
                    GL.VertexPointer(3, VertexPointerType.Float, 0, path.positions);
                    GCHandle handle = GCHandle.Alloc(path.elements, GCHandleType.Pinned);
                    try
                    {
                        IntPtr pointer = new IntPtr(handle.AddrOfPinnedObject().ToInt32() + sizeof(int) * estart);
                        if (method == 0)

                            GL.DrawElements(BeginMode.Lines, eend - estart, DrawElementsType.UnsignedInt, pointer);
                        else
                        {
                            GL.EnableClientState(ArrayCap.NormalArray);
                            GL.NormalPointer(NormalPointerType.Float, 0, path.normals);
                            GL.DrawElements(BeginMode.Quads, eend - estart, DrawElementsType.UnsignedInt, pointer);
                            GL.DisableClientState(ArrayCap.NormalArray);
                        }
                    }
                    finally
                    {
                        if (handle.IsAllocated)
                        {
                            handle.Free();
                        }
                    }
                    GL.DisableClientState(ArrayCap.VertexArray);
                }
                else
                {
                    int i, l = path.elementsLength;
                    if (method == 0)
                    {
                        GL.Begin(BeginMode.Lines);
                        for (i = estart; i < eend; i++)
                        {
                            int p = path.elements[i] * 3;
                            GL.Vertex3(ref path.positions[p]);
                        }
                        GL.End();
                    }
                    else
                    {
                        GL.Begin(BeginMode.Quads);
                        for (i = estart; i < eend; i++)
                        {
                            int p = path.elements[i] * 3;
                            GL.Normal3(ref path.normals[p]);
                            GL.Vertex3(ref path.positions[p]);
                        }
                        GL.End();
                    }
                }
            }
        }