public bool PaintRenderTexture(BrushStrokePainterImage cfg)
            {
                var stroke  = cfg.stroke;
                var image   = cfg.image;
                var painter = cfg.painter;
                var bc      = cfg.brush;

                var vt = painter.GetVolumeTexture();

                stroke.posFrom = stroke.posTo;

                BrushTypes.Sphere.Inst.BeforeStroke(bc, stroke, painter);

                VOLUME_POSITION_N_SIZE_BRUSH.GlobalValue = vt.PosSize4Shader;
                VOLUME_H_SLICES_BRUSH.GlobalValue        = vt.Slices4Shader;
                VOLUME_BRUSH_DIRECTION.GlobalValue       = stroke.collisionNormal.ToVector4(smoothing);

                UseSmoothing.Enabled = smoothing > 0;

                image.useTexCoord2 = false;
                bool alphaBuffer;

                TexMGMT.SHADER_STROKE_SEGMENT_UPDATE(bc, bc.Speed * 0.05f, image, stroke, out alphaBuffer, painter);

                stroke.SetWorldPosInShader();

                RenderTextureBuffersManager.Blit(null, image.CurrentRenderTexture(),
                                                 TexMGMT.brushRenderer.GetMaterial().shader);

                BrushTypes.Sphere.Inst.AfterStroke_Painter(painter, bc, stroke, alphaBuffer, image);

                return(true);
            }
            public void AfterCameraRender(RenderTexture texture)
            {
                var size = RenderTextureBuffersManager.tinyTextureSize;

                int pixelsCount = size * size;

                var tiny = RenderTextureBuffersManager.GetDownscaleOf(texture,
                                                                      RenderTextureBuffersManager.tinyTextureSize, true);

                var pix = RenderTextureBuffersManager.GetMinSizeTexture().CopyFrom(tiny).GetPixels();

                Color avg = Color.black;

                foreach (var p in pix)
                {
                    avg += p;
                }

                var pcam = PainterCamera.GetProjectorCamera();

                GlobalBrush.Color = avg / (float)pixelsCount;

                PainterShaderVariables.BrushColorProperty.GlobalValue = GlobalBrush.Color;

                PaintRenderTexture(delayedPaintingConfiguration);

                delayedPaintingConfiguration = null;
            }
            public void PaintRenderTexture(StrokeVector stroke, TextureMeta image, BrushConfig bc,
                                           PlaytimePainter painter)
            {
                var vt = painter.GetVolumeTexture();

                if (!vt)
                {
                    Debug.LogError("Painted volume was not found");
                    return;
                }

                if (_enableRayTracing)
                {
                    rayTraceCameraConfiguration.From(stroke);

                    bc.useAlphaBuffer = false;

                    delayedPaintingConfiguration = new BrushStrokePainterImage(stroke, image, bc, painter);

                    PainterCamera.GetProjectorCamera().RenderRightNow(this);
                }
                else
                {
                    PaintRenderTexture(new BrushStrokePainterImage(stroke, image, bc, painter));
                }
            }