Пример #1
0
        public PlaytimePainter Paint(StrokeVector stroke, PlaytimePainter painter)
        {
            var imgData = painter.ImgMeta;

            if (imgData == null)
            {
                painter.InitIfNotInitialized();
                imgData = painter.ImgMeta;
                if (imgData == null)
                {
                    return(painter);
                }
            }

            var cpu       = imgData.TargetIsTexture2D();
            var brushType = GetBrushType(cpu);
            var blitMode  = GetBlitMode(cpu);

            blitMode.PrePaint(painter, this, stroke);

            if (cpu)
            {
                painter.RecordingMgmt();
                brushType.PaintToTexture2D(painter, this, stroke);
            }
            else
            {
                var materialData = painter.MatDta;

                if (!imgData.renderTexture && !TexMGMT.materialsUsingRenderTexture.Contains(materialData))
                {
                    TexMGMT.ChangeBufferTarget(imgData, materialData, painter.GetMaterialTextureProperty, painter);
                    painter.SetTextureOnMaterial(imgData);
                }

                var rendered = false;

                foreach (var pl in PainterSystemManagerModuleBase.BrushPlugins)
                {
                    if (pl.IsEnabledFor(painter, imgData, this))
                    {
                        pl.PaintRenderTexture(stroke, imgData, this, painter);
                        rendered = true;
                        break;
                    }
                }

                if (!painter.terrain || brushType.SupportedForTerrainRt)
                {
                    painter.RecordingMgmt();

                    if (!rendered)
                    {
                        brushType.PaintRenderTexture(painter, this, stroke);
                    }
                }
            }

            return(painter);
        }
Пример #2
0
        public void Paint(PaintCommand.UV command)
        {
            var imgData = command.TextureData;

            var cpu          = command.TextureData.TargetIsTexture2D();
            var brushType    = GetBrushType(cpu);
            var blitMode     = GetBlitMode(cpu);
            var isWorldSpace = command.Is3DBrush;

            var painterCommand = command as PaintCommand.ForPainterComponent;

            PlaytimePainter painter = painterCommand?.painter;

            blitMode.PrePaint(command);

            if (cpu)
            {
                if (painter)
                {
                    foreach (var module in imgData.Modules)
                    {
                        module.OnPainting(painter);
                    }
                }

                brushType.PaintPixelsInRam(command);
            }
            else
            {
                if (painter)
                {
                    var materialData = painter.MatDta;

                    if (!imgData.renderTexture && !TexMGMT.materialsUsingRenderTexture.Contains(materialData))
                    {
                        TexMGMT.ChangeBufferTarget(imgData, materialData, painter.GetMaterialTextureProperty(), painter);
                        painter.SetTextureOnMaterial(imgData);
                    }

                    var rendered = false;

                    foreach (var pl in CameraModuleBase.BrushPlugins)
                    {
                        if (pl.IsEnabledFor(painter, imgData, this))
                        {
                            pl.PaintRenderTextureUvSpace(command);
                            rendered = true;
                            break;
                        }
                    }

                    if (!painter.terrain || brushType.SupportedForTerrainRt)
                    {
                        foreach (var module in imgData.Modules)
                        {
                            module.OnPainting(painter);
                        }

                        if (!rendered)
                        {
                            if (isWorldSpace)
                            {
                                brushType.PaintRenderTextureInWorldSpace(command as PaintCommand.WorldSpace);
                            }
                            else
                            {
                                brushType.PaintRenderTextureUvSpace(command);
                            }
                        }
                    }
                }
                else
                {
                    if (isWorldSpace)
                    {
                        brushType.PaintRenderTextureInWorldSpace(command as PaintCommand.WorldSpace);
                    }
                    else
                    {
                        brushType.PaintRenderTextureUvSpace(command);
                    }
                }
            }
        }
Пример #3
0
        public PlaytimePainter Paint(StrokeVector stroke, PlaytimePainter pntr)
        {
            var id = pntr.ImgData;

            if (id == null)
            {
                pntr.InitIfNotInited();
                id = pntr.ImgData;
                if (id == null)
                {
                    return(pntr);
                }
            }


            var cpu = id.TargetIsTexture2D();
            var t   = Type(cpu);

            BlitMode.PrePaint(pntr, this, stroke);

            if (cpu)
            {
                pntr.RecordingMGMT();
                t.PaintToTexture2D(pntr, this, stroke);
            }
            else
            {
                var md = pntr.MatDta;

                if (id.renderTexture == null && !TexMGMT.materialsUsingTendTex.Contains(md))
                {
                    TexMGMT.ChangeBufferTarget(id, md, pntr.MaterialTexturePropertyName, pntr);
                    //materialsUsingTendTex.Add(md);
                    pntr.SetTextureOnMaterial(id);
                    //Debug.Log("Adding RT target");
                }

                bool rendered = false;

                foreach (var pl in TexMGMT.Plugins)
                {
                    if (pl.PaintRenderTexture(stroke, id, this, pntr))
                    {
                        rendered = true;
                        break;
                    }
                }

                if ((pntr.terrain != null) && (!t.SupportedForTerrain_RT))
                {
                    return(pntr);
                }

                pntr.RecordingMGMT();

                if (!rendered)
                {
                    t.PaintRenderTexture(pntr, this, stroke);
                }
            }

            return(pntr);
        }