public Mesh(int vbo, int ibo, int count, PrimitiveType mode)
 {
     VboId = vbo;
     IboId = ibo;
     Count = count;
     Mode = mode;
 }

 /// <summary>
 /// Initializes a new <see cref="VertexBufferObject"/>
 /// </summary>
 /// <param name="vertexBufferLength">The lenght of the vertex buffer</param>
 /// <param name="elementBufferLength">The lenght of the element buffer</param>
 /// <param name="primitiveType">The <see cref="OpenTK.Graphics.OpenGL.PrimitiveType"/> used to render the <see cref="VertexBufferObject"/></param>
 public VertexBufferObject(int vertexBufferLength, int elementBufferLength, PrimitiveType primitiveType)
 {
     this.VertexBufferLength = vertexBufferLength;
     this.ElementBufferLength = elementBufferLength;
     this.PrimitiveType = primitiveType;
     this.Initialize();
 }

        public void AddVertex( Vector2 vertex, Color color, PrimitiveType primitiveType )
        {
            if ( !_hasBegun )
                throw new InvalidOperationException( "Begin must be called before AddVertex can be called." );

            if ( primitiveType == PrimitiveType.LineStrip || primitiveType == PrimitiveType.TriangleStrip )
                throw new NotSupportedException( "The specified primitiveType is not supported by PrimitiveBatch." );

            if ( primitiveType == PrimitiveType.TriangleList ) {
                if ( _triangleVertsCount >= _triangleVertices.Length )
                    FlushTriangles();

                _triangleVertices[ _triangleVertsCount ].Position = new Vector3( vertex, -0.1f );
                _triangleVertices[ _triangleVertsCount ].Color = color;
                _triangleVertsCount++;
            }

            if ( primitiveType == PrimitiveType.LineList ) {
                if ( _lineVertsCount >= _lineVertices.Length )
                    FlushLines();

                _lineVertices[ _lineVertsCount ].Position = new Vector3( vertex, 0f );
                _lineVertices[ _lineVertsCount ].Color = color;
                _lineVertsCount++;
            }
        }

        public void Draw(IndexBuffer ibo, PrimitiveType primitiveType)
        {
            ibo.Draw();

            bool bWireframe = (SceneManager.Current.RenderMode == SceneManager.RenderMeshMode.Wireframe);

            GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);

            GL.EnableClientState(ArrayCap.VertexArray);
            GL.EnableClientState(ArrayCap.NormalArray);
            GL.EnableClientState(ArrayCap.TextureCoordArray);
            if (!bWireframe) { GL.EnableClientState(ArrayCap.ColorArray); }

            GL.VertexPointer(3, VertexPointerType.Float, Vertex.Stride, new IntPtr(0));
            GL.NormalPointer(NormalPointerType.Float, Vertex.Stride, new IntPtr(Vector3.SizeInBytes));
            GL.TexCoordPointer(2, TexCoordPointerType.Float, Vertex.Stride, new IntPtr(2 * Vector3.SizeInBytes));
            if (!bWireframe) { GL.ColorPointer(4, ColorPointerType.Float, Vertex.Stride, new IntPtr((2 * Vector3.SizeInBytes) + Vector4.SizeInBytes)); }

            GL.DrawElements(primitiveType, ibo.Length, DrawElementsType.UnsignedInt, IntPtr.Zero);

            GL.DisableClientState(ArrayCap.VertexArray);
            GL.DisableClientState(ArrayCap.NormalArray);
            GL.DisableClientState(ArrayCap.TextureCoordArray);
            if (!bWireframe) { GL.DisableClientState(ArrayCap.ColorArray);}

            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
        }

 public Constant CreateConstant(ImmediateOperand imm, PrimitiveType dataWidth)
 {
     if (dataWidth.BitSize > imm.Width.BitSize)
         return Constant.Create(dataWidth, imm.Value.ToInt64());
     else
         return Constant.Create(imm.Width, imm.Value.ToUInt32());
 }

        private static void InsertBinaryOperationMethod(Core core, CodeBlockNode root, Operator op, PrimitiveType r, PrimitiveType op1, PrimitiveType op2, int retRank = 0, int op1rank = 0, int op2rank = 0)
        {
            FunctionDefinitionNode funcDefNode = new FunctionDefinitionNode();
            funcDefNode.access = CompilerDefinitions.AccessModifier.kPublic;
            funcDefNode.IsAssocOperator = true;
            funcDefNode.IsBuiltIn = true;
            funcDefNode.Name = Op.GetOpFunction(op);
            funcDefNode.ReturnType = new Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r, rank = retRank };
            ArgumentSignatureNode args = new ArgumentSignatureNode();
            args.AddArgument(new VarDeclNode()
            {
                Access = CompilerDefinitions.AccessModifier.kPublic,
                NameNode = AstFactory.BuildIdentifier(DSASM.Constants.kLHS),
                ArgumentType = new Type { Name = core.TypeSystem.GetType((int)op1), UID = (int)op1, rank = op1rank }
            });
            args.AddArgument(new VarDeclNode()
            {
                Access = CompilerDefinitions.AccessModifier.kPublic,
                NameNode = AstFactory.BuildIdentifier(DSASM.Constants.kRHS),
                ArgumentType = new Type { Name = core.TypeSystem.GetType((int)op2), UID = (int)op2, rank = op2rank }
            });
            funcDefNode.Signature = args;

            CodeBlockNode body = new CodeBlockNode();

            var lhs = AstFactory.BuildIdentifier(DSASM.Constants.kLHS);
            var rhs = AstFactory.BuildIdentifier(DSASM.Constants.kRHS);
            var binaryExpr = AstFactory.BuildBinaryExpression(lhs, rhs, op);
            body.Body.Add(AstFactory.BuildReturnStatement(binaryExpr));

            funcDefNode.FunctionBody = body;
            root.Body.Add(funcDefNode);
        }

 public static PrimitiveTopology ConvertPrimitiveType(PrimitiveType primitiveType)
 {
     switch (primitiveType)
     {
         case PrimitiveType.PointList:
             return PrimitiveTopology.PointList;
         case PrimitiveType.LineList:
             return PrimitiveTopology.LineList;
         case PrimitiveType.LineStrip:
             return PrimitiveTopology.LineStrip;
         case PrimitiveType.TriangleList:
             return PrimitiveTopology.TriangleList;
         case PrimitiveType.TriangleStrip:
             return PrimitiveTopology.TriangleStrip;
         case PrimitiveType.LineListWithAdjacency:
             return PrimitiveTopology.LineListWithAdjacency;
         case PrimitiveType.LineStripWithAdjacency:
             return PrimitiveTopology.LineStripWithAdjacency;
         case PrimitiveType.TriangleListWithAdjacency:
             return PrimitiveTopology.TriangleListWithAdjacency;
         case PrimitiveType.TriangleStripWithAdjacency:
             return PrimitiveTopology.TriangleStripWithAdjacency;
         default:
             throw new ArgumentOutOfRangeException(nameof(primitiveType));
     }
 }

        private void RewriteAcbi(PrimitiveType width)
        {
            var limit = RewriteSrcOp(0, width);
            var add = RewriteSrcOp(1, width);
            var index = RewriteDstOp(2, width, e => emitter.IAdd(e, add));
            NZV(index);
            var cAdd = add as Constant;
            if (cAdd == null)
                throw new AddressCorrelatedException(
                    dasm.Current.Address,
                    "Instruction {0] too complex to rewrite.",
                    dasm.Current);
            if (cAdd.ToInt32() >= 0)
            {
                emitter.Branch(
                          emitter.Le(index, limit),
                          ((AddressOperand)dasm.Current.Operands[3]).Address,
                          RtlClass.ConditionalTransfer);
            }
            else
            {
                emitter.Branch(
                    emitter.Ge(index, limit),
                    ((AddressOperand)dasm.Current.Operands[3]).Address,
                    RtlClass.ConditionalTransfer);
            }
            rtlc.Class = RtlClass.ConditionalTransfer;

        }

		public static void DrawMeshArraysSUN(PrimitiveType mode, Int32 first, Int32 count, Int32 width)
		{
			Debug.Assert(Delegates.pglDrawMeshArraysSUN != null, "pglDrawMeshArraysSUN not implemented");
			Delegates.pglDrawMeshArraysSUN((Int32)mode, first, count, width);
			LogFunction("glDrawMeshArraysSUN({0}, {1}, {2}, {3})", mode, first, count, width);
			DebugCheckErrors(null);
		}

 public void Draw(PrimitiveType mode, IElementArray elements)
 {
     using (elements.Bind())
     {
         _gl.DrawElements(mode, (int)elements.Elements, (uint)elements.Type, IntPtr.Zero);
     }
 }

 public OperandRewriter(M68kArchitecture arch, RtlEmitter emitter, Frame frame, PrimitiveType dataWidth)
 {
     this.arch = arch;
     this.m = emitter;
     this.frame = frame;
     this.DataWidth = dataWidth;
 }

 private void RewriteFpu3(PrimitiveType width, Func<Expression, Expression, Expression> fn, Action<Expression> genFlags)
 {
     var op1 = RewriteSrcOp(0, width);
     var op2 = RewriteSrcOp(1, width);
     var dst = RewriteDstOp(2, width, e => fn(op2, op1));
     genFlags(dst);
 }

 public IRenderRequest CreateInstancedRequest(IRenderContext renderContext, RasterizerState rasterizerState,
     BlendState blendState, DepthStencilState depthStencilState, IEffect effect, IEffectParameterSet effectParameterSet,
     VertexBuffer meshVertexBuffer, IndexBuffer meshIndexBuffer, PrimitiveType primitiveType,
     Matrix[] instanceWorldTransforms, Action<List<Matrix>, VertexBuffer, IndexBuffer> computeCombinedBuffers)
 {
     throw new NotImplementedException();
 }

    public RrdPrimitive(RrdUpdater updater, PrimitiveType type, int count, bool isConstant)
   {
		backend = updater.getRrdBackend();
		byteCount = RRD_PRIM_SIZES[(int)type] * count;
		pointer = updater.getRrdAllocator().allocate(byteCount);
		cachingAllowed = isConstant || backend.isCachingAllowed();
	}

			/// <summary>
			/// Specify which elements shall be drawn by indexing them, specifying an offset and the number of elements.
			/// </summary>
			/// <param name="vao">
			/// The <see cref="VertexArrayObject"/> to which this element belongs to.
			/// </param>
			/// <param name="mode">
			/// A <see cref="PrimitiveType"/> that indicates how elements are interpreted.
			/// </param>
			protected Element(VertexArrayObject vao, PrimitiveType mode)
			{
				if (vao == null)
					throw new ArgumentNullException("vao");
				_VertexArrayObject = vao;
				ElementsMode = mode;
			}

        /// <summary>
        /// Read the message header structure and cache the meta data for finding the key fields for decoding messages.
        /// </summary>
        /// <param name="headerStructure"> for the meta data describing the message header. </param>
        public OtfHeaderDecoder(HeaderStructure headerStructure)
        {
            _size = headerStructure.Tokens[0].Size;

            foreach (Token token in headerStructure.Tokens)
            {
                switch (token.Name)
                {
                    case HeaderStructure.BlockLength:
                        _blockLengthOffset = token.Offset;
                        _blockLengthType = token.Encoding.PrimitiveType;
                        _blockLengthByteOrder = token.Encoding.ByteOrder;
                        break;

                    case HeaderStructure.TemplateId:
                        _templateIdOffset = token.Offset;
                        _templateIdType = token.Encoding.PrimitiveType;
                        _templateIdByteOrder = token.Encoding.ByteOrder;
                        break;

                    case HeaderStructure.SchemaId:
                        _schemaIdOffset = token.Offset;
                        _schemaIdType = token.Encoding.PrimitiveType;
                        _schemaIdByteOrder = token.Encoding.ByteOrder;
                        break;

                    case HeaderStructure.SchemaVersion:
                        _schemaVersionOffset = token.Offset;
                        _schemaVersionType = token.Encoding.PrimitiveType;
                        _schemaVersionByteOrder = token.Encoding.ByteOrder;
                        break;
                }
            }
        }

    /// <summary>
    ///   Checks whether a vertex count is valid for the specified type of primitives
    /// </summary>
    /// <param name="verticesOrIndices">Number of vertices or indices</param>
    /// <param name="type">Type of primitives the vertices will be processed as</param>
    /// <returns>
    ///   True if the specified number is a valid vertex count for the specified
    ///   type of primitives
    /// </returns>
    /// <remarks>
    ///   A zero check is expected to be done in addition to this method. Negative
    ///   vertex or index counts will result in undefined behavior.
    /// </remarks>
    public static bool IsValidVertexCount(int verticesOrIndices, PrimitiveType type) {
      switch(type) {
#if !XNA_4
        case PrimitiveType.PointList: {
          return true;
        }
#endif
        case PrimitiveType.LineStrip: {
          return (verticesOrIndices >= 2);
        }
        case PrimitiveType.LineList: {
          return ((verticesOrIndices % 2) == 0);
        }
#if !XNA_4
        case PrimitiveType.TriangleFan:
#endif
        case PrimitiveType.TriangleStrip: {
          return (verticesOrIndices >= 3);
        }
        case PrimitiveType.TriangleList: {
          return (verticesOrIndices % 3) == 0;
        }
        default: { throw new ArgumentException("Invalid primitive type"); }
      }
    }

 public Primitive()
 {
     id = Guid.NewGuid().ToString();
     type = PrimitiveType.None;
     edges = new List<Edge>();
     nodes = new List<Node>();
 }

 public VertexArray(PrimitiveType primitive)
 {
     this.id = GL.GenVertexArray();
     this.primitive = primitive;
     this.arrays = new Dictionary<string, GLBuffer>();
     this.attributes = new Dictionary<int, VertexAttribute>();
 }

 /// <summary>
 /// Converts a javascript primitive type to a .NET type.
 /// </summary>
 /// <param name="type"> The type to convert. </param>
 /// <returns> A .NET type. </returns>
 public static Type ToType(PrimitiveType type)
 {
     switch (type)
     {
         case PrimitiveType.Any:
             return typeof(object);
         case PrimitiveType.Undefined:
             return typeof(Undefined);
         case PrimitiveType.Null:
             return typeof(Null);
         case PrimitiveType.Bool:
             return typeof(bool);
         case PrimitiveType.Int32:
             return typeof(int);
         case PrimitiveType.UInt32:
             return typeof(uint);
         case PrimitiveType.Number:
             return typeof(double);
         case PrimitiveType.String:
             return typeof(string);
         case PrimitiveType.ConcatenatedString:
             return typeof(ConcatenatedString);
         case PrimitiveType.Object:
             return typeof(Library.ObjectInstance);
         default:
             throw new NotImplementedException(string.Format("Unsupported primitive type: {0}", type));
     }
 }