// TODO@: expose now that Download necesarrily goes via the gpu (compute/pixel) ?
private float[] TextureToTensorDataCache(TensorShape shape)
{
float[] tensorDataCache = new float[shape.length];
bool flipY = flip == Flip.Y;
int batchOffset = 0;
int channelOffset = 0;
foreach (var tex in textures)
{
var channelWriteMask = TextureFormatUtils.FormatToChannelMask(tex, interpretPixelAsChannels);
var channelReadMap = TextureFormatUtils.FormatToChannelReadMap(tex, interpretPixelAsChannels);
FillCacheFromTexture(tensorDataCache, tex, batchOffset, channelOffset, channelWriteMask, channelReadMap,
flipY, scale, bias, shape);
if (interpretDepthAs == InterpretDepthAs.Batch)
{
batchOffset += 1;
}
else if (interpretDepthAs == InterpretDepthAs.Channels)
{
channelOffset += interpretPixelAsChannels;
}
}
return(tensorDataCache);
}
// ---------------------------------------------------------------------------------
internal ITensorData TextureToTensorData(TextureAsTensorData texData, string name)
{
var tensorData = new TextureTensorData(texData.shape, name, false);
Material material = new Material(PixelShaderSingleton.Instance.FindShader("Barracuda/TextureToTensor"));
material.SetVector("OdeclShape", new Vector4(texData.shape.batch, texData.shape.height, texData.shape.width, texData.shape.channels));
material.SetInt("_FlipY", texData.flip == TextureAsTensorData.Flip.Y ? 1 : 0);
material.SetVector("_Scale", texData.scale);
material.SetVector("_Bias", texData.bias);
Vector4 offsets = Vector4.zero;
foreach (var tex in texData.textures)
{
var texArr = tex as Texture2DArray;
var rt = tex as RenderTexture;
var texDepth = 1;
if (texArr)
{
texDepth = texArr.depth;
}
else if (rt)
{
texDepth = rt.volumeDepth;
}
material.SetTexture("Xtex2D", tex);
material.SetVector("_Pool", new Vector2(tex.width, tex.height));
material.SetVector("_Pad", offsets);
var channelWriteMask = TextureFormatUtils.FormatToChannelMask(tex, texData.interpretPixelAsChannels);
var channelReadMap = TextureFormatUtils.FormatToChannelReadMap(tex, texData.interpretPixelAsChannels);
material.SetVector("_ChannelWriteMask", new Vector4(channelWriteMask[0], channelWriteMask[1], channelWriteMask[2], channelWriteMask[3]));
material.SetVector("_ChannelReadMap", new Vector4(channelReadMap[0], channelReadMap[1], channelReadMap[2], channelReadMap[3]));
Graphics.Blit(null, tensorData.bufferAsTexture, material);
if (texData.interpretDepthAs == TextureAsTensorData.InterpretDepthAs.Batch)
{
offsets[0] += texDepth;
}
else if (texData.interpretDepthAs == TextureAsTensorData.InterpretDepthAs.Channels)
{
offsets[3] += texDepth * texData.interpretPixelAsChannels;
}
}
return(tensorData);
}
internal void OnPostprocessTexture(Texture2D tex)
{
TextureImporter impl = assetImporter as TextureImporter;
if (impl)
{
string ext = Path.GetExtension(assetPath);
if (string.IsNullOrEmpty(ext) || !SUPPORT_EXTENTIONS.Contains(ext))
{
AssetDatabase.DeleteAsset(assetPath);
EditorUtility.DisplayDialog("error",
"the pic @ " + assetPath + " deleted, the game support png and tga only", "OK");
return;
}
if (TextureFormatUtils.isReimporting)
{
return;
}
if (impl && impl.textureType == TextureImporterType.Sprite)
{
TextureFormatUtils.SetUITexture(impl);
}
}
}
/// <summary>
/// Create `TextureAsTensorData` from supplied `textures`
/// </summary>
/// <param name="textures">backing textures</param>
/// <param name="interpretPixelAsChannels">interpret pixel as channels</param>
/// <param name="flip">flip</param>
/// <param name="depthAs">depth as</param>
/// <param name="colorAs">color as</param>
/// <param name="scale">multiplies `scale` to texture values</param>
/// <param name="bias">substracts `bias` from texture values</param>
/// <exception cref="ArgumentException">thrown if textures array is empty or texture types are different</exception>
/// <exception cref="InvalidOperationException">thrown if unsupported texture type is supplied</exception>
public TextureAsTensorData(Texture[] textures,
Flip flip, InterpretDepthAs depthAs, InterpretColorAs colorAs, Vector4 scale, Vector4 bias,
int interpretPixelAsChannels)
{
if (textures.Length < 1)
{
throw new ArgumentException("Textures array must be non empty");
}
if (interpretPixelAsChannels < 0)
{
interpretPixelAsChannels = TextureFormatUtils.FormatToChannelCount(textures[0]);
// check that all textures have the same number of channels
foreach (var tex in textures)
{
if (interpretPixelAsChannels != TextureFormatUtils.FormatToChannelCount(tex))
{
throw new ArgumentException("All textures must have the same number of channels");
}
}
}
m_InterpretPixelAsChannels = interpretPixelAsChannels;
m_InterpretDepthAs = depthAs;
m_InterpretColorAs = colorAs;
m_Flip = flip;
m_scale = scale;
m_bias = bias;
var width = textures[0].width;
var height = textures[0].height;
var totalDepth = 0;
foreach (var tex in textures)
{
if (tex.width != width || tex.height != height)
{
throw new ArgumentException("All textures must have the same width and height dimensions");
}
var tex2D = tex as Texture2D;
var texArr = tex as Texture2DArray;
var tex3D = tex as Texture3D;
var rt = tex as RenderTexture;
if (tex2D)
{
totalDepth += 1;
}
else if (texArr)
{
totalDepth += texArr.depth;
}
else if (tex3D)
{
totalDepth += tex3D.depth;
}
else if (rt)
{
totalDepth += rt.volumeDepth;
}
else
{
throw new InvalidOperationException("Unsupported texture type");
}
}
m_Textures = textures;
int batch = 1;
int channels = interpretPixelAsChannels;
if (m_InterpretDepthAs == InterpretDepthAs.Batch)
{
batch *= totalDepth;
}
else if (m_InterpretDepthAs == InterpretDepthAs.Channels)
{
channels *= totalDepth;
}
m_Shape = new TensorShape(batch, height, width, channels);
}
