public RenderableMinimap(TerrainModel parent, RenderableHeightMap renderableheightmap)  // note could upgrade this to use Isomething later, but Terrain works for now
        {
            this.parent = parent;
            this.renderableheightmap = renderableheightmap;

            Gl.glGenTextures(1, out minimaptexture);

            RendererSdl.GetInstance().WriteNextFrameEvent += new WriteNextFrameCallback(RenderableMinimap_WriteNextFrameEvent);
        }
        void RenderableMinimap_WriteNextFrameEvent(Vector3 camerapos)
        {
            //Console.WriteLine( "RenderableMinimap_WriteNextFrameEvent" );
            GetDimensions();

            GraphicsHelperGl g = new GraphicsHelperGl();

            g.CheckError();
            //LogFile.WriteLine( windowwidth + " " + windowheight + " " + RendererSdl.GetInstance().OuterWindowWidth + " " + RendererSdl.GetInstance().OuterWindowHeight );
            g.ApplyOrtho(windowwidth, windowheight, RendererSdl.GetInstance().OuterWindowWidth, RendererSdl.GetInstance().OuterWindowHeight);
            g.CheckError();
            DrawMinimap();
            g.CheckError();
            DrawFrustrum(camerapos);
            g.CheckError();
            if (Render != null)
            {
                Render(minimapx, minimapy, minimapwidth, minimapheight);
            }
            g.CheckError();
            g.RemoveOrtho();
            g.CheckError();
        }
        // determine which chunks are used by each texture stage
        // only affects blend really
        void CacheChunkTextureStageUsage()
        {
            LogFile.WriteLine("Cachchunktexturestageusage");

            int numxchunks = width / chunksize;
            int numychunks = height / chunksize;

            chunkusestexturestage = new Dictionary <MapTextureStageModel, bool[, ]>();
            foreach (MapTextureStageModel maptexturestage in maptexturestagemodels)
            {
                chunkusestexturestage.Add(maptexturestage, new bool[numxchunks, numychunks]);
            }
            for (int chunkx = 0; chunkx < numxchunks; chunkx++)
            {
                for (int chunky = 0; chunky < numychunks; chunky++)
                {
                    //    Console.WriteLine("chunk " + chunkx + " " + chunky);
                    for (int texturestageindex = 0; texturestageindex < maptexturestagemodels.Count; texturestageindex++)
                    {
                        MapTextureStageModel texturestagemodel = maptexturestagemodels[texturestageindex];
                        //MapTextureStageView texturestageview = terrainview.mapviewbymapmodel[texturestagemodel];
                        //Console.WriteLine("texturestage " + texturestageindex + " " + texturestage.Operation );
                        if (texturestagemodel.Operation == MapTextureStageModel.OperationType.Blend)
                        {
                            bool texturestageused = false;
                            // go through each point in chunk and check if texturestage is used
                            for (int mapx = chunkx * chunksize; mapx < (chunkx + 1) * chunksize && !texturestageused;
                                 mapx++)
                            {
                                for (int mapy = chunky * chunksize; mapy < (chunky + 1) * chunksize && !texturestageused;
                                     mapy++)
                                {
                                    if (texturestagemodel.Affects(mapx, mapy, width, height))
                                    {
                                        texturestageused = true;
                                    }
                                }
                            }
                            chunkusestexturestage[texturestagemodel][chunkx, chunky] = texturestageused;
                            //  if (chunkusestexturestage[texturestageindex][chunkx, chunky])
                            //{
                            //  Console.WriteLine("texturestage used: " + texturestageindex + " " + chunkx + " " + chunky);
                            //}
                        }
                        else if (texturestagemodel.Operation == MapTextureStageModel.OperationType.Nop)
                        {
                            chunkusestexturestage[texturestagemodel][chunkx, chunky] = false;
                        }
                        else
                        {
                            //Console.WriteLine("RenderableHeightMap,, cache chunk usage, true");
                            chunkusestexturestage[texturestagemodel][chunkx, chunky] = true;
                        }
                    }
                }
            }
            maxtexels = RendererSdl.GetInstance().MaxTexelUnits;

            int totaltexturestagesneeded = 0;

            foreach (MapTextureStageModel maptexturestagemodel in maptexturestagemodels)
            {
                totaltexturestagesneeded += terrainview.mapviewbymapmodel[maptexturestagemodel].NumTextureStagesRequired;
            }

            multipass = false;
            if (totaltexturestagesneeded > maxtexels)
            {
                multipass = true;
            }
            rendererpasses = new List <RendererPass>();
            //maxtexels = 2;
            //int currenttexel = 0;

            multipass = true; // force multipass for now for simplicity
            LogFile.WriteLine("Adding rendererpasses");
            if (multipass)
            {
                for (int i = 0; i < maptexturestagemodels.Count; i++)
                {
                    MapTextureStageModel maptexturestagemodel = maptexturestagemodels[i];
                    MapTextureStageView  maptexturestage      = terrainview.mapviewbymapmodel[maptexturestagemodel];
                    int numtexturestagesrequired = maptexturestage.NumTextureStagesRequired;
                    if (numtexturestagesrequired > 0) // exclude Nops
                    {
                        RendererPass rendererpass = new RendererPass(maxtexels);
                        for (int j = 0; j < maptexturestage.NumTextureStagesRequired; j++)
                        {
                            rendererpass.AddStage(new RendererTextureStage(maptexturestage, j, true, width, height));
                        }
                        rendererpasses.Add(rendererpass);
                        LogFile.WriteLine("Adding rendererpass: " + rendererpass);
                    }
                }
            }
        }
        // note to self: move this to subscriber?
        void DrawMinimap()
        {
            TerrainModel terrain = MetaverseClient.GetInstance().worldstorage.terrainmodel;

            if (DateTime.Now.Subtract(LastMinimapUpdate).TotalMilliseconds > 1000)
            //if( true )
            {
                List <RendererPass> rendererpasses = new List <RendererPass>();
                bool multipass = true; // force multipass for now for simplicity
                int  maxtexels = RendererSdl.GetInstance().MaxTexelUnits;
                if (multipass)
                {
                    for (int i = 0; i < terrain.texturestages.Count; i++)
                    {
                        MapTextureStageModel maptexturestage = terrain.texturestages[i];
                        int numtexturestagesrequired         = maptexturestage.NumTextureStagesRequired;
                        if (numtexturestagesrequired > 0) // exclude Nops
                        {
                            RendererPass rendererpass = new RendererPass(maxtexels);
                            for (int j = 0; j < maptexturestage.NumTextureStagesRequired; j++)
                            {
                                rendererpass.AddStage(new RendererTextureStage(maptexturestage, j, true, mapwidth, mapheight));
                            }
                            rendererpasses.Add(rendererpass);
                        }
                    }
                }

                GraphicsHelperGl g = new GraphicsHelperGl();

                //g.ApplyOrtho(windowwidth, windowheight, RendererSdl.GetInstance().OuterWindowWidth, RendererSdl.GetInstance().OuterWindowHeight);

                g.EnableBlendSrcAlpha();
                Gl.glDepthFunc(Gl.GL_LEQUAL);

                int chunkwidth  = minimapwidth / numchunks;
                int chunkheight = minimapheight / numchunks;

                float[] ambientLight  = new float[] { 0.4f, 0.4f, 0.4f, 1.0f };
                float[] diffuseLight  = new float[] { 0.6f, 0.6f, 0.6f, 1.0f };
                float[] specularLight = new float[] { 0.2f, 0.2f, 0.2f, 1.0f };
                float[] position      = new float[] { -1.0f, 0.2f, -0.4f, 1.0f };

                Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, ambientLight);
                Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, diffuseLight);
                Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_SPECULAR, specularLight);
                Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, position);

                foreach (RendererPass rendererpass in rendererpasses)
                {
                    rendererpass.Apply();

                    for (int x = 0; x + chunkwidth < minimapwidth; x += chunkwidth)
                    {
                        for (int y = 0; y + chunkheight < minimapheight; y += chunkheight)
                        {
                            Gl.glBegin(Gl.GL_QUADS);

                            //double ul = 0;
                            //double ur = mapwidth * Terrain.SquareSize;
                            //double vt = 0;
                            //double vb = mapheight * Terrain.SquareSize;
                            double ul = (double)x / minimapwidth * mapwidth;
                            double ur = (double)(x + chunkwidth) / minimapwidth * mapwidth;
                            double vt = (double)y / minimapheight * mapheight;
                            double vb = (double)(y + chunkheight) / minimapheight * mapheight;

                            double xl = minimapx + x;
                            double xr = minimapx + x + minimapwidth / (double)numchunks;
                            double yt = minimapy + y;
                            double yb = minimapy + y + minimapheight / (double)numchunks;

                            Gl.glTexCoord2d(ul, vt);
                            Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ul, vt);
                            g.Normal(renderableheightmap.GetNormal(x * mapwidth / minimapwidth, y * mapheight / minimapheight));
                            //g.Normal(renderableheightmap.normalsperquad[, ]);
                            Gl.glVertex2d(xl, yt);

                            Gl.glTexCoord2d(ul, vb);
                            Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ul, vb);
                            g.Normal(renderableheightmap.GetNormal(x * mapwidth / minimapwidth, (y + chunkheight) * mapheight / minimapheight));
                            //g.Normal( renderableheightmap.normalsperquad[x * mapwidth / minimapwidth, (y + 1) * mapheight / minimapheight ] );
                            Gl.glVertex2d(xl, yb);

                            Gl.glTexCoord2d(ur, vb);
                            Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ur, vb);
                            g.Normal(renderableheightmap.GetNormal((x + chunkwidth) * mapwidth / minimapwidth, (y + chunkheight) * mapheight / minimapheight));
                            //g.Normal(renderableheightmap.normalsperquad[(x + 1) * mapwidth / minimapwidth, (y + 1) * mapheight / minimapheight]);
                            Gl.glVertex2d(xr, yb);

                            Gl.glTexCoord2d(ur, vt);
                            Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ur, vt);
                            g.Normal(renderableheightmap.GetNormal((x + chunkwidth) * mapwidth / minimapwidth, y * mapheight / minimapheight));
                            //g.Normal(renderableheightmap.normalsperquad[(x + 1) * mapwidth / minimapwidth, y * mapheight / minimapheight]);
                            Gl.glVertex2d(xr, yt);

                            Gl.glEnd();
                        }
                    }
                }

                g.ActiveTexture(0);
                Gl.glBindTexture(Gl.GL_TEXTURE_2D, minimaptexture);
                Gl.glCopyTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA8, minimapx,
                                    RendererSdl.GetInstance().WindowHeight - minimapy - minimapsize,
                                    minimapsize, minimapsize, 0);
                Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST);
                LastMinimapUpdate = DateTime.Now;

//                g.RemoveOrtho();

                g.ActiveTexture(1);
                g.DisableTexture2d();
                g.SetTextureScale(1);
                g.ActiveTexture(0);
                g.SetTextureScale(1);

                g.EnableModulate();

                Gl.glDisable(Gl.GL_BLEND);
            }
            else
            {
                GraphicsHelperGl g = new GraphicsHelperGl();

                //Gl.glMatrixMode(Gl.GL_PROJECTION);
                //Gl.glPushMatrix();
                //Gl.glLoadIdentity();
                //Gl.glOrtho(0, windowwidth, windowheight - RendererSdl.GetInstance().OuterWindowHeight, 0, -1, 1); // we'll just draw the minimap directly onto our display
                //Gl.glOrtho(0, windowwidth, windowheight, windowheight - RendererSdl.GetInstance().OuterWindowHeight, -1, 1); // we'll just draw the minimap directly onto our display

                //Gl.glMatrixMode(Gl.GL_MODELVIEW);
                //Gl.glPushMatrix();
                //Gl.glLoadIdentity();

                g.ActiveTexture(0);
                g.EnableTexture2d();
                Gl.glBindTexture(Gl.GL_TEXTURE_2D, minimaptexture);
                //Gl.glBindTexture(Gl.GL_TEXTURE_2D, (terrain.texturestages[0].texture as GlTexture).GlReference);
                Gl.glDisable(Gl.GL_LIGHTING);
                Gl.glBegin(Gl.GL_QUADS);

                Gl.glTexCoord2d(0, 1);
                Gl.glVertex2i(minimapx, minimapy);

                Gl.glTexCoord2d(0, 1 - minimapwidth / (double)minimapsize);
                Gl.glVertex2i(minimapx, minimapy + minimapheight);

                Gl.glTexCoord2d(minimapwidth / (double)minimapsize, 1 - minimapheight / (double)minimapsize);
                Gl.glVertex2i(minimapx + minimapwidth, minimapy + minimapheight);

                Gl.glTexCoord2d(minimapwidth / (double)minimapsize, 1);
                Gl.glVertex2i(minimapx + minimapwidth, minimapy);

                Gl.glEnd();

                Gl.glEnable(Gl.GL_LIGHTING);

                //Gl.glMatrixMode(Gl.GL_PROJECTION);
                //Gl.glPopMatrix();
                //Gl.glMatrixMode(Gl.GL_MODELVIEW);
                //Gl.glPopMatrix();
            }
        }