public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.Hair)
{
if (m_HairBake != null)
{
return(m_HairBake);
}
m_HairBake = CreateTargetBakeImage(target);
Rectangle bakeRectangle = GetTargetBakeDimensions(target);
using (Graphics gfx = Graphics.FromImage(m_HairBake))
{
gfx.CompositingMode = CompositingMode.SourceCopy;
using (var brush = new SolidBrush(Color.FromArgb(0, 255, 255, 255)))
{
gfx.FillRectangle(brush, bakeRectangle);
}
/* alpha blending */
gfx.CompositingMode = CompositingMode.SourceOver;
Image img;
if (m_HairTextureId != UUID.Zero && cache.TryGetTexture(m_HairTextureId, target, out img))
{
gfx.DrawTinted(bakeRectangle, img, m_HairColor);
}
}
return(m_HairBake);
}
return(null);
}
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.Eyes)
{
if (EyeBake != null)
{
return(EyeBake);
}
EyeBake = CreateTargetBakeImage(target);
using (Graphics gfx = Graphics.FromImage(EyeBake))
{
Rectangle bakeRectangle = GetTargetBakeDimensions(target);
using (var brush = new SolidBrush(Color.White))
{
gfx.FillRectangle(brush, bakeRectangle);
}
Image img;
if (m_EyeTextureId != UUID.Zero && cache.TryGetTexture(m_EyeTextureId, target, out img))
{
gfx.DrawTinted(bakeRectangle, img, m_EyeColor);
}
}
return(EyeBake);
}
return(null);
}
public override byte[] BakeBumpOutput(IBakeTextureInputCache cache, BakeTarget target)
{
switch (target)
{
case BakeTarget.UpperBody:
if (m_UpperBump == null)
{
if (!cache.TryGetBump(m_UpperTextureId, target, out m_UpperBump))
{
m_UpperBump = BaseBakes.UpperBodyBump;
}
BlendBump(m_UpperBump, BaseBakes.JacketLengthUpperAlpha, m_JacketUpperLengthBump);
BlendBump(m_UpperBump, BaseBakes.JacketOpenUpperAlpha, m_JacketUpperOpenBump);
BlendBump(m_UpperBump, BaseBakes.ShirtSleeveAlpha, m_JacketSleeveLengthBump);
BlendBump(m_UpperBump, BaseBakes.ShirtCollarFrontAlpha, m_JacketCollarFrontBump);
BlendBump(m_UpperBump, BaseBakes.ShirtCollarBackAlpha, m_JacketCollarBackBump);
}
return(m_UpperBump);
case BakeTarget.LowerBody:
if (m_LowerBump == null)
{
if (!cache.TryGetBump(m_LowerTextureId, target, out m_LowerBump))
{
m_LowerBump = BaseBakes.LowerBodyBump;
}
BlendBump(m_LowerBump, BaseBakes.JacketLengthLowerAlpha, m_JacketLowerLengthBump);
BlendBump(m_LowerBump, BaseBakes.JacketOpenUpperAlpha, m_JacketLowerOpenBump);
}
return(m_LowerBump);
default:
return(null);
}
}
protected static Bitmap CreateTargetBakeImage(BakeTarget target)
{
if (target == BakeTarget.Eyes)
{
return(new Bitmap(128, 128, PixelFormat.Format32bppArgb));
}
else
{
return(new Bitmap(512, 512, PixelFormat.Format32bppArgb));
}
}
protected static Rectangle GetTargetBakeDimensions(BakeTarget target)
{
if (target == BakeTarget.Eyes)
{
return(new Rectangle(0, 0, 128, 128));
}
else
{
return(new Rectangle(0, 0, 512, 512));
}
}
public override byte[] BakeBumpOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.Skirt)
{
if (m_Bump == null && !cache.TryGetBump(m_TextureId, target, out m_Bump))
{
m_Bump = new byte[512 * 512];
}
return(m_Bump);
}
return(null);
}
protected static Bitmap CreateWhiteBakeImage(BakeTarget target)
{
int dimensions = target == BakeTarget.Eyes ? 128 : 512;
Bitmap bmp = new Bitmap(dimensions, dimensions, PixelFormat.Format32bppArgb);
using (Graphics gfx = Graphics.FromImage(bmp))
{
using (var b = new SolidBrush(System.Drawing.Color.White))
{
gfx.FillRectangle(b, new Rectangle(0, 0, dimensions, dimensions));
}
}
return(bmp);
}
public override ColorAlpha BakeImageColor(BakeTarget target)
{
switch (target)
{
case BakeTarget.UpperBody:
return((ColorAlpha)m_JacketUpperColor);
case BakeTarget.LowerBody:
return((ColorAlpha)m_JacketLowerColor);
default:
return(ColorAlpha.White);
}
}
public override byte[] BakeBumpOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.LowerBody)
{
if (m_LowerBump == null)
{
if (!cache.TryGetBump(m_TextureId, target, out m_LowerBump))
{
m_LowerBump = BaseBakes.LowerBodyBump;
}
BlendBump(m_LowerBump, BaseBakes.ShoeHeightAlpha, m_SocksLengthBump);
}
return(m_LowerBump);
}
return(null);
}
public override byte[] BakeBumpOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.UpperBody)
{
if (m_BumpGloves == null)
{
if (!cache.TryGetBump(m_GlovesTextureId, target, out m_BumpGloves))
{
m_BumpGloves = BaseBakes.UpperBodyBump;
}
BlendBump(m_BumpGloves, BaseBakes.GlovesFingersAlpha, m_GlovesFingersBump);
BlendBump(m_BumpGloves, BaseBakes.GlovesLengthAlpha, m_GlovesLengthBump);
}
return(m_BumpGloves);
}
return(null);
}
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.LowerBody)
{
if (m_LowerBake == null)
{
Image img;
m_LowerBake = cache.TryGetTexture(m_TextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
InsideAlphaBlend(m_LowerBake, (rawdata) =>
{
BlendAlpha(rawdata, BaseBakes.ShoeHeightAlpha, m_ShoeHeight);
});
}
return(m_LowerBake);
}
return(null);
}
public override byte[] BakeBumpOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.LowerBody)
{
if (m_PantsBump == null)
{
if (!cache.TryGetBump(m_PantsTextureId, target, out m_PantsBump))
{
m_PantsBump = BaseBakes.LowerBodyBump;
MultiplyBump(m_PantsBump, m_Displace);
}
BlendBump(m_PantsBump, BaseBakes.PantsLengthAlpha, m_LengthBump);
BlendBump(m_PantsBump, BaseBakes.PantsWaistAlpha, m_WaistBump);
}
return(m_PantsBump);
}
return(null);
}
public bool TryGetTexture(UUID textureID, BakeTarget bakeType, out Image img)
{
if (textureID == UUID.Zero)
{
img = null;
return(false);
}
int targetDimension;
Dictionary <UUID, Image> resizeCache;
if (bakeType == BakeTarget.Eyes)
{
resizeCache = m_TexturesResized128;
targetDimension = 128;
}
else
{
resizeCache = m_TexturesResized512;
targetDimension = 512;
}
/* do not redo the hard work of rescaling images unnecessarily */
if (resizeCache.TryGetValue(textureID, out img))
{
return(true);
}
TryLoadTexture(textureID);
if (m_Textures.TryGetValue(textureID, out img))
{
if (img.Width != targetDimension || img.Height != targetDimension)
{
img = new Bitmap(img, targetDimension, targetDimension);
resizeCache.Add(textureID, img);
}
return(true);
}
img = null;
return(false);
}
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
Image img;
switch (target)
{
case BakeTarget.UpperBody:
if (m_UpperBake != null)
{
return(m_UpperBake);
}
m_UpperBake = cache.TryGetTexture(m_UpperTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
InsideAlphaBlend(m_UpperBake, (rawdata) =>
{
BlendAlpha(rawdata, BaseBakes.JacketLengthUpperAlpha, m_JacketUpperLength);
BlendAlpha(rawdata, BaseBakes.JacketOpenUpperAlpha, m_JacketUpperOpen);
BlendAlpha(rawdata, BaseBakes.ShirtSleeveAlpha, m_JacketSleeveLength);
BlendAlpha(rawdata, BaseBakes.ShirtCollarFrontAlpha, m_JacketCollarFront);
BlendAlpha(rawdata, BaseBakes.ShirtCollarBackAlpha, m_JacketCollarBack);
});
break;
case BakeTarget.LowerBody:
if (m_LowerBake != null)
{
return(m_LowerBake);
}
m_LowerBake = cache.TryGetTexture(m_LowerTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
InsideAlphaBlend(m_UpperBake, (rawdata) =>
{
BlendAlpha(rawdata, BaseBakes.JacketLengthLowerAlpha, m_JacketLowerLength);
BlendAlpha(rawdata, BaseBakes.JacketOpenLowerAlpha, m_JacketLowerOpen);
});
break;
}
return(null);
}
public bool TryGetBump(UUID textureID, BakeTarget bakeType, out byte[] bump)
{
if (textureID == UUID.Zero)
{
bump = null;
return(false);
}
int targetDimension;
Dictionary <UUID, byte[]> resizeCache;
if (bakeType == BakeTarget.Eyes)
{
resizeCache = m_BumpsResized128;
targetDimension = 128;
}
else
{
resizeCache = m_BumpsResized512;
targetDimension = 512;
}
/* do not redo the hard work of rescaling images unnecessarily */
if (resizeCache.TryGetValue(textureID, out bump))
{
return(true);
}
TryLoadTexture(textureID);
if (m_Bumps.TryGetValue(textureID, out bump))
{
if (bump.Length != targetDimension * targetDimension)
{
bump = ResizeBump(bump, targetDimension);
resizeCache.Add(textureID, bump);
}
return(true);
}
bump = null;
return(false);
}
public override byte[] BakeBumpOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.UpperBody)
{
if (m_UpperBump == null)
{
if (!cache.TryGetBump(m_TextureId, target, out m_UpperBump))
{
m_UpperBump = BaseBakes.UpperBodyBump;
}
BlendBump(m_UpperBump, BaseBakes.ShirtSleeveAlpha, m_SleeveLengthBump);
BlendBump(m_UpperBump, BaseBakes.ShirtBottomAlpha, m_BottomLengthBump);
BlendBump(m_UpperBump, BaseBakes.ShirtCollarFrontAlpha, m_CollarFrontBump);
BlendBump(m_UpperBump, BaseBakes.ShirtCollarBackAlpha, m_CollarBackBump);
}
return(m_UpperBump);
}
return(null);
}
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.UpperBody)
{
if (m_BakeGloves != null)
{
return(m_BakeGloves);
}
Image img;
m_BakeGloves = cache.TryGetTexture(m_GlovesTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
InsideAlphaBlend(m_BakeGloves, (rawdata) =>
{
BlendAlpha(rawdata, BaseBakes.GlovesFingersAlpha, m_GlovesFingers);
BlendAlpha(rawdata, BaseBakes.GlovesLengthAlpha, m_GlovesLength);
});
}
return(null);
}
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.UpperBody)
{
if (m_UpperBake == null)
{
Image img;
m_UpperBake = cache.TryGetTexture(m_UpperTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
InsideAlphaBlend(m_UpperBake, (rawdata) =>
{
BlendAlpha(rawdata, BaseBakes.ShirtSleeveAlpha, m_SleeveLength);
BlendAlpha(rawdata, BaseBakes.ShirtBottomAlpha, m_BottomLength);
BlendAlpha(rawdata, BaseBakes.ShirtCollarFrontAlpha, m_CollarFrontHeight);
BlendAlpha(rawdata, BaseBakes.ShirtCollarBackAlpha, m_CollarBackHeight);
});
}
return(m_UpperBake);
}
return(null);
}
public override ColorAlpha BakeImageColor(BakeTarget target)
{
switch (target)
{
case BakeTarget.Hair:
return((ColorAlpha)m_TattooHairColor);
case BakeTarget.Head:
return((ColorAlpha)m_TattooHeadColor);
case BakeTarget.UpperBody:
return((ColorAlpha)m_TattooUpperColor);
case BakeTarget.LowerBody:
return((ColorAlpha)m_TattooLowerColor);
case BakeTarget.Eyes:
return((ColorAlpha)m_TattooEyesColor);
case BakeTarget.Skirt:
return((ColorAlpha)m_TattooSkirtColor);
case BakeTarget.LeftArm:
return((ColorAlpha)m_TattooLeftArmColor);
case BakeTarget.LeftLeg:
return((ColorAlpha)m_TattooLeftLegColor);
case BakeTarget.Aux1:
return((ColorAlpha)m_TattooAux1Color);
case BakeTarget.Aux2:
return((ColorAlpha)m_TattooAux2Color);
case BakeTarget.Aux3:
return((ColorAlpha)m_TattooAux3Color);
}
return(ColorAlpha.White);
}
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
if (target == BakeTarget.Skirt)
{
if (m_Bake == null)
{
Image img;
m_Bake = cache.TryGetTexture(m_TextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
InsideAlphaBlend(m_Bake, (rawdata) =>
{
BlendAlpha(rawdata, BaseBakes.SkirtLengthAlpha, m_SkirtLength);
BlendAlpha(rawdata, BaseBakes.SkirtSlitBackAlpha, m_SlitBack);
BlendAlpha(rawdata, BaseBakes.SkirtSlitFrontAlpha, m_SlitFront);
BlendAlpha(rawdata, BaseBakes.SkirtSlitLeftAlpha, m_SlitLeft);
BlendAlpha(rawdata, BaseBakes.SkirtSlitRightAlpha, m_SlitRight);
});
}
return(m_Bake);
}
return(null);
}
public virtual ColorAlpha BakeImageColor(BakeTarget target) => ColorAlpha.White;
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
Image img;
if (target == BakeTarget.Head)
{
if (HeadBake != null)
{
return(HeadBake);
}
Rectangle bakeRectangle = GetTargetBakeDimensions(target);
HeadBake = CreateTargetBakeImage(target);
using (Graphics gfx = Graphics.FromImage(HeadBake))
{
using (var brush = new SolidBrush(m_SkinColor.ToDrawing()))
{
gfx.FillRectangle(brush, bakeRectangle);
}
gfx.CompositingMode = CompositingMode.SourceOver;
gfx.DrawUntinted(bakeRectangle, BaseBakes.HeadColorAndSkinGrain);
if (m_HeadTextureId != UUID.Zero && cache.TryGetTexture(m_HeadTextureId, target, out img))
{
gfx.DrawUntinted(bakeRectangle, img);
}
else
{
/*
* gfx.DrawColorKeyed(bakeRectangle, BaseBakes.RosyfaceAlpha, m_RosyComplexionColor);
* gfx.DrawColorKeyed(bakeRectangle, BaseBakes.LipsMask, m_LipPinknessColor);
* gfx.DrawColorKeyed(bakeRectangle, BaseBakes.LipstickAlpha, m_LipstickColor);
* gfx.DrawColorKeyed(bakeRectangle, BaseBakes.EyelinerAlpha, m_EyelinerColor);
* gfx.DrawColorKeyed(bakeRectangle, BaseBakes.BlushAlpha, m_BlushColor);
* gfx.DrawColorKeyed(bakeRectangle, BaseBakes.InnershadowAlpha, m_InnershadowColor, m_Innershadow);
* gfx.DrawColorKeyed(bakeRectangle, BaseBakes.OutershadowAlpha, m_OutershadowColor, m_Outershadow);
*/
}
}
return(HeadBake);
}
else if (target == BakeTarget.LowerBody)
{
if (LowerBake != null)
{
return(LowerBake);
}
Rectangle bakeRectangle = GetTargetBakeDimensions(target);
LowerBake = CreateTargetBakeImage(target);
using (Graphics gfx = Graphics.FromImage(LowerBake))
{
using (var brush = new SolidBrush(m_SkinColor.ToDrawing()))
{
gfx.FillRectangle(brush, bakeRectangle);
}
gfx.DrawUntinted(bakeRectangle, BaseBakes.LowerBodyColorAndSkinGrain);
if (m_LowerTextureId != UUID.Zero && cache.TryGetTexture(m_LowerTextureId, target, out img))
{
gfx.DrawUntinted(bakeRectangle, img);
}
}
return(LowerBake);
}
else if (target == BakeTarget.UpperBody)
{
if (UpperBake != null)
{
return(UpperBake);
}
Rectangle bakeRectangle = GetTargetBakeDimensions(target);
UpperBake = CreateTargetBakeImage(target);
using (Graphics gfx = Graphics.FromImage(UpperBake))
{
using (var brush = new SolidBrush(m_SkinColor.ToDrawing()))
{
gfx.FillRectangle(brush, bakeRectangle);
}
gfx.DrawUntinted(bakeRectangle, BaseBakes.UpperBodyColorAndSkinGrain);
if (m_UpperTextureId != UUID.Zero && cache.TryGetTexture(m_UpperTextureId, target, out img))
{
gfx.DrawUntinted(bakeRectangle, img);
}
else
{
gfx.DrawColorKeyed(bakeRectangle, BaseBakes.NailpolishAlpha, m_NailpolishColor);
}
}
return(UpperBake);
}
else
{
return(null);
}
}
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
Image img;
switch (target)
{
case BakeTarget.Head:
if (HeadBake != null)
{
return(HeadBake);
}
if (cache.TryGetTexture(m_HeadTattooId, target, out img))
{
HeadBake = new Bitmap(img);
}
else
{
HeadBake = CreateTargetBakeImage(target);
using (Graphics gfx = Graphics.FromImage(HeadBake))
{
gfx.CompositingMode = CompositingMode.SourceCopy;
using (var b = new SolidBrush(Color.FromArgb(0, 0, 0, 0)))
{
gfx.FillRectangle(b, GetTargetBakeDimensions(target));
}
}
}
return(HeadBake);
case BakeTarget.UpperBody:
if (UpperBake != null)
{
return(UpperBake);
}
if (cache.TryGetTexture(m_UpperTattooId, target, out img))
{
UpperBake = new Bitmap(img);
}
else
{
UpperBake = CreateTargetBakeImage(target);
using (Graphics gfx = Graphics.FromImage(UpperBake))
{
gfx.CompositingMode = CompositingMode.SourceCopy;
using (var b = new SolidBrush(Color.FromArgb(0, 0, 0, 0)))
{
gfx.FillRectangle(b, GetTargetBakeDimensions(target));
}
}
}
return(UpperBake);
case BakeTarget.LowerBody:
if (LowerBake != null)
{
return(LowerBake);
}
if (cache.TryGetTexture(m_LowerTattooId, target, out img))
{
LowerBake = new Bitmap(img);
}
else
{
LowerBake = CreateTargetBakeImage(target);
using (Graphics gfx = Graphics.FromImage(LowerBake))
{
gfx.CompositingMode = CompositingMode.SourceCopy;
using (var b = new SolidBrush(Color.FromArgb(0, 0, 0, 0)))
{
gfx.FillRectangle(b, GetTargetBakeDimensions(target));
}
}
}
return(LowerBake);
}
return(null);
}
public override ColorAlpha BakeImageColor(BakeTarget target) => (ColorAlpha)m_Color;
/* * may return null if bake does not output an alpha mask */ public virtual Image BakeAlphaMaskOutput(IBakeTextureInputCache cache, BakeTarget target) => null;
public override Image BakeImageOutput(IBakeTextureInputCache cache, BakeTarget target)
{
switch (target)
{
case BakeTarget.Hair:
if (m_HairBake == null)
{
Image img;
m_HairBake = cache.TryGetTexture(m_TattooHairTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_HairBake);
case BakeTarget.Head:
if (m_HeadBake == null)
{
Image img;
m_HeadBake = cache.TryGetTexture(m_TattooHeadTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_HeadBake);
case BakeTarget.UpperBody:
if (m_UpperBake == null)
{
Image img;
m_UpperBake = cache.TryGetTexture(m_TattooUpperTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_UpperBake);
case BakeTarget.LowerBody:
if (m_LowerBake == null)
{
Image img;
m_LowerBake = cache.TryGetTexture(m_TattooLowerTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_LowerBake);
case BakeTarget.Eyes:
if (m_EyesBake == null)
{
Image img;
m_EyesBake = cache.TryGetTexture(m_TattooEyesTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_EyesBake);
case BakeTarget.Skirt:
if (m_SkirtBake == null)
{
Image img;
m_SkirtBake = cache.TryGetTexture(m_TattooSkirtTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_SkirtBake);
case BakeTarget.LeftArm:
if (m_LeftArmBake == null)
{
Image img;
m_LeftArmBake = cache.TryGetTexture(m_TattooLeftArmTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_LeftArmBake);
case BakeTarget.LeftLeg:
if (m_LeftLegBake == null)
{
Image img;
m_LeftLegBake = cache.TryGetTexture(m_TattooLeftLegTextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_LeftLegBake);
case BakeTarget.Aux1:
if (m_Aux1Bake == null)
{
Image img;
m_Aux1Bake = cache.TryGetTexture(m_TattooAux1TextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_Aux1Bake);
case BakeTarget.Aux2:
if (m_Aux2Bake == null)
{
Image img;
m_Aux2Bake = cache.TryGetTexture(m_TattooAux2TextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_Aux2Bake);
case BakeTarget.Aux3:
if (m_Aux3Bake == null)
{
Image img;
m_Aux3Bake = cache.TryGetTexture(m_TattooAux3TextureId, target, out img) ?
new Bitmap(img) : CreateWhiteBakeImage(target);
}
return(m_Aux3Bake);
}
return(null);
}
/* * may return null if bake does not output a bump */ public virtual byte[] BakeBumpOutput(IBakeTextureInputCache cache, BakeTarget target) => null;
public override byte[] BakeBumpOutput(IBakeTextureInputCache cache, BakeTarget target) => null;
public override Image BakeAlphaMaskOutput(IBakeTextureInputCache cache, BakeTarget target)
{
Image img;
switch (target)
{
case BakeTarget.Eyes:
if (m_EyesTextureId == UUID.Zero)
{
return(null);
}
if (m_EyesBake != null)
{
return(m_EyesBake);
}
if (cache.TryGetTexture(m_EyesTextureId, target, out img))
{
m_EyesBake = new Bitmap(img);
}
return(m_EyesBake);
case BakeTarget.Hair:
if (m_HairTextureId == UUID.Zero)
{
return(null);
}
if (m_HairBake != null)
{
return(m_HairBake);
}
if (cache.TryGetTexture(m_HairTextureId, target, out img))
{
m_HairBake = new Bitmap(img);
}
return(m_HairBake);
case BakeTarget.Head:
if (m_HeadTextureId == UUID.Zero)
{
return(null);
}
if (m_HeadBake != null)
{
return(m_HeadBake);
}
if (cache.TryGetTexture(m_HeadTextureId, target, out img))
{
m_HeadBake = new Bitmap(img);
}
return(m_HeadBake);
case BakeTarget.LowerBody:
if (m_LowerbodyTextureId == UUID.Zero)
{
return(null);
}
if (m_LowerbodyBake != null)
{
return(m_LowerbodyBake);
}
if (cache.TryGetTexture(m_LowerbodyTextureId, target, out img))
{
m_LowerbodyBake = new Bitmap(img);
}
return(m_LowerbodyBake);
case BakeTarget.UpperBody:
if (m_UpperbodyTextureId == UUID.Zero)
{
return(null);
}
if (m_UpperbodyBake != null)
{
return(m_UpperbodyBake);
}
if (cache.TryGetTexture(m_UpperbodyTextureId, target, out img))
{
m_UpperbodyBake = new Bitmap(img);
}
return(m_UpperbodyBake);
}
return(null);
}
