Пример #1
0
        protected override void OnRenderUI(CanvasRenderer renderer)
        {
            base.OnRenderUI(renderer);

            //draw texture
            {
                var color = new ColorValue(1, 1, 1);

                GetScreenRectangle(out var rect);

                var tex = createdImage;
                if (tex == null)
                {
                    tex = ResourceUtility.WhiteTexture2D;
                }

                if (renderer.IsScreen)                 //&& !renderer._OutGeometryTransformEnabled )
                {
                    //screen per pixel accuracy

                    Vector2   viewportSize = renderer.ViewportForScreenCanvasRenderer.SizeInPixels.ToVector2F();
                    var       v            = createdForSize.ToVector2() / viewportSize;
                    Rectangle fixedRect    = new Rectangle(rect.LeftTop, rect.LeftTop + v);

                    renderer.PushTextureFilteringMode(CanvasRenderer.TextureFilteringMode.Point);
                    renderer.AddQuad(fixedRect, new Rectangle(0, 0, 1, 1), tex, color, true);
                    renderer.PopTextureFilteringMode();
                }
                else
                {
                    renderer.AddQuad(rect, new Rectangle(0, 0, 1, 1), tex, color, true);
                }
                //}
            }
        }
Пример #2
0
        /////////////////////////////////////////

        protected override void OnRenderUI(CanvasRenderer renderer)
        {
            base.OnRenderUI(renderer);

            //bool backColorZero = backColor == new ColorValue( 0, 0, 0, 0 );

            //!!!!неправильной текстурой рисовать, чтобы видно было что ошибка? везде так
            //!!!!!заранее при загрузке?

            Component_Image texture = SourceImage;

            ////!!!!?
            //GpuTexture gpuTexture = ResourceUtils.GetTextureCompiledData( texture );
            //if( gpuTexture == null )
            //	gpuTexture = ResourceUtils.GetTextureCompiledData( ResourceUtils.WhiteTexture2D );

            if (texture != null)
            {
                //Rect texCoord = backTextureCoord;

                //if( backTextureTile && texture != null )
                //{
                //	double baseHeight = UIControlsWorld.ScaleByResolutionBaseHeight;
                //	//!!!!!!slow
                //	Vec2 tileCount = new Vec2( baseHeight * renderer.AspectRatio, baseHeight ) / gpuTexture.SourceSize.ToVec2F() * GetScreenSize();
                //	texCoord = new Rect( -tileCount * .5f, tileCount * .5f ) + new Vec2( .5f, .5f );
                //}

                //var color = GetTotalColorMultiplier();
                //if( color.Alpha > 0 )
                //{
                //	color.Saturate();

                GetScreenRectangle(out var rect);

                var filtering = Filtering.Value;
                //!!!!или всегда выставлять. или добавить пункт Default.
                if (filtering == CanvasRenderer.TextureFilteringMode.Point)
                {
                    renderer.PushTextureFilteringMode(CanvasRenderer.TextureFilteringMode.Point);
                }

                renderer.AddQuad(rect, TextureCoordinates.Value, texture, ColorValue.One, Clamp);
                //renderer.AddQuad( rect, texCoord, texture, color, backTextureTile ? false : true );

                if (filtering == CanvasRenderer.TextureFilteringMode.Point)
                {
                    renderer.PopTextureFilteringMode();
                }
                //}
            }
        }
Пример #3
0
        protected override void OnRenderUI(CanvasRenderer renderer)
        {
            base.OnRenderUI(renderer);

            Vector2I size = GetNeededSize();

            if (browser == null)
            {
                CreateBrowser();
            }

            //update brower engine and texture
            if (browser != null)
            {
                if (viewSize != size /*&& !browser.IsResizing */)
                {
                    var oldSize = viewSize;
                    viewSize = size;
                    OnResized(oldSize, viewSize);
                }

                //create texture
                if (texture == null || textureSize != size || needRecreateTexture)
                {
                    if (texture != null)
                    {
                        texture.Dispose();
                        texture = null;
                    }

                    textureSize = size;

                    bool mipmaps = false;
                    //!!!!
                    //if( ControlManager != null && ControlManager is UI3DControlContainer )
                    //	mipmaps = renderingIn3DMipmaps;

                    var usage = Component_Image.Usages.WriteOnly;
                    if (mipmaps)
                    {
                        usage |= Component_Image.Usages.AutoMipmaps;
                    }

                    texture               = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
                    texture.CreateType    = Component_Image.TypeEnum._2D;
                    texture.CreateSize    = textureSize;
                    texture.CreateMipmaps = mipmaps;                    // ? -1 : 0;
                    texture.CreateFormat  = PixelFormat.A8R8G8B8;
                    texture.CreateUsage   = usage;
                    texture.Enabled       = true;

                    //Log.Info( textureSize.ToString() );

                    //if( mipmaps )
                    //{
                    //	texture = TextureManager.Instance.Create( textureName, Texture.Type.Type2D, textureSize,
                    //		1, -1, PixelFormat.A8R8G8B8, Texture.Usage.DynamicWriteOnlyDiscardable | Texture.Usage.AutoMipmap );
                    //}
                    //else
                    //{
                    //	texture = TextureManager.Instance.Create( textureName, Texture.Type.Type2D, textureSize,
                    //		1, 0, PixelFormat.A8R8G8B8, Texture.Usage.DynamicWriteOnlyDiscardable );
                    //}

                    needUpdateTexture   = true;
                    needRecreateTexture = false;
                }

                if (needInvalidate)
                {
                    browserHost.SetZoomLevel(Zoom);
                    browserHost.Invalidate(new CefRectangle(0, 0, 100000, 100000), CefPaintElementType.View);
                    needInvalidate = false;
                }

                //update texture
                if (/*browser.IsDirty ||*/ needUpdateTexture)
                {
                    if (texture != null)
                    {
                        UpdateTexture();
                    }
                    needUpdateTexture = false;
                }
            }

            //draw texture
            {
                //bool backColorZero = BackColor == new ColorValue( 0, 0, 0, 0 );

                //ColorValue color = new ColorValue( 1, 1, 1 );
                ////ColorValue color = backColorZero ? new ColorValue( 1, 1, 1 ) : BackColor;
                //if( texture == null )
                //	color = new ColorValue( 0, 0, 0, color.Alpha );
                //color *= GetTotalColorMultiplier();

                //var color = GetTotalColorMultiplier();
                //if( color.Alpha > 0 )
                //{
                var color = new ColorValue(1, 1, 1);
                //color.Saturate();

                GetScreenRectangle(out var rect);

                Component_Image tex = null;
                if (renderBuffer != null && renderBufferForSize == ViewSize && renderBuffer.Length == ViewSize.X * ViewSize.Y * 4)
                {
                    tex = texture;
                }
                if (tex == null)
                {
                    tex = ResourceUtility.WhiteTexture2D;
                }

                if (renderer.IsScreen)                 //&& !renderer._OutGeometryTransformEnabled )
                {
                    ////screen per pixel accuracy

                    Vector2   viewportSize = renderer.ViewportForScreenCanvasRenderer.SizeInPixels.ToVector2F();
                    var       v            = size.ToVector2() / viewportSize;
                    Rectangle fixedRect    = new Rectangle(rect.LeftTop, rect.LeftTop + v);

                    //Vec2 leftTop = rect.LeftTop;
                    //leftTop *= viewportSize;
                    //leftTop = new Vec2( (int)( leftTop.X + .9999f ), (int)( leftTop.Y + .9999f ) );
                    ////!!!!!
                    ////if( RenderSystem.Instance.IsDirect3D() )
                    ////	leftTop -= new Vec2( .5f, .5f );
                    //leftTop /= viewportSize;

                    //Vec2 rightBottom = rect.RightBottom;
                    //rightBottom *= viewportSize;
                    //rightBottom = new Vec2( (int)( rightBottom.X + .9999f ), (int)( rightBottom.Y + .9999f ) );
                    ////!!!!!
                    ////if( RenderSystem.Instance.IsDirect3D() )
                    ////	rightBottom -= new Vec2( .5f, .5f );
                    //rightBottom /= viewportSize;

                    //Rect fixedRect = new Rect( leftTop, rightBottom );

                    renderer.PushTextureFilteringMode(CanvasRenderer.TextureFilteringMode.Point);
                    renderer.AddQuad(fixedRect, new Rectangle(0, 0, 1, 1), tex, color, true);
                    renderer.PopTextureFilteringMode();
                }
                else
                {
                    renderer.AddQuad(rect, new Rectangle(0, 0, 1, 1), tex, color, true);
                }
                //}
            }

            if (!IsSupportedByThisPlatform())
            {
                var text   = string.Format("UIWebBrowser: {0} is not supported.", SystemSettings.CurrentPlatform);
                var center = GetScreenRectangle().GetCenter();
                renderer.AddText(text, center, EHorizontalAlignment.Center, EVerticalAlignment.Center, new ColorValue(1, 0, 0));
            }
        }