private int CompileShader(string shaderName, All shaderType)
        {
            string shaderPath = NSBundle.PathForResourceAbsolute(shaderName, ".glsl", "Content");
            string shaderProgram = File.ReadAllText(shaderPath);

            int shader = GL.CreateShader(shaderType);
            int length = shaderProgram.Length;

            GL.ShaderSource(shader, 1, new string[] { shaderProgram }, ref length);
            GL.CompileShader(shader);

            int compileStatus = 0;

            GL.GetShader(shader, All.CompileStatus, ref compileStatus);

            if (compileStatus == (int)All.False)
            {
                StringBuilder sb = new StringBuilder(256);
                length = 0;
                GL.GetShaderInfoLog(shader, sb.Capacity, ref length, sb);
                Console.WriteLine(sb.ToString());
                throw new InvalidOperationException();
            }

            return shader;
        }

 public static void Cull(All cullMode)
 {
     if (_cull != cullMode)
     {
         _cull = cullMode;
        // TODO  GL.Enable(_cull);
     }
 }

        // throws jjtraveler.VisitFailure
        public virtual void testAll()
        {
            Identity id = new Identity();
            Logger expected = new Logger(id, new IVisitable[]{n3, n2} );

            All  all = new All( logVisitor(id) );

            IVisitable nodeReturned = all.visit(n4);
            Assertion.AssertEquals(expected, logger);
            Assertion.AssertEquals(n4, nodeReturned);
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="name"></param>
		/// <param name="target"></param>
		/// <param name="id"></param>
		/// <param name="width"></param>
		/// <param name="height"></param>
		/// <param name="format"></param>
		/// <param name="face"></param>
		/// <param name="level"></param>
		/// <param name="usage"></param>
		/// <param name="crappyCard"></param>
		/// <param name="writeGamma"></param>
		/// <param name="fsaa"></param>
		public GLESTextureBuffer( string basename, All targetfmt, int id, int width, int height, int format, int face, int level, BufferUsage usage, bool crappyCard, bool writeGamma, int fsaa )
			: base( 0, 0, 0, Media.PixelFormat.Unknown, usage )
		{
			_target = targetfmt;
			_textureId = id;
			_face = face;
			_level = level;
			_softwareMipmap = crappyCard;

			GLESConfig.GlCheckError( this );
			OpenGL.BindTexture( All.Texture2D, _textureId );
			GLESConfig.GlCheckError( this );

			// Get face identifier
			_faceTarget = _target;

			// TODO verify who get this
			Width = width;
			Height = height;
			Depth = 1;

			_glInternalFormat = (All)format;
			Format = GLESPixelUtil.GetClosestAxiomFormat( _glInternalFormat );

			RowPitch = Width;
			SlicePitch = Height * Width;
			sizeInBytes = PixelUtil.GetMemorySize( Width, Height, Depth, Format );

			// Set up a pixel box
			_buffer = new PixelBox( Width, Height, Depth, Format );
			if ( Width == 0 || Height == 0 || Depth == 0 )
			{
				/// We are invalid, do not allocate a buffer
				return;
			}

			// Is this a render target?
			if ( ( (int)Usage & (int)TextureUsage.RenderTarget ) != 0 )
			{
				// Create render target for each slice
				for ( int zoffset = 0; zoffset < Depth; zoffset++ )
				{
					string name = string.Empty;
					name = "rtt/" + this.GetHashCode() + "/" + basename;
					GLESSurfaceDescription target = new GLESSurfaceDescription();
					target.Buffer = this;
					target.ZOffset = zoffset;
					RenderTexture trt = GLESRTTManager.Instance.CreateRenderTexture( name, target, writeGamma, fsaa );
					_sliceTRT.Add( trt );
					Root.Instance.RenderSystem.AttachRenderTarget( _sliceTRT[ zoffset ] );
				}
			}

		}

		public EAGLView (RectangleF frame, All format, All depth, bool retained) : base (frame)
		{
			CAEAGLLayer eaglLayer = (CAEAGLLayer) Layer;
			eaglLayer.DrawableProperties = NSDictionary.FromObjectsAndKeys (
				new NSObject [] {NSNumber.FromBoolean (true),           EAGLColorFormat.RGBA8},
				new NSObject [] {EAGLDrawableProperty.RetainedBacking,  EAGLDrawableProperty.ColorFormat}
			);
			_format = format;
			_depthFormat = depth;

			_context = (iPhoneOSGraphicsContext) ((IGraphicsContextInternal) GraphicsContext.CurrentContext).Implementation;
			CreateSurface ();
		}

		public EAGLView (CGRect frame, All format, All depth, bool retained) : base (frame)
		{
			CAEAGLLayer eaglLayer = (CAEAGLLayer) Layer;
			eaglLayer.DrawableProperties = new NSDictionary (
				EAGLDrawableProperty.RetainedBacking, true,
				EAGLDrawableProperty.ColorFormat, EAGLColorFormat.RGBA8
			);

			_depthFormat = depth;

			_context = (iPhoneOSGraphicsContext) ((IGraphicsContextInternal) GraphicsContext.CurrentContext).Implementation;
			CreateSurface ();
		}

 public virtual void testOnceTopDownIsLeaf()
 {
     IVisitor isLeaf = new All(new Fail());
     OnceTopDown onceTopDown = new OnceTopDown(logVisitor(isLeaf));
     Logger expected = new Logger(isLeaf, new IVisitable[]{n0,n1,n11});
     try
     {
         IVisitable nodeReturned = onceTopDown.visit(n0);
         Assertion.AssertEquals("visit trace",expected, logger);
         Assertion.AssertEquals("return value",n0, nodeReturned);
     }
     catch (VisitFailure)
     {
         Assertion.Fail("VisitFailure should not occur!");
     }
 }

 public virtual void testAll()
 {
     Identity id = new Identity();
     All all = new All(logVisitor(id));
     Logger expected = new Logger(id, new IVisitable[] { n1, n2 });
     try
     {
         IVisitable nodeReturned = all.visit(n0);
         Assertion.AssertEquals(expected, logger);
         Assertion.AssertEquals(n0, nodeReturned);
     }
     catch (VisitFailure)
     {
         Assertion.Fail("VisitFailure should not occur!");
     }
 }

		/// <summary>
		/// </summary>
		/// <param name="format"> </param>
		/// <param name="width"> </param>
		/// <param name="height"> </param>
		/// <param name="numSamples"> </param>
		public GLESRenderBuffer( All format, int width, int height, int numSamples )
			: base( width, height, 1, GLESPixelUtil.GetClosestAxiomFormat( format ), BufferUsage.WriteOnly )
		{
			_glInternalFormat = format;
			/// Generate renderbuffer
			OpenGLOES.GenRenderbuffers( 1, ref this._renderbufferID );
			GLESConfig.GlCheckError( this );
			/// Bind it to FBO
			OpenGLOES.BindRenderbuffer( All.RenderbufferOes, this._renderbufferID );
			GLESConfig.GlCheckError( this );

			/// Allocate storage for depth buffer
			if ( numSamples <= 0 )
			{
				OpenGLOES.RenderbufferStorage( All.RenderbufferOes, format, width, height );
				GLESConfig.GlCheckError( this );
			}
		}

        public void InitWithBitmap(Bitmap image, All filter)
        {
            //TODO:  Android.Opengl.GLUtils.GetInternalFormat()

            _format = SurfaceFormat.Color;
            if(image.HasAlpha)
                _format = SurfaceFormat.Color;

            GL.GenTextures(1, ref _name);
            GL.BindTexture(All.Texture2D, _name);
            GL.TexParameter(All.Texture2D, All.TextureMinFilter, (int)filter);
            GL.TexParameter(All.Texture2D, All.TextureMagFilter, (int)filter);

            Android.Opengl.GLUtils.TexImage2D((int)All.Texture2D, 0, image, 0);

            _size = new Size(image.Width, image.Height);
            _width = image.Width;
            _height = image.Height;
            
            _maxS = _size.Width / (float)_width;
            _maxT = _size.Height / (float)_height;
        }

 public ESTexture2D(UIImage uiImage, All filter)
 {
     InitWithCGImage(uiImage.CGImage,filter);
 }

        public void InitWithData(IntPtr data, SurfaceFormat pixelFormat, int width, int height, Size size, All filter)
        {
            GL.GenTextures(1,ref _name);
            GL.BindTexture(All.Texture2D, _name);
            GL.TexParameter(All.Texture2D, All.TextureMinFilter, (int) filter);
            GL.TexParameter(All.Texture2D, All.TextureMagFilter, (int) filter);

            int sz = 0;

            switch(pixelFormat) {
                case SurfaceFormat.Color /*kTexture2DPixelFormat_RGBA8888*/:
                case SurfaceFormat.Dxt1:
                case SurfaceFormat.Dxt3:
                    sz = 4;
                    GL.TexImage2D(All.Texture2D, 0, (int) All.Rgba, (int) width, (int) height, 0, All.Rgba, All.UnsignedByte, data);
                    break;
                case SurfaceFormat.Bgra4444 /*kTexture2DPixelFormat_RGBA4444*/:
                    sz = 2;
                    GL.TexImage2D(All.Texture2D, 0, (int) All.Rgba, (int) width, (int) height, 0, All.Rgba, All.UnsignedShort4444, data);
                    break;
                case SurfaceFormat.Bgra5551 /*kTexture2DPixelFormat_RGB5A1*/:
                    sz = 2;
                    GL.TexImage2D(All.Texture2D, 0, (int) All.Rgba, (int) width, (int) height, 0, All.Rgba, All.UnsignedShort5551, data);
                    break;
                case SurfaceFormat.Alpha8 /*kTexture2DPixelFormat_A8*/:
                    sz = 1;
                    GL.TexImage2D(All.Texture2D, 0, (int) All.Alpha, (int) width, (int) height, 0, All.Alpha, All.UnsignedByte, data);
                    break;
                default:
                    throw new NotSupportedException("Texture format");;
            }

            _size = size;
            _width = width;
            _height = height;
            _format = pixelFormat;
            _maxS = size.Width / (float)width;
            _maxT = size.Height / (float)height;
        }

        public ESTexture2D(UIImage uiImage, All filter)
        {
            CGImage image = uiImage.CGImage;
            if(uiImage == null)
                throw new ArgumentNullException("uiImage");

            // TODO: could use this to implement lower-bandwidth textures
            //bool hasAlpha = (image.AlphaInfo == CGImageAlphaInfo.First || image.AlphaInfo == CGImageAlphaInfo.Last
            //		|| image.AlphaInfo == CGImageAlphaInfo.PremultipliedFirst || image.AlphaInfo == CGImageAlphaInfo.PremultipliedLast);

            // Image dimentions:
            logicalSize = new Point((int)uiImage.Size.Width, (int)uiImage.Size.Height);

            pixelWidth = uiImage.CGImage.Width;
            pixelHeight = uiImage.CGImage.Height;

            // Round up the target texture width and height to powers of two:
            potWidth = pixelWidth;
            potHeight = pixelHeight;
            if(( potWidth & ( potWidth-1)) != 0) { int w = 1; while(w <  potWidth) { w *= 2; }  potWidth = w; }
            if((potHeight & (potHeight-1)) != 0) { int h = 1; while(h < potHeight) { h *= 2; } potHeight = h; }

            // Scale down textures that are too large...
            CGAffineTransform transform = CGAffineTransform.MakeIdentity();
            while((potWidth > 1024) || (potHeight > 1024))
            {
                potWidth /= 2;    // Note: no precision loss - it's a power of two
                potHeight /= 2;
                pixelWidth /= 2;  // Note: precision loss - assume possibility of dropping a pixel at each step is ok
                pixelHeight /= 2;
                transform.Multiply(CGAffineTransform.MakeScale(0.5f, 0.5f));
            }

            RecalculateRatio();

            lock(textureLoadBufferLockObject)
            {
                CreateTextureLoadBuffer();

                unsafe
                {
                    fixed(byte* data = textureLoadBuffer)
                    {
                        var colorSpace = CGColorSpace.CreateDeviceRGB();
                        var context = new CGBitmapContext(new IntPtr(data), potWidth, potHeight,
                                8, 4 * potWidth, colorSpace, CGImageAlphaInfo.PremultipliedLast);

                        context.ClearRect(new RectangleF(0, 0, potWidth, potHeight));
                        context.TranslateCTM(0, potHeight - pixelHeight); // TODO: this does not play nice with the precision-loss above (keeping half-pixel to the edge)

                        if(!transform.IsIdentity)
                            context.ConcatCTM(transform);

                        context.DrawImage(new RectangleF(0, 0, image.Width, image.Height), image);
                        SetupTexture(new IntPtr(data), filter);

                        context.Dispose();
                        colorSpace.Dispose();
                    }
                }
            }
        }

        private void SetupTexture(IntPtr data, All filter)
        {
            GL.GenTextures(1, ref name);
            GL.BindTexture(All.Texture2D, name);
            GL.TexParameter(All.Texture2D, All.TextureMinFilter, (int)filter);
            GL.TexParameter(All.Texture2D, All.TextureMagFilter, (int)filter);

            GL.TexImage2D(All.Texture2D, 0, (int)All.Rgba, (int)potWidth, (int)potHeight, 0, All.Rgba, All.UnsignedByte, data);
        }

        int LoadShader(All type, string source)
        {
            int shader = GL.CreateShader (type);
            if (shader == 0)
                throw new InvalidOperationException ("Unable to create shader");

            int length = 0;
            GL.ShaderSource (shader, 1, new string [] {source}, (int[])null);
            GL.CompileShader (shader);

            int compiled = 0;
            GL.GetShader (shader, All.CompileStatus, ref compiled);
            if (compiled == 0) {
                length = 0;
                GL.GetShader (shader, All.InfoLogLength, ref length);
                if (length > 0) {
                    var log = new StringBuilder (length);
                    GL.GetShaderInfoLog (shader, length, ref length, log);
                    Log.Debug ("GL2", "Couldn't compile shader: " + log.ToString ());
                }

                GL.DeleteShader (shader);
                throw new InvalidOperationException ("Unable to compile shader of type : " + type.ToString ());
            }

            return shader;
        }

 public ESTexture2D(CGImage cgImage, All filter)
 {
     InitWithCGImage (cgImage, filter);
 }

		public ESImage(NSImage image, All filter)
		{			
			// By default set the scale to 1.0f
			texture = new ESTexture2D(image,filter);
			Initialize(1.0f/*TODO image.CurrentScale*/);
		}

		/// <summary>
		/// </summary>
		/// <param name="attachment"> </param>
		/// <param name="zOffset"> </param>
		public override void BindToFramebuffer( All attachment, int zOffset )
		{
			Utilities.Contract.Requires( zOffset < Depth );
			OpenGLOES.FramebufferRenderbuffer( All.FramebufferOes, attachment, All.RenderbufferOes, this._renderbufferID );
			GLESConfig.GlCheckError( this );
		}

        public Analyze Analyze(string host, Publish publish, StartNew startNew, FromCache fromCache, int? maxHours, All all, IgnoreMismatch ignoreMismatch)
        {
            var analyzeModel = new Analyze();

            // Checking host is valid before continuing
            if (!_urlValidation.IsValid(host))
            {
                analyzeModel.HasErrorOccurred = true;
                analyzeModel.Errors.Add(new Error { message = "Host does not pass preflight validation. No Api call has been made." });
                return analyzeModel;
            }

            // Building request model
            var requestModel = _requestModelFactory.NewAnalyzeRequestModel(ApiUrl, "analyze", host, publish.ToString().ToLower(), startNew.ToString().ToLower(),
                fromCache.ToString().ToLower(), maxHours, all.ToString().ToLower(), ignoreMismatch.ToString().ToLower());

            try
            {
                var webResponse = _apiProvider.MakeGetRequest(requestModel);
                analyzeModel = _responsePopulation.AnalyzeModel(webResponse, analyzeModel);
            }
            catch (Exception ex)
            {
                analyzeModel.HasErrorOccurred = true;
                analyzeModel.Errors.Add(new Error { message = ex.ToString() });
            }

            // Checking if errors have occoured either from ethier api or wrapper
            if (analyzeModel.Errors.Count != 0 && !analyzeModel.HasErrorOccurred) { analyzeModel.HasErrorOccurred = true; }

            return analyzeModel;
        }

        public Analyze AutomaticAnalyze(string host, Publish publish, StartNew startNew, FromCache fromCache, int? maxHours, All all, IgnoreMismatch ignoreMismatch,
			int maxWaitInterval, int sleepInterval)
        {
            var startTime = DateTime.UtcNow;
            var sleepIntervalMilliseconds = sleepInterval * 1000;
            var apiPassCount = 1;
            var analyzeModel = Analyze(host, publish, startNew, fromCache, maxHours, all, ignoreMismatch);

            // Ignoring cache settings after first request to prevent loop
            startNew = StartNew.Ignore;

            // Shouldn't have to check status header as HasErrorOccurred should be enough
            while (analyzeModel.HasErrorOccurred == false && analyzeModel.status != "READY" && (DateTime.UtcNow - startTime).TotalSeconds < maxWaitInterval)
            {
                Thread.Sleep(sleepIntervalMilliseconds);
                apiPassCount++;
                analyzeModel = Analyze(host, publish, startNew, fromCache, null, all, ignoreMismatch);
            }

            analyzeModel.Wrapper.ApiPassCount = apiPassCount;

            return analyzeModel;
        }