[SL Multitexturing] - Only one texture with gluSphere

            /// <summary>
            /// Draws a VBO
            /// </summary>
            /// <param name="vboPtr">Vbo structure info</param>
            /// <param name="indices">array of INDICES</param>
            /// <param name="vertices">array of VERTICES</param>
            public static void DrawVbo(Vbo vboPtr, ushort[] indices, VertexP3N3T2[] vertices)
            {
 
                // bind VBOs for vertex array and index array
                GL.BindBuffer(BufferTarget.ArrayBuffer, vboPtr.VboId);           // for vertex coordinates
                GL.BindBuffer(BufferTarget.ElementArrayBuffer, vboPtr.Eboid);    // for indices
 
                GL.EnableClientState(EnableCap.VertexArray);            // activate vertex, normal and texture coords array
                GL.EnableClientState(EnableCap.NormalArray);
                GL.EnableClientState(EnableCap.TextureCoordArray);
 
                // tells OpenGL how the data are passed
                GL.InterleavedArrays(InterleavedArrayFormat.T2fN3fV3f, 0, (IntPtr) null);
 
                // obtains the safe pointer to the indices array
                GCHandle pinnedArray = GCHandle.Alloc(indices, GCHandleType.Pinned);
                IntPtr ptrIndices = pinnedArray.AddrOfPinnedObject();
 
                // draws the elements
                GL.DrawElements(BeginMode.Triangles, vboPtr.Numelements, DrawElementsType.UnsignedShort, ptrIndices);
 
                // frees resources
                pinnedArray.Free();
 
                GL.DisableClientState(EnableCap.VertexArray);                // deactivates used Client States
                GL.DisableClientState(EnableCap.NormalArray);
                GL.DisableClientState(EnableCap.TextureCoordArray);
 
                // bind with 0, so, switch back to normal pointer operation
                GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
                GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
 
            }
        }

            /// <summary>
            /// Load into a Vertex Buffer Object both VERTICES and INDICES and returns a vbo structure info
            /// </summary>
            /// <param name="vertices">vertex array</param>
            /// <param name="indices">elements array</param>
            /// <returns></returns>
            public static Vbo LoadVbo(VertexP3N3T2[] vertices, ushort[] indices)
            {
                Vbo handle=new Vbo();
                int size;
 
                //vertices
                GL.GenBuffers(1, out handle.VboId);
                if (GL.GetError() != ErrorCode.NoError)
                {
                    throw new ApplicationException("Error while creating VERTICES Buffer Object.\n\nERROR: " + Enum.GetName(typeof(ErrorCode), GL.GetError()));
                }
                GL.BindBuffer(BufferTarget.ArrayBuffer, handle.VboId);
                GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * Vector3.SizeInBytes),vertices, BufferUsageHint.StaticDraw);
                GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
 
                if (GL.GetError() != ErrorCode.NoError)
                {
                    throw new ApplicationException("Error while creating VERTICES Buffer Object.\n\nERROR: " + Enum.GetName(typeof(ErrorCode), GL.GetError()));
                }
 
                if (vertices.Length*Vector3.SizeInBytes!=size)
                {
                    throw new ApplicationException("Error while uploading VERTICES data.");
                }
 
                //indices
                GL.GenBuffers(1, out handle.Eboid);
                if (GL.GetError() != ErrorCode.NoError)
                {
                    throw new ApplicationException("Error while creating INDICES Buffer Object.\n\nERROR: " + Enum.GetName(typeof(ErrorCode), GL.GetError()));
                }
                GL.BindBuffer(BufferTarget.ElementArrayBuffer, handle.Eboid);
                GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(ushort)), indices, BufferUsageHint.StaticDraw);
                GL.GetBufferParameter(BufferTarget.ElementArrayBuffer,BufferParameterName.BufferSize, out size);
                if (indices.Length * sizeof(ushort) != size)
                {
                    throw new ApplicationException("Error while uploading INDICES data.");
                }
 
                if (GL.GetError() != ErrorCode.NoError)
                {
                    throw new ApplicationException("Error while creating INDICES Buffer Object.\n\nERROR: " + Enum.GetName(typeof(ErrorCode), GL.GetError()));
                }
 
                handle.Numelements = indices.Length;
                return handle;
            }

            /// <summary>
            /// Vertex Structure for vec3 position, vec3 normals, vec2 textcoord
            /// </summary>
            [StructLayout(LayoutKind.Sequential, Pack = 1)]
            public struct VertexP3N3T2
            {
                public Vector2 TexCoord;
                public Vector3 Normal;
                public Vector3 Position;                
            }

        /// <summary>
        /// Set-up the viewport; always called when the glControl is resized
        /// </summary>
        /// <param name="w">width</param>
        /// <param name="h">height</param>
        private void OnReshape(int w, int h)
        {
            if (w == 0 | h == 0)
            {
                w = 1;
                h = 1;
            }
            GL.Viewport(0, 0, w, h);
            Double aspect = w / h;
 
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadIdentity();
            Glu.Perspective(45.0, aspect, 1.0, 90.0); 
        }

        ''' <summary>
        ''' Sets up the the viewport
        ''' </summary>
        ''' <remarks></remarks>
        Private Sub SetupViewport()
 
            Dim cx As Single = 0.0, halfWidth As Single = _viewportW * 0.5F, halfHeight = _viewportH * 0.5F
            Dim aspect As Single = 4.0F / 3.0F '_viewportW / _viewportH
 
            GL.Viewport(0, 0, _viewportW, _viewportW)
            GL.MatrixMode(MatrixMode.Modelview)
            GL.LoadIdentity()
            'cx is the eye space center of the zNear plane in X */
            GL.Ortho(cx - halfWidth * aspect, cx + halfWidth * aspect, _viewportH * -1, _viewportH, 0.0F, _viewportW * 4)
            Glu.LookAt( _
                0.0F, 300.0F, 0.0F, _
                0.0F, 0.0F, -200.0F, _
                0.0F, 1.0F, 0.0F)
 
        End Sub