Ejemplo n.º 1
0
 public bool ReadData(int offset, int length, Vertex[] data)
 {
     if (_useVbo == VBOType.Core) {
         GL.BindBuffer (BufferTarget.ArrayBuffer, _vbo);
         GL.GetBufferSubData<Vertex> (BufferTarget.ArrayBuffer, new IntPtr (offset), new IntPtr (length), data);
     } else if (_useVbo == VBOType.ARB) {
         GL.Arb.BindBuffer (BufferTargetArb.ArrayBuffer, _vbo);
         GL.Arb.GetBufferSubData<Vertex> (BufferTargetArb.ArrayBuffer, new IntPtr (offset), new IntPtr (length), data);
     } else {
         for (int i = 0; i < _vertices.Length; i++) {
             // slow
             data[i] = _vertices[i];
         }
     }
     return true;
 }
Ejemplo n.º 2
0
        public void WriteData(int offset, int length, Vertex[] data)
        {
            if (_useVbo == VBOType.Core) {
                GL.BindBuffer (BufferTarget.ArrayBuffer, _vbo);
                if (offset == 0 && length == data.Length)
                {
                    BufferUsageHint buh = BufferUsageHint.StaticDraw;
                    if (_usage == BufferUsage.DYNAMIC)
                        buh = BufferUsageHint.DynamicDraw;
                    GL.BufferData<Vertex> (BufferTarget.ArrayBuffer, new IntPtr (length), data, buh);
                } else {
                    GL.BufferSubData<Vertex> (BufferTarget.ArrayBuffer, new IntPtr (offset), new IntPtr (length), data);
                }
            } else if (_useVbo == VBOType.ARB) {
                GL.Arb.BindBuffer (BufferTargetArb.ArrayBuffer, _vbo);
                if (offset == 0 && length == data.Length)
                {
                    BufferUsageArb buh = BufferUsageArb.StaticDraw;
                    if (_usage == BufferUsage.DYNAMIC)
                        buh = BufferUsageArb.DynamicDraw;
                    GL.Arb.BufferData<Vertex> (BufferTargetArb.ArrayBuffer, new IntPtr (length), data, buh);
                } else {
                    GL.Arb.BufferSubData<Vertex> (BufferTargetArb.ArrayBuffer, new IntPtr (offset), new IntPtr (length), data);
                }

            } else {
                for (int i = 0; i < _vertices.Length; i++) {
                    // slow
                    _vertices[i] = data[i];
                }
            }
        }
Ejemplo n.º 3
0
        // readonly CSGL.VertexBuffer VB;
        public Primitive(primitive_element PElement)
        {
            switch(PElement.GetType().Name)
            {
                case "triangles":
                    DM	= DrawMode.Triangles;
                    break;

                case "trifans":
                    DM	= DrawMode.TriangleFan;
                    break;

                case "tristrips":
                    DM	= DrawMode.TriangleStrip;
                    break;

                case "lines":
                    DM	= DrawMode.Lines;
                    break;

                case "lineStrip":
                    DM	= DrawMode.LineStrip;
                    break;

                default:
                    throw new NotImplementedException();
            }

            ////////////////////////////////////////////////////////////////

            int Length	= PElement.P.GetLength(1);

            // float[][] Data	= new float[PElement.Inputs.Count][];
            Vertex[] Data = new Vertex[PElement.Inputs.Count];
            /*
            CSGL.VertexBuffer Vertex	= null;
            CSGL.NormalBuffer Normal	= null;
            CSGL.TexCoordBuffer TexCoord	= null;
             */
            int i	= 0;
            foreach(input S in PElement.Inputs)
            {
                uint Stride	= ((source)S).Accessor.Stride;
                Data[i]	= new float[Length * Stride];

                source Src	= ((source)S);
                float[] ArrayData	= Src.Array.Values as float[];

                int j	= 0;
                while(j < Length)
                {
                    uint DI	= PElement.P[i,j] * Stride;

                    int k	= 0;
                    while(k < Stride)
                    {
                        Data[i][(j * Stride) + k]	= ArrayData[DI + k];

                        k++;
                    }

                    j++;
                }

                switch(S.Semantic)
                {
                    case "VERTEX":
                        Vertex	= new CSGL.VertexBuffer(gl,Stride,Data[i],Usage.StaticDraw);
                        break;

                    case "NORMAL":
                        Normal	= new CSGL.NormalBuffer(gl,Data[i],Usage.StaticDraw);
                        break;

                    case "TEXCOORD":
                        TexCoord	= new CSGL.TexCoordBuffer(gl,Stride,Data[i],Usage.StaticDraw);
                        break;

                    default:
                        throw new NotImplementedException();
                }

                i++;
            }

            VB	= Vertex;
            VB.Normal	= Normal;
            VB.TexCoord	= TexCoord;
        }