public override void AfterGpuStroke(BrushConfig br, StrokeVector st, BrushTypes.Base type)
{
if (br.IsA3DBrush(painter) && painter.IsAtlased())
{
PainterShaderVariables.BRUSH_ATLAS_SECTION_AND_ROWS.GlobalValue = new Vector4(0, 0, 1, 0);
}
}
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));
}
}
public bool IsA3DBrush(PlaytimePainter painter, BrushConfig bc, ref bool overrideOther)
{
if (!painter.GetVolumeTexture())
{
return(false);
}
overrideOther = true;
return(true);
}
public override void BeforeGpuStroke(BrushConfig br, StrokeVector st, BrushTypes.Base type)
{
if (!br.IsA3DBrush(painter) || !painter.IsAtlased())
{
return;
}
var ats = GetAtlasedSection();
PainterShaderVariables.BRUSH_ATLAS_SECTION_AND_ROWS.GlobalValue = new Vector4(ats.x, ats.y, atlasRows, 1);
}
public override bool MouseEventPointedTriangle()
{
if ((EditorInputManager.GetMouseButton(0)))
{
if (PointedTriangle.SameAsLastFrame)
{
return(true);
}
BrushConfig bcf = Cfg.brushConfig;
foreach (var uv in PointedTriangle.vertexes)
{
//bcf.colorLinear.ToV4(ref uv.meshPoint.shadowBake, bcf.mask);
bcf.mask.SetValuesOn(ref uv.meshPoint.shadowBake, bcf.Color);
}
EditedMesh.Dirty = true;
return(true);
}
return(false);
}
public bool BrushConfigPEGI(ref bool overrideBlitMode, BrushConfig br)
{
var changed = false;
var p = InspectedPainter;
var volTex = p.GetVolumeTexture();
if (volTex)
{
var tex = volTex.texture;
if (tex)
{
"Volume is a {0} texture".F(tex.IsColorTexture() ? "Color" : "Non-Color Data").write();
#if UNITY_EDITOR
if (tex.IsColorTexture())
{
pegi.nl();
var imp = tex.GetTextureImporter();
if ((imp != null) && "FIX texture".Click() && (imp.WasWrongIsColor(false)))
{
imp.SaveAndReimport();
}
}
#endif
pegi.nl();
}
else
{
"Volume has no texture".writeWarning();
}
overrideBlitMode = true;
var id = p.TexMeta;
var cpuBlit = id.TargetIsTexture2D().nl();
br.showingSize = !_enableRayTracing || cpuBlit;
if (!cpuBlit)
{
if (BrushConfig.showAdvanced || _enableRayTracing)
{
"Ray-Tracing".toggleIcon(ref _enableRayTracing, true).changes(ref changed);
if (br.useAlphaBuffer)
{
icon.Warning.write(
"Ray Tracing doesn't use Alpha buffer. Alpha buffer will be automatically disabled");
}
}
if ("Ray Trace Camera".conditional_enter(
_enableRayTracing && PainterCamera.depthProjectorCamera,
ref _exploreRayTaceCamera).nl_ifFoldedOut())
{
"Min".edit(40, ref minFov, 60, maxFov - 1).nl(ref changed);
"Max".edit(40, ref maxFov, minFov + 1, 170).nl(ref changed);
rayTraceCameraConfiguration.Nested_Inspect().nl(ref changed);
}
if (smoothing > 0 || BrushConfig.showAdvanced)
{
pegi.nl();
"Smoothing".edit(70, ref smoothing, 0, 1).changes(ref changed);
"Best used in the end".fullWindowDocumentationClickOpen();
pegi.nl();
}
if (!_exploreRayTaceCamera && _enableRayTracing)
{
var dp = PainterCamera.depthProjectorCamera;
if (!dp)
{
if ("Create Projector Camera".Click().nl())
{
PainterCamera.GetProjectorCamera();
}
}
else if (dp.pauseAutoUpdates)
{
pegi.nl();
"Light Projectors paused".toggleIcon(ref dp.pauseAutoUpdates).nl(ref changed);
}
pegi.nl();
}
}
if (!cpuBlit)
{
pegi.nl();
if (!br.GetBrushType(false).IsAWorldSpaceBrush)
{
"Only World space brush can edit volumes".writeHint();
pegi.nl();
if ("Change to Sphere brush".Click())
{
br.SetBrushType(false, BrushTypes.Sphere.Inst);
}
}
}
pegi.nl();
if (!_exploreRayTaceCamera && PainterCamera.Data.showVolumeDetailsInPainter &&
(volTex.name + " " + VolumeEditingExtensions.VolumeSize(id.texture2D, volTex.hSlices))
.foldout(ref _exploreVolumeData).nl())
{
volTex.Nested_Inspect().changes(ref changed);
if (volTex.NeedsToManageMaterials)
{
var painterMaterial = InspectedPainter.Material;
if (painterMaterial)
{
if (!volTex.materials.Contains(painterMaterial))
{
if ("Add This Material".Click().nl())
{
volTex.AddIfNew(p);
}
}
}
}
}
if (!cpuBlit)
{
MsgPainter.Hardness.GetText()
.edit(MsgPainter.Hardness.GetDescription(), 70, ref br.hardness, 1f, 5f).nl(ref changed);
}
var tmpSpeed = br._dSpeed.Value;
if (MsgPainter.Speed.GetText().edit(40, ref tmpSpeed, 0.01f, 4.5f).nl(ref changed))
{
br._dSpeed.Value = tmpSpeed;
}
if (br.showingSize)
{
var maxScale = volTex.size * volTex.Width * 4;
"Scale:".edit(40, ref br.brush3DRadius, 0.001f * maxScale, maxScale * 0.5f)
.changes(ref changed);
if (cpuBlit && !_brushShaderFroRayTrace && br.brush3DRadius > BrushScaleMaxForCpu(volTex))
{
icon.Warning.write(
"Size will be reduced when panting due to low performance of the CPU brush for volumes");
}
}
pegi.nl();
}
return(changed);
}
public bool IsEnabledFor(PlaytimePainter painter, TextureMeta img, BrushConfig cfg) => img.GetVolumeTextureController();
public void PaintPixelsInRam(StrokeVector stroke, float brushAlpha, TextureMeta image, BrushConfig bc,
PlaytimePainter painter)
{
var volume = image.texture2D.GetVolumeTextureData();
if (!volume)
{
return;
}
bc.brush3DRadius = Mathf.Min(BrushScaleMaxForCpu(volume), bc.brush3DRadius);
var volumeScale = volume.size;
var pos = (stroke.posFrom - volume.transform.position) / volumeScale + 0.5f * Vector3.one;
var height = volume.Height;
var texWidth = image.width;
BlitFunctions.brAlpha = brushAlpha;
bc.PrepareCpuBlit(image);
BlitFunctions.half = bc.Size(true) / volumeScale;
var pixels = image.Pixels;
var iHalf = (int)(BlitFunctions.half - 0.5f);
var smooth = bc.GetBrushType(true) != BrushTypes.Pixel.Inst;
if (smooth)
{
iHalf += 1;
}
BlitFunctions.alphaMode = BlitFunctions.SphereAlpha;
var sliceWidth = texWidth / volume.hSlices;
var hw = sliceWidth / 2;
var y = (int)pos.y;
var z = (int)(pos.z + hw);
var x = (int)(pos.x + hw);
for (BlitFunctions.y = -iHalf; BlitFunctions.y < iHalf + 1; BlitFunctions.y++)
{
var h = y + BlitFunctions.y;
if (h >= height)
{
return;
}
if (h < 0)
{
continue;
}
var hy = h / volume.hSlices;
var hx = h % volume.hSlices;
var hTexIndex = (hy * texWidth + hx) * sliceWidth;
for (BlitFunctions.z = -iHalf; BlitFunctions.z < iHalf + 1; BlitFunctions.z++)
{
var trueZ = z + BlitFunctions.z;
if (trueZ < 0 || trueZ >= sliceWidth)
{
continue;
}
var yTexIndex = hTexIndex + trueZ * texWidth;
for (BlitFunctions.x = -iHalf; BlitFunctions.x < iHalf + 1; BlitFunctions.x++)
{
if (!BlitFunctions.alphaMode())
{
continue;
}
var trueX = x + BlitFunctions.x;
if (trueX < 0 || trueX >= sliceWidth)
{
continue;
}
var texIndex = yTexIndex + trueX;
BlitFunctions.blitMode(ref pixels[texIndex]);
}
}
}
}
public bool PaintTexture2D(StrokeVector stroke, float brushAlpha, TextureMeta image, BrushConfig bc, PlaytimePainter painter)
{
if (!painter.IsAtlased())
{
return(false);
}
var uvCoords = stroke.uvFrom;
var atlasedSection = GetAtlasedSection();
sectorSize = image.width / atlasRows;
atlasSector.From(atlasedSection * sectorSize);
BlitFunctions.brAlpha = brushAlpha;
BlitFunctions.half = (bc.Size(false)) / 2;
var iHalf = Mathf.FloorToInt(BlitFunctions.half - 0.5f);
var smooth = bc.GetBrushType(true) != BrushTypes.Pixel.Inst;
if (smooth)
{
BlitFunctions.alphaMode = BlitFunctions.CircleAlpha;
}
else
{
BlitFunctions.alphaMode = BlitFunctions.NoAlpha;
}
BlitFunctions.blitMode = bc.GetBlitMode(true).BlitFunctionTex2D(image);
if (smooth)
{
iHalf += 1;
}
BlitFunctions.alpha = 1;
BlitFunctions.Set(bc.mask);
BlitFunctions.cSrc = bc.Color;
var tmp = image.UvToPixelNumber(uvCoords);
var fromX = tmp.x - iHalf;
tmp.y -= iHalf;
var pixels = image.Pixels;
for (BlitFunctions.y = -iHalf; BlitFunctions.y < iHalf + 1; BlitFunctions.y++)
{
tmp.x = fromX;
for (BlitFunctions.x = -iHalf; BlitFunctions.x < iHalf + 1; BlitFunctions.x++)
{
if (BlitFunctions.alphaMode())
{
var sx = tmp.x - atlasSector.x;
var sy = tmp.y - atlasSector.y;
sx %= sectorSize;
if (sx < 0)
{
sx += sectorSize;
}
sy %= sectorSize;
if (sy < 0)
{
sy += sectorSize;
}
BlitFunctions.blitMode(ref pixels[((atlasSector.y + sy)) * image.width + (atlasSector.x + sx)]);
}
tmp.x += 1;
}
tmp.y += 1;
}
return(true);
}
public virtual void AfterGpuStroke(BrushConfig br, StrokeVector st, BrushTypes.Base type)
{
}
public bool IsEnabledFor(PlaytimePainter painter, TextureMeta id, BrushConfig cfg) => painter.IsAtlased() && !id.TargetIsRenderTexture();
public bool BrushConfigPEGI(ref bool overrideBlitMode, BrushConfig br) => false;
public void PaintRenderTexture(StrokeVector stroke, TextureMeta image, BrushConfig bc,
PlaytimePainter painter)
{
}
public bool IsA3DBrush(PlaytimePainter painter, BrushConfig bc, ref bool overrideOther) => false;
public void PaintPixelsInRam(StrokeVector stroke, float brushAlpha, TextureMeta image, BrushConfig bc,
PlaytimePainter painter) =>
painter.GetModule <TileableAtlasingComponentModule>()
?.PaintTexture2D(stroke, brushAlpha, image, bc, painter);
