Ejemplo n.º 1
0
        static bool arglPixelBufferDataUpload(ARGL_CONTEXT_SETTINGS contextSettings, byte[] bufDataPtr)
        {
            if (contextSettings == null)
            {
                return(false);
            }
            if (contextSettings.textureObjectsHaveBeenSetup || contextSettings.textureGeometryHasBeenSetup || contextSettings.pixSize == 0)
            {
                return(false);
            }

            GL1.ActiveTexture(All1.Texture0);
            GL1.BindTexture(All1.Texture2D, contextSettings.texture);

            GL1.PixelStore(All1.UnpackAlignment, (((contextSettings.bufSizeX * contextSettings.pixSize) & 0x3) == 0 ? 4 : 1));

            if (contextSettings.bufSizeIsTextureSize)
            {
                GL1.TexImage2D(All1.Texture2D, 0, (OpenTK.Graphics.ES11.All)contextSettings.pixIntFormat, contextSettings.textureSizeX, contextSettings.textureSizeY, 0, (All1)contextSettings.pixFormat, (All1)contextSettings.pixType, bufDataPtr);
            }
            else
            {
                // Request OpenGL allocate memory internally for a power-of-two texture of the appropriate size.
                // Then send the NPOT-data as a subimage.
                GL1.TexImage2D(All1.Texture2D, 0, (OpenTK.Graphics.ES11.All)contextSettings.pixIntFormat, contextSettings.textureSizeX, contextSettings.textureSizeY, 0, (All1)contextSettings.pixFormat, (All1)contextSettings.pixType, IntPtr.Zero);
                GL1.TexSubImage2D(All1.Texture2D, 0, 0, 0, contextSettings.bufSizeX, contextSettings.bufSizeY, (All1)contextSettings.pixFormat, (All1)contextSettings.pixType, bufDataPtr);
            }

            contextSettings.textureDataReady = true;

            return(true);
        }
Ejemplo n.º 2
0
        // Set up the texture objects.
        static bool arglSetupTextureObjects(ARGL_CONTEXT_SETTINGS contextSettings)
        {
            int textureWrapMode;

            // Delete previous textures, unless this is our first time here.
            if (contextSettings.textureObjectsHaveBeenSetup)
            {
                GL1.ActiveTexture(All1.Texture0);
                GL1.BindTexture(All1.Texture2D, 0);
                GL1.DeleteTextures(1, ref contextSettings.texture);
                contextSettings.textureObjectsHaveBeenSetup = false;
            }

            GL1.GenTextures(1, out contextSettings.texture);
            GL1.ActiveTexture(All1.Texture0);
            GL1.BindTexture(All1.Texture2D, contextSettings.texture);
            GL1.TexParameterx(All1.Texture2D, All1.TextureMinFilter, (int)All1.Linear);
            GL1.TexParameterx(All1.Texture2D, All1.TextureMagFilter, (int)All1.Linear);
            // Decide whether we can use GL_CLAMP_TO_EDGE.
            //if (arglGLCapabilityCheck(0x0120, (unsigned char *)"GL_SGIS_texture_edge_clamp")) {
            textureWrapMode = (int)All1.ClampToEdge;
            //} else {
            //    textureWrapMode = (int)All1.Repeat;
            //}
            GL1.TexParameterx(All1.Texture2D, All1.TextureWrapS, textureWrapMode);
            GL1.TexParameterx(All1.Texture2D, All1.TextureWrapT, textureWrapMode);

            contextSettings.textureObjectsHaveBeenSetup = true;
            return(true);
        }
Ejemplo n.º 3
0
        public static ARGL_CONTEXT_SETTINGS arglSetupForCurrentContext(ARParam cparam, AR_PIXEL_FORMAT pixelFormat)
        {
            ARGL_CONTEXT_SETTINGS contextSettings;

            contextSettings         = new ARGL_CONTEXT_SETTINGS();
            contextSettings.arParam = cparam; // Copy it.
            contextSettings.zoom    = 1.0f;
            // Because of calloc used above, these are redundant.
            //contextSettings.rotate90 = contextSettings.flipH = contextSettings.flipV = false;
            //contextSettings.disableDistortionCompensation = false;
            //contextSettings.textureGeometryHasBeenSetup = false;
            //contextSettings.textureObjectsHaveBeenSetup = false;
            //contextSettings.textureDataReady = false;

            // This sets pixIntFormat, pixFormat, pixType, pixSize, and resets textureDataReady.
            arglPixelFormatSet(contextSettings, pixelFormat);

            // Set pixel buffer sizes to incoming image size, by default.
            if (!arglPixelBufferSizeSet(contextSettings, cparam.xsize, cparam.ysize))
            {
                Debug.Print("ARGL: Error setting pixel buffer size.\n");
                contextSettings = null;
                return(null);
            }

            return(contextSettings);
        }
Ejemplo n.º 4
0
 static bool arglGetRotate90(ARGL_CONTEXT_SETTINGS contextSettings)
 {
     if (contextSettings == null)
     {
         return(false);
     }
     return(contextSettings.rotate90);
 }
Ejemplo n.º 5
0
 static void arglSetFlipV(ARGL_CONTEXT_SETTINGS contextSettings, bool flipV)
 {
     if (contextSettings == null)
     {
         return;
     }
     contextSettings.flipV = flipV;
 }
Ejemplo n.º 6
0
 static bool arglGetFlipV(ARGL_CONTEXT_SETTINGS contextSettings)
 {
     if (contextSettings == null)
     {
         return(false);
     }
     return(contextSettings.flipV);
 }
Ejemplo n.º 7
0
 static void arglSetRotate90(ARGL_CONTEXT_SETTINGS contextSettings, bool rotate90)
 {
     if (contextSettings == null)
     {
         return;
     }
     contextSettings.rotate90 = rotate90;
 }
Ejemplo n.º 8
0
 static bool arglDistortionCompensationGet(ARGL_CONTEXT_SETTINGS contextSettings, ref bool enable)
 {
     if (contextSettings == null || !enable)
     {
         return(false);
     }
     enable = contextSettings.disableDistortionCompensation;
     return(true);
 }
Ejemplo n.º 9
0
 static bool arglDistortionCompensationSet(ARGL_CONTEXT_SETTINGS contextSettings, bool enable)
 {
     if (contextSettings == null)
     {
         return(false);
     }
     contextSettings.disableDistortionCompensation = !enable;
     return(arglSetupTextureGeometry(contextSettings));
 }
Ejemplo n.º 10
0
 static bool arglGetPixelZoom(ARGL_CONTEXT_SETTINGS contextSettings, ref float zoom)
 {
     if (contextSettings == null)
     {
         return(false);
     }
     zoom = contextSettings.zoom;
     return(true);
 }
Ejemplo n.º 11
0
        static bool arglSetPixelZoom(ARGL_CONTEXT_SETTINGS contextSettings, float zoom)
        {
            if (contextSettings == null)
            {
                return(false);
            }
            contextSettings.zoom = zoom;

            // Changing the zoom invalidates the geometry, so set it up.
            return(arglSetupTextureGeometry(contextSettings));
        }
Ejemplo n.º 12
0
        static bool arglPixelFormatGet(ARGL_CONTEXT_SETTINGS contextSettings, ref AR_PIXEL_FORMAT format, ref int size)
        {
            if (contextSettings == null)
            {
                return(false);
            }

            format = contextSettings.format;
            size   = contextSettings.pixSize;

            return(true);
        }
Ejemplo n.º 13
0
        static void arglCleanup(ARGL_CONTEXT_SETTINGS contextSettings)
        {
            if (contextSettings == null)
            {
                return;                          // Sanity check.
            }
            if (contextSettings.textureObjectsHaveBeenSetup)
            {
                GL1.ActiveTexture(All1.Texture0);
                GL1.BindTexture(All1.Texture2D, 0);
                GL1.DeleteTextures(1, ref contextSettings.texture);
            }

            if (contextSettings.textureGeometryHasBeenSetup)
            {
                GL1.DeleteBuffers(1, ref contextSettings.t2bo);
                GL1.DeleteBuffers(1, ref contextSettings.v2bo);
            }

            contextSettings = null;
        }
Ejemplo n.º 14
0
        static bool arglPixelBufferSizeSet(ARGL_CONTEXT_SETTINGS contextSettings, int bufWidth, int bufHeight)
        {
            if (contextSettings == null)
            {
                return(false);
            }

            // Check texturing capabilities (sets textureSizeX, textureSizeY, textureSizeMax).
            GL1.GetInteger(All1.MaxTextureSize, out contextSettings.textureSizeMax);
            if (bufWidth > contextSettings.textureSizeMax || bufHeight > contextSettings.textureSizeMax)
            {
                Debug.Print("Error: ARGL: Your OpenGL implementation and/or hardware's texturing capabilities are insufficient.\n");
                return(false);
            }

            contextSettings.textureSizeX         = bufWidth;
            contextSettings.textureSizeY         = bufHeight;
            contextSettings.bufSizeIsTextureSize = true;

            // Changing the size of the data we'll be receiving invalidates the geometry, so set it up.
            return(arglSetupTextureGeometry(contextSettings));
        }
Ejemplo n.º 15
0
        static bool arglPixelBufferSizeGet(ARGL_CONTEXT_SETTINGS contextSettings, ref int bufWidth, ref int bufHeight)
        {
            if (contextSettings == null)
            {
                return(false);
            }
            if (contextSettings.textureGeometryHasBeenSetup)
            {
                return(false);
            }

            if (contextSettings.bufSizeIsTextureSize)
            {
                bufWidth  = contextSettings.textureSizeX;
                bufHeight = contextSettings.textureSizeY;
            }
            else
            {
                bufWidth  = contextSettings.bufSizeX;
                bufHeight = contextSettings.bufSizeY;
            }
            return(true);
        }
Ejemplo n.º 16
0
        static bool arglPixelFormatSet(ARGL_CONTEXT_SETTINGS contextSettings, AR_PIXEL_FORMAT format)
        {
            if (contextSettings == null)
            {
                return(false);
            }
            switch (format)
            {
            case AR_PIXEL_FORMAT.AR_PIXEL_FORMAT_Rgba:
                contextSettings.pixIntFormat = (int)All1.Rgba;
                contextSettings.pixFormat    = (int)All1.Rgba;
                contextSettings.pixType      = (int)All1.UnsignedByte;
                contextSettings.pixSize      = 4;
                break;

            case AR_PIXEL_FORMAT.AR_PIXEL_FORMAT_Bgra:      // Windows.
                contextSettings.pixIntFormat = (int)All1.Rgba;
                contextSettings.pixFormat    = (int)All1.Bgra;
                contextSettings.pixType      = (int)All1.UnsignedByte;
                contextSettings.pixSize      = 4;
                break;

            case AR_PIXEL_FORMAT.AR_PIXEL_FORMAT_ABGR:      // SGI.
                contextSettings.pixIntFormat = (int)All1.Rgba;
                contextSettings.pixFormat    = (int)All1.AbgrExt;
                contextSettings.pixType      = (int)All1.UnsignedByte;
                contextSettings.pixSize      = 4;
                break;

            case AR_PIXEL_FORMAT.AR_PIXEL_FORMAT_ARGB:      // Mac.
                contextSettings.pixIntFormat = (int)All1.Rgba;
                contextSettings.pixFormat    = (int)All1.Bgra;
                contextSettings.pixType      = (int)All1.UnsignedInt8888;
                contextSettings.pixSize      = 4;
                break;

            case AR_PIXEL_FORMAT.AR_PIXEL_FORMAT_RGB:
                contextSettings.pixIntFormat = (int)All1.Rgb;
                contextSettings.pixFormat    = (int)All1.Rgb;
                contextSettings.pixType      = (int)All1.UnsignedByte;
                contextSettings.pixSize      = 3;
                break;

            case AR_PIXEL_FORMAT.AR_PIXEL_FORMAT_BGR:
                contextSettings.pixIntFormat = (int)All1.Rgb;
                contextSettings.pixFormat    = (int)All1.Rgb;
                contextSettings.pixType      = (int)All1.UnsignedByte;
                contextSettings.pixSize      = 3;
                break;

            default:
                return(false);

                break;
            }
            contextSettings.format           = format;
            contextSettings.textureDataReady = false;

            if (!arglSetupTextureObjects(contextSettings))
            {
                return(false);
            }

            return(true);
        }
Ejemplo n.º 17
0
        static void arglDispImageStateful(ARGL_CONTEXT_SETTINGS contextSettings)
        {
            int texEnvModeSave;
            int i;

            if (contextSettings == null)
            {
                return;
            }
            if (contextSettings.textureObjectsHaveBeenSetup)
            {
                return;
            }
            if (contextSettings.textureGeometryHasBeenSetup)
            {
                return;
            }
            if (contextSettings.textureDataReady)
            {
                return;
            }

            GL1.ActiveTexture(All1.Texture0);

            GL1.MatrixMode(All1.Texture);
            GL1.LoadIdentity();
            GL1.MatrixMode(All1.Modelview);

            GL1.BindTexture(All1.Texture2D, contextSettings.texture);
            GL1.GetTexEnv(All1.TextureEnv, All1.TextureEnvMode, out texEnvModeSave); // Save GL texture environment mode.
            if (texEnvModeSave != (int)All1.Replace)
            {
                GL1.TexEnv(All1.TextureEnv, All1.TextureEnvMode, (int)All1.Replace);
            }
            GL1.Enable(All1.Texture2D);

            GL1.ClientActiveTexture(All1.Texture0);
            GL1.BindBuffer(All1.ArrayBuffer, contextSettings.t2bo);
            GL1.TexCoordPointer(2, All1.Float, 0, IntPtr.Zero);
            GL1.EnableClientState(All1.TextureCoordArray);

            GL1.BindBuffer(All1.ArrayBuffer, contextSettings.v2bo);
            GL1.VertexPointer(2, All1.Float, 0, IntPtr.Zero);
            GL1.EnableClientState(All1.VertexArray);
            GL1.DisableClientState(All1.NormalArray);

            if (contextSettings.disableDistortionCompensation)
            {
                GL1.DrawArrays(All1.TriangleStrip, 0, 4);
            }
            else
            {
                for (i = 0; i < 20; i++)
                {
                    GL1.DrawArrays(All1.TriangleStrip, i * 42, 42);
                }
            }

            GL1.BindBuffer(All1.ArrayBuffer, 0);
            GL1.DisableClientState(All1.VertexArray);
            GL1.DisableClientState(All1.TextureCoordArray);

            GL1.Disable(All1.Texture2D);
            if (texEnvModeSave != (int)All1.Replace)
            {
                GL1.TexEnv(All1.TextureEnv, All1.TextureEnvMode, texEnvModeSave);                                      // Restore GL texture environment mode.
            }
        }
Ejemplo n.º 18
0
        public static bool arglSetupTextureGeometry(ARGL_CONTEXT_SETTINGS contextSettings)
        {
            float  ty_prev, tx, ty;
            float  y_prev, x, y;
            double x1, x2, y1, y2;
            float  xx1, xx2, yy1, yy2;
            int    i, j;
            int    vertexCount, t2count, v2count;
            float  imageSizeX, imageSizeY;
            float  zoom;

            // Delete previous geometry, unless this is our first time here.
            if (contextSettings.textureGeometryHasBeenSetup)
            {
                GL1.DeleteBuffers(1, ref contextSettings.t2bo);
                GL1.DeleteBuffers(1, ref contextSettings.v2bo);
                contextSettings.textureGeometryHasBeenSetup = false;
            }

            // Set up the geometry for the surface which we will texture upon.
            imageSizeX = (float)contextSettings.arParam.xsize;
            imageSizeY = (float)contextSettings.arParam.ysize;
            zoom       = contextSettings.zoom;
            if (contextSettings.disableDistortionCompensation)
            {
                vertexCount = 4;
            }
            else
            {
                vertexCount = 840;  // 20 rows of 2 x 21 vertices.
            }
            contextSettings.t2 = new float[2 * vertexCount];
            contextSettings.v2 = new float[2 * vertexCount];
            t2count            = v2count = 0;
            if (contextSettings.disableDistortionCompensation)
            {
                contextSettings.t2[t2count++] = 0.0f; // Top-left.
                contextSettings.t2[t2count++] = 0.0f;
                contextSettings.v2[v2count++] = 0.0f;
                contextSettings.v2[v2count++] = imageSizeY * zoom;
                contextSettings.t2[t2count++] = 0.0f; // Bottom-left.
                contextSettings.t2[t2count++] = imageSizeY / (float)contextSettings.textureSizeY;
                contextSettings.v2[v2count++] = 0.0f;
                contextSettings.v2[v2count++] = 0.0f;
                contextSettings.t2[t2count++] = imageSizeX / (float)contextSettings.textureSizeX; // Top-right.
                contextSettings.t2[t2count++] = 0.0f;
                contextSettings.v2[v2count++] = imageSizeX * zoom;
                contextSettings.v2[v2count++] = imageSizeY * zoom;
                contextSettings.t2[t2count++] = imageSizeX / (float)contextSettings.textureSizeX; // Bottom-right.
                contextSettings.t2[t2count++] = imageSizeY / (float)contextSettings.textureSizeY;
                contextSettings.v2[v2count++] = imageSizeX * zoom;
                contextSettings.v2[v2count++] = 0.0f;
            }
            else
            {
                y  = 0.0f;
                ty = 0.0f;
                for (j = 1; j <= 20; j++)      // Do 20 rows of triangle strips.
                {
                    y_prev  = y;
                    ty_prev = ty;
                    y       = imageSizeY * (float)j / 20.0f;
                    ty      = y / (float)contextSettings.textureSizeY;


                    for (i = 0; i <= 20; i++)   // 21 columns of triangle strip vertices, 2 vertices per column.
                    {
                        x  = imageSizeX * (float)i / 20.0f;
                        tx = x / (float)contextSettings.textureSizeX;

                        arParamObserv2Ideal(contextSettings.arParam.dist_factor, (double)x, (double)y_prev, out x1, out y1, contextSettings.arParam.dist_function_version);
                        arParamObserv2Ideal(contextSettings.arParam.dist_factor, (double)x, (double)y, out x2, out y2, contextSettings.arParam.dist_function_version);

                        xx1 = (float)x1 * zoom;
                        yy1 = (imageSizeY - (float)y1) * zoom;
                        xx2 = (float)x2 * zoom;
                        yy2 = (imageSizeY - (float)y2) * zoom;

                        contextSettings.t2[t2count++] = tx; // Top.
                        contextSettings.t2[t2count++] = ty_prev;
                        contextSettings.v2[v2count++] = xx1;
                        contextSettings.v2[v2count++] = yy1;
                        contextSettings.t2[t2count++] = tx; // Bottom.
                        contextSettings.t2[t2count++] = ty;
                        contextSettings.v2[v2count++] = xx2;
                        contextSettings.v2[v2count++] = yy2;
                    } // columns.
                }     // rows.
            }

            // Now setup VBOs.
            GL1.GenBuffers(1, out contextSettings.t2bo);
            GL1.GenBuffers(1, out contextSettings.v2bo);
            GL1.BindBuffer(All1.ArrayBuffer, contextSettings.t2bo);
            GL1.BufferData(All1.ArrayBuffer, new IntPtr((sizeof(float) * 2 * vertexCount)), contextSettings.t2, All1.StaticDraw);
            GL1.BindBuffer(All1.ArrayBuffer, contextSettings.v2bo);
            GL1.BufferData(All1.ArrayBuffer, new IntPtr((sizeof(float) * 2 * vertexCount)), contextSettings.v2, All1.StaticDraw);
            GL1.BindBuffer(All1.ArrayBuffer, 0);

            contextSettings.textureGeometryHasBeenSetup = true;
            return(true);
        }
Ejemplo n.º 19
0
        static void arglDispImage(ARGL_CONTEXT_SETTINGS contextSettings)
        {
            float left, right, bottom, top;
            bool  lightingSave;
            bool  depthTestSave;

            if (contextSettings == null)
            {
                return;
            }

            // Prepare an orthographic projection, set camera position for 2D drawing, and save GL state.
            GL1.MatrixMode(All1.Projection);
            GL1.PushMatrix();
            GL1.LoadIdentity();
            if (contextSettings.rotate90)
            {
                GL1.Rotate(90.0f, 0.0f, 0.0f, -1.0f);
            }

            if (contextSettings.flipV)
            {
                bottom = (float)contextSettings.arParam.ysize;
                top    = 0.0f;
            }
            else
            {
                bottom = 0.0f;
                top    = (float)contextSettings.arParam.ysize;
            }
            if (contextSettings.flipH)
            {
                left  = (float)contextSettings.arParam.xsize;
                right = 0.0f;
            }
            else
            {
                left  = 0.0f;
                right = (float)contextSettings.arParam.xsize;
            }
            GL1.Ortho(left, right, bottom, top, -1.0f, 1.0f);
            GL1.MatrixMode(All1.Modelview);
            GL1.PushMatrix();
            GL1.LoadIdentity();

            lightingSave = GL1.IsEnabled(All1.Lighting);            // Save enabled state of lighting.
            if (lightingSave == true)
            {
                GL1.Disable(All1.Lighting);
            }
            depthTestSave = GL1.IsEnabled(All1.DepthTest);      // Save enabled state of depth test.
            if (depthTestSave == true)
            {
                GL1.Disable(All1.DepthTest);
            }

            arglDispImageStateful(contextSettings);

            if (depthTestSave == true)
            {
                GL1.Enable(All1.DepthTest);                                 // Restore enabled state of depth test.
            }
            if (lightingSave == true)
            {
                GL1.Enable(All1.Lighting);                               // Restore enabled state of lighting.
            }
            // Restore previous projection & camera position.
            GL1.MatrixMode(All1.Projection);
            GL1.PopMatrix();
            GL1.MatrixMode(All1.Modelview);
            GL1.PopMatrix();

            // Report any errors we generated.
            int err = (int)GL1.GetError();

            while (err != (int)All1.NoError)
            {
                Debug.Print("ARGL: GL error 0x%04X\n", (int)err);
            }
        }