コード例 #1
0
        //Texture skybox;

        public static void load(String url, OnTextueLoad onloading, OnTextueLoad onloadComplete)
        {
            texture.fetch_texture(url, (int skybox) =>
            {
                onloading(skybox);
            },
                                  (int skybox, System.Drawing.Bitmap image) =>
            {
                bool isPowerOf2 = false;
                System.Drawing.Imaging.BitmapData pixelData;

                pixelData = texture.UnlockBitmap(image);

                GL.Enable(EnableCap.TextureCubeMap);
                GL.BindTexture(TextureTarget.TextureCubeMap, skybox);

                //gl.texImage2D(types[i], 0, GL_RGB, pImage->columns(), pImage->rows(), 0, RenderingContext.RGBA,
                //     RenderingContext.UNSIGNED_BYTE, blob.data());
                GL.TexImage2D(TextureTarget.TextureCubeMap, 0, PixelInternalFormat.Rgba, image.Width, image.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, pixelData.Scan0);

                GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
                GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
                GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureMagFilter, (int)TextureMinFilter.Linear);
                GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureMinFilter, (isPowerOf2 ? (int)TextureMinFilter.LinearMipmapNearest : (int)TextureMinFilter.Linear));

                if (isPowerOf2)
                {
                    GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
                }

                onloadComplete(skybox);
            });
        }
コード例 #2
0
ファイル: Skybox.cs プロジェクト: geralltf/alethaCS
        public static void loadSkyTexture(shader_gl shader,
                                          shader_p surface,
                                          OnTextueLoad onTextureLoading,
                                          OnTextueLoad onTextureLoadComplete)
        {
            bool has_skyparams = shader.sky_env_map != null;



            if (has_skyparams)
            {
                // hard code in six or one texture mode for now

                String url       = Config.q3bsp_base_folder + "/" + shader.sky_env_map.@params;
                String back_url  = url + "_bk.jpg";
                String down_url  = url + "_dn.jpg";
                String front_url = url + "_ft.jpg";
                String left_url  = url + "_lf.jpg";
                String right_url = url + "_rt.jpg";
                String up_url    = url + "_up.jpg";

                cubemap_texture_six.load(back_url,
                                         down_url,
                                         front_url,
                                         left_url,
                                         right_url,
                                         up_url,
                                         (int texture) =>
                {
                    onTextureLoading(texture);
                },
                                         (int texture) =>
                {
                    onTextureLoadComplete(texture);
                });



                //TODO: support for single texture mode using something like this. need to find test map.

                //      cubemap_texture_one.load(back_url, gl,
                //      (GLTexture texture)
                //      {
                //        onTextureLoading(texture);
                //      },
                //      (GLTexture texture)
                //      {
                //        onTextureLoadComplete(texture);
                //      });

                //cubemap_texture_one.load(q3bsp_base_folder + '/' + stage.map, gl, null, onTextureLoadComplete);
            }
            else
            {
                //UNTESTED condition
            }
        }
コード例 #3
0
        public static void LoadComplete(int index, TextureTarget target, OnTextueLoad onloadComplete) // OnSkymapLoadComplete
        {
            var context = new OpenTK.Graphics.GraphicsContext(AlethaApplication.GraphicsMode, AlethaApplication.NativeWindowContext.WindowInfo);

            context.MakeCurrent(AlethaApplication.NativeWindowContext.WindowInfo);

            int skybox = GL.GenTexture();

            index  = skybox;
            skymap = skybox;
            System.Drawing.Imaging.BitmapData xposd, yposd, zposd, xnegd, ynegd, znegd;



            //gl.enable(RenderingContext.TEXTURE_CUBE_MAP);
            GL.BindTexture(TextureTarget.TextureCubeMap, skybox);

            GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureMagFilter, (int)TextureMinFilter.Linear);
            GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
            GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
            GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);

            //gl.TexParameter(RenderingContext.TEXTURE_CUBE_MAP, RenderingContext.TEXTURE_WRAP_R, RenderingContext.CLAMP_TO_EDGE);

            int level = 0;
            PixelInternalFormat format  = PixelInternalFormat.Rgba;
            PixelFormat         pformat = PixelFormat.Rgba;
            PixelType           type    = PixelType.UnsignedByte;

            xposd = texture.UnlockBitmap(xpos);
            yposd = texture.UnlockBitmap(ypos);
            zposd = texture.UnlockBitmap(zpos);
            xnegd = texture.UnlockBitmap(xneg);
            ynegd = texture.UnlockBitmap(yneg);
            znegd = texture.UnlockBitmap(zneg);

            // gl.texImage2D(RenderingContext.TEXTURE_2D, 0, RenderingContext.RGBA, RenderingContext.RGBA, RenderingContext.UNSIGNED_BYTE, image);
            GL.TexImage2D(TextureTarget.TextureCubeMapPositiveX, level, format, xpos.Width, xpos.Height, 0, pformat, type, xposd.Scan0);
            GL.TexImage2D(TextureTarget.TextureCubeMapNegativeX, level, format, xneg.Width, xneg.Height, 0, pformat, type, xnegd.Scan0);
            GL.TexImage2D(TextureTarget.TextureCubeMapPositiveY, level, format, ypos.Width, ypos.Height, 0, pformat, type, yposd.Scan0);
            GL.TexImage2D(TextureTarget.TextureCubeMapNegativeY, level, format, yneg.Width, yneg.Height, 0, pformat, type, ynegd.Scan0);
            GL.TexImage2D(TextureTarget.TextureCubeMapPositiveZ, level, format, zpos.Width, zpos.Height, 0, pformat, type, zposd.Scan0);
            GL.TexImage2D(TextureTarget.TextureCubeMapNegativeZ, level, format, zneg.Width, zneg.Height, 0, pformat, type, znegd.Scan0);

            onloadComplete(skybox);
        }
コード例 #4
0
        public void loadTextureUrl(stage_gl stage, String url, OnTextueLoad onload)
        {
            texture.fetch_texture(url, (int texture) =>
            {
                onload(texture);
            },
                                  (int texture, Bitmap image) =>
            {
                bool isPowerOf2 = false;
                BitmapData pixelData;
                Rectangle boundingbox;

                boundingbox = new Rectangle(0, 0, image.Width, image.Height);

                pixelData = image.LockBits(boundingbox,
                                           System.Drawing.Imaging.ImageLockMode.ReadOnly,
                                           System.Drawing.Imaging.PixelFormat.Format32bppArgb);

                GL.BindTexture(TextureTarget.Texture2D, texture);
                GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, image.Width, image.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, pixelData.Scan0);

                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (isPowerOf2 ? (int)TextureMinFilter.LinearMipmapNearest : (int)TextureMinFilter.Linear));
                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);

                if (stage.clamp == true)
                {
                    GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
                    GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
                }

                if (isPowerOf2)
                {
                    GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
                }

                GL.BindTexture(TextureTarget.Texture2D, 0);

                onload(texture);
            });
        }
コード例 #5
0
        public static void load(String back_url,
                                String down_url,
                                String front_url,
                                String left_url,
                                String right_url,
                                String up_url,
                                OnTextueLoad onloading,
                                OnTextueLoad onloadComplete)
        {
            // DISPATCH requests

            //onloading(skymap);

            //ASYNC loading of skybox right here
            texture.fetch_texture(back_url, (t) => { }, (int t, System.Drawing.Bitmap image) =>
            {
                TextureTarget target = TextureTarget.TextureCubeMapNegativeZ;

                PartLoadComplete(image, target);

                num_loaded++;
                if (num_loaded == 6)
                {
                    LoadComplete(-1, target, onloadComplete);
                }
            });

            texture.fetch_texture(down_url, (t) => { }, (int t, System.Drawing.Bitmap image) =>
            {
                TextureTarget target = TextureTarget.TextureCubeMapPositiveX;

                PartLoadComplete(image, target);

                num_loaded++;
                if (num_loaded == 6)
                {
                    LoadComplete(t, target, onloadComplete);
                }
            });

            texture.fetch_texture(front_url, (t) => { }, (int t, System.Drawing.Bitmap image) =>
            {
                TextureTarget target = TextureTarget.TextureCubeMapNegativeX;

                PartLoadComplete(image, target);

                num_loaded++;
                if (num_loaded == 6)
                {
                    LoadComplete(t, target, onloadComplete);
                }
            });

            texture.fetch_texture(left_url, (t) => { }, (int t, System.Drawing.Bitmap image) =>
            {
                TextureTarget target = TextureTarget.TextureCubeMapPositiveY;

                PartLoadComplete(image, target);

                num_loaded++;
                if (num_loaded == 6)
                {
                    LoadComplete(t, target, onloadComplete);
                }
            });

            texture.fetch_texture(right_url, (t) => { }, (int t, System.Drawing.Bitmap image) =>
            {
                TextureTarget target = TextureTarget.TextureCubeMapNegativeY;

                PartLoadComplete(image, target);

                num_loaded++;
                if (num_loaded == 6)
                {
                    LoadComplete(t, target, onloadComplete);
                }
            });

            texture.fetch_texture(up_url, (t) => { }, (int t, System.Drawing.Bitmap image) =>
            {
                TextureTarget target = TextureTarget.TextureCubeMapPositiveZ;

                PartLoadComplete(image, target);

                num_loaded++;
                if (num_loaded == 6)
                {
                    LoadComplete(t, target, onloadComplete);
                }
            });
        }
コード例 #6
0
        public static void fetch_texture(String url, OnTextueLoad onGlTexture, OnTextueImageLoadComplete onloadComplete)
        {
            int    texture = -1;
            Bitmap image   = null;

            if (onGlTexture != null)
            {
                if (url_cache_texture.ContainsKey(url))
                {
                    texture = url_cache_texture[url];
                }
                else
                {
                    texture = GL.GenTexture();
                }

                onGlTexture(texture);
            }

            if (onloadComplete != null)
            {
                if (data_cache_texture.ContainsKey(url))
                {
                    image = (Bitmap)data_cache_texture[url];
                }
                else
                {
                    //      fetch(url,'arraybuffer').then((HttpRequest request){
                    //        var respp = request.response;
                    //
                    //        print("["+request.statusText+"] "+request.responseUrl);
                    //
                    //        var image = respp;
                    //        onloadComplete(texture,image);
                    //      });

                    //try
                    //{
                    url = url.Replace("/", "\\");     // they are all located in base folder on local file system not on web

                    image = new Bitmap(url);

                    var newSize = GetTextureGLMaxSize(image);

                    Rescale(ref image, newSize);


                    //AlethaApplication.incReqests();
                    //    AlethaApplication.update_progress_bar(AlethaApplication.request_number, url);

                    //    onloadComplete(texture, image);

                    //    Console.WriteLine(url);
                    //}
                    //catch
                    //{
                    //    Console.WriteLine("[warning] could not find texture '{0}'", url);
                    //}
                }
                AlethaApplication.incReqests();
                AlethaApplication.update_progress_bar(AlethaApplication.request_number, url);

                onloadComplete(texture, image);

                Console.WriteLine(url);

                //fetch_update(url);
            }
        }