public static TextureInfo GetTextureInfo(string name, string filename)
{
TextureInfo ti = null;
if (texture_dict.TryGetValue(name, out ti))
{
return(ti);
}
if (string.IsNullOrEmpty(filename))
{
return(null);
}
FileInfo fi = new FileInfo(filename);
if (!fi.Exists)
{
return(null);
}
FileStream fs = fi.OpenRead();
var filesize = fs.Length;
byte[] content = new byte[filesize];
fs.Read(content, 0, (int)filesize);
TextureFormat format = TextureFormat.DXT1;
var extname = uEmuera.Utils.GetSuffix(filename).ToLower();
if (extname == "png")
{
format = TextureFormat.DXT5;
}
if (extname == "webp")
{
var tex = Texture2DExt.CreateTexture2DFromWebP(content, false, false,
out Error err);
if (err != Error.Success)
{
Debug.LogWarning($"{filename} {err.ToString()}");
return(null);
}
ti = new TextureInfo(name, tex);
texture_dict.Add(name, ti);
}
else
{
var tex = new Texture2D(4, 4, format, false);
if (tex.LoadImage(content))
{
ti = new TextureInfo(name, tex);
texture_dict.Add(name, ti);
}
}
return(ti);
}
private unsafe List <(Texture2D, int)> LoadAnimation(string loadPath)
{
List <(Texture2D, int)> ret = new List <(Texture2D, int)>();
TextAsset textasset = Resources.Load <TextAsset>(loadPath);
byte[] bytes = textasset.bytes;
WebPAnimDecoderOptions option = new WebPAnimDecoderOptions
{
use_threads = 1,
color_mode = (unity.libwebp.Interop.WEBP_CSP_MODE)WEBP_CSP_MODE.MODE_RGBA
};
NativeLibwebpdemux.WebPAnimDecoderOptionsInit(&option);
fixed(byte *p = bytes)
{
WebPData webpdata = new WebPData
{
bytes = p,
size = new UIntPtr((uint)bytes.Length)
};
WebPAnimDecoder *dec = NativeLibwebpdemux.WebPAnimDecoderNew(&webpdata, &option);
WebPAnimInfo anim_info = new WebPAnimInfo();
NativeLibwebpdemux.WebPAnimDecoderGetInfo(dec, &anim_info);
Debug.LogWarning($"{anim_info.frame_count} {anim_info.canvas_width}/{anim_info.canvas_height}");
int size = (int)anim_info.canvas_width * 4 * (int)anim_info.canvas_height;
dec->config_.options.flip = 1;
dec->config_.options.no_fancy_upsampling = 1;
int timestamp = 0;
IntPtr pp = new IntPtr();
byte **unmanagedPointer = (byte **)&pp;
for (int i = 0; i < anim_info.frame_count; ++i)
{
int result = NativeLibwebpdemux.WebPAnimDecoderGetNext(dec, unmanagedPointer, ×tamp);
Assert.AreEqual(1, result);
int lWidth = (int)anim_info.canvas_width;
int lHeight = (int)anim_info.canvas_height;
bool lMipmaps = false;
bool lLinear = false;
Texture2D texture = Texture2DExt.CreateWebpTexture2D(lWidth, lHeight, lMipmaps, lLinear);
texture.LoadRawTextureData(pp, size);
texture.Apply(updateMipmaps: false, makeNoLongerReadable: true);
ret.Add((texture, timestamp));
}
NativeLibwebpdemux.WebPAnimDecoderReset(dec);
NativeLibwebpdemux.WebPAnimDecoderDelete(dec);
}
return(ret);
}
void LoadWebp(RawImage image, byte[] bytes)
{
Error lError;
Texture2D texture = Texture2DExt.CreateTexture2DFromWebP(bytes, lMipmaps: true, lLinear: true, lError: out lError);
if (lError != Error.Success)
{
Debug.LogError("Webp Load Error : " + lError.ToString());
return;
}
image.texture = texture;
}
private void LoadTextureFromWebP(byte[] bytes)
{
Texture2D texture = Texture2DExt.CreateTexture2DFromWebP(bytes, lMipmaps: true, lLinear: true, lError: out Error lError);
if (lError == Error.Success)
{
_image.sprite = TextureUtils.CreateSpriteFromTexture(texture);
}
else
{
Debug.LogError(GetType() + ".LoadTextureFromWebP: WebP Load Error : " + lError.ToString());
}
}
public static Texture2D RefSharedWebpTexture(TextAsset webpAsset)
{
if (webpAsset == null)
{
return(null);
}
Texture2D sharedTexture = null;
string sharedTextureKey = webpAsset.GetInstanceID().ToString();
SharedWebpTextureEntry sharedWebpTextureEntry = GetSharedWebpTextureEntry(sharedTextureKey);
if (sharedWebpTextureEntry != null)
{
// The texture might be already GCed
if (sharedWebpTextureEntry.texture == null)
{
sharedWebpTextures.Remove(sharedWebpTextureEntry);
sharedWebpTextureEntry = null;
}
}
if (sharedWebpTextureEntry != null)
{
sharedWebpTextureEntry.refCount++;
sharedTexture = sharedWebpTextureEntry.texture;
}
else
{
Status lError;
sharedTexture = Texture2DExt.CreateTexture2DFromWebP(webpAsset.bytes, false, true, out lError, Texture2DExt.ScaleBy(1f));
if (lError != Status.SUCCESS)
{
// Debug.LogError ("SharedWebpTexture::RefSharedAlphaMaterial Webp Load Error : " + lError.ToString ());
return(null);
}
sharedWebpTextureEntry = new SharedWebpTextureEntry()
{
assetId = sharedTextureKey,
texture = sharedTexture,
refCount = 1
};
sharedWebpTextures.Add(sharedWebpTextureEntry);
}
return(sharedTexture);
}
void LoadWebp(RawImage image)
{
var textasset = Resources.Load <TextAsset>("webp");
var bytes = textasset.bytes;
Texture2D texture = Texture2DExt.CreateTexture2DFromWebP(bytes, lMipmaps: true, lLinear: true, lError: out Error lError);
if (lError == Error.Success)
{
image.texture = texture;
}
else
{
Debug.LogError("Webp Load Error : " + lError.ToString());
}
}
//------------------------------------------------------------------------------------------------------------
private IEnumerator StartWebPExample()
{
var lWebStream = new WWW(@"http://cdn.octo-dev.co.uk/octo/image01.webp");
yield return(lWebStream);
Error lError;
Texture2D lTexture2D = Texture2DExt.CreateTexture2DFromWebP(lWebStream.bytes, true, true, out lError);
if (lError == Error.Success)
{
m_Material.mainTexture = lTexture2D;
}
else
{
Debug.LogError("Webp Load Error : " + lError.ToString());
}
}
void LoadWebpUsingPool(RawImage image)
{
byte[] bytePool = new byte[1024 * 1024 * 10];
var textasset = Resources.Load <TextAsset>("webp");
var webpBytes = textasset.bytes;
Texture2DExt.GetWebPDimensions(webpBytes, out int width, out int height);
Texture2D texture = Texture2DExt.CreateWebpTexture2D(width, height, isUseMipmap: true, isLinear: true);
image.texture = texture;
int numBytesRequired = Texture2DExt.GetRequireByteSize(width, height, isUseMipmap: true);
Debug.Assert(bytePool.Length >= numBytesRequired);
Texture2DExt.LoadTexture2DFromWebP(webpBytes, texture, lMipmaps: true, lLinear: true, bytePool, numBytesRequired);
}
public Texture2D LoadWebp()
{
Texture2D result = null;
byte[] bytes = File.ReadAllBytes("Assets/unpacked/base.webp");
//byte[] bytes = textasset.bytes;
Error _error;
result = Texture2DExt.CreateTexture2DFromWebP(bytes, true, true, out _error);
if (_error == Error.Success)
{
GetComponent <SpriteRenderer>().sprite = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), new Vector2(0.5f, 0.5f));
return(result);
}
else
{
return(null);
}
}
private unsafe List <(Texture2D, int)> LoadAnimation(string loadPath)
{
List <(Texture2D, int)> ret = new List <(Texture2D, int)>();
TextAsset textasset = Resources.Load <TextAsset>(loadPath);
byte[] bytes = textasset.bytes;
WebPAnimDecoderOptions option = new WebPAnimDecoderOptions
{
use_threads = 1,
color_mode = WEBP_CSP_MODE.MODE_RGBA,
};
option.padding[5] = 1;
NativeLibwebpdemux.WebPAnimDecoderOptionsInit(&option);
fixed(byte *p = bytes)
{
WebPData webpdata = new WebPData
{
bytes = p,
size = new UIntPtr((uint)bytes.Length)
};
WebPAnimDecoder *dec = NativeLibwebpdemux.WebPAnimDecoderNew(&webpdata, &option);
//dec->config_.options.flip = 1;
WebPAnimInfo anim_info = new WebPAnimInfo();
NativeLibwebpdemux.WebPAnimDecoderGetInfo(dec, &anim_info);
Debug.LogWarning($"{anim_info.frame_count} {anim_info.canvas_width}/{anim_info.canvas_height}");
uint size = anim_info.canvas_width * 4 * anim_info.canvas_height;
int timestamp = 0;
IntPtr pp = new IntPtr();
byte **unmanagedPointer = (byte **)&pp;
for (int i = 0; i < anim_info.frame_count; ++i)
{
int result = NativeLibwebpdemux.WebPAnimDecoderGetNext(dec, unmanagedPointer, ×tamp);
Assert.AreEqual(1, result);
int lWidth = (int)anim_info.canvas_width;
int lHeight = (int)anim_info.canvas_height;
bool lMipmaps = false;
bool lLinear = false;
Texture2D texture = Texture2DExt.CreateWebpTexture2D(lWidth, lHeight, lMipmaps, lLinear);
texture.LoadRawTextureData(pp, (int)size);
{// Flip updown.
// ref: https://github.com/netpyoung/unity.webp/issues/25
// ref: https://github.com/netpyoung/unity.webp/issues/21
// ref: https://github.com/webmproject/libwebp/blob/master/src/demux/anim_decode.c#L309
Color[] pixels = texture.GetPixels();
Color[] pixelsFlipped = new Color[pixels.Length];
for (int y = 0; y < anim_info.canvas_height; y++)
{
Array.Copy(pixels, y * anim_info.canvas_width, pixelsFlipped, (anim_info.canvas_height - y - 1) * anim_info.canvas_width, anim_info.canvas_width);
}
texture.SetPixels(pixelsFlipped);
}
texture.Apply();
ret.Add((texture, timestamp));
}
NativeLibwebpdemux.WebPAnimDecoderReset(dec);
NativeLibwebpdemux.WebPAnimDecoderDelete(dec);
}
return(ret);
}
static IEnumerator Loading(Bitmap baseimage)
{
TextureInfo ti = null;
FileInfo fi = new FileInfo(baseimage.path);
if (fi.Exists)
{
FileStream fs = fi.OpenRead();
var filesize = fs.Length;
byte[] content = new byte[filesize];
var async = fs.BeginRead(content, 0, (int)filesize, null, null);
while (!async.IsCompleted)
{
yield return(null);
}
TextureFormat format = TextureFormat.DXT1;
var extname = uEmuera.Utils.GetSuffix(baseimage.path).ToLower();
if (extname == "png")
{
format = TextureFormat.DXT5;
}
if (extname == "webp")
{
var tex = Texture2DExt.CreateTexture2DFromWebP(content, false, false,
out Error err);
if (err != Error.Success)
{
Debug.LogWarning($"{baseimage.path} {err.ToString()}");
yield break;
}
ti = new TextureInfo(baseimage.filename, tex);
texture_dict.Add(baseimage.filename, ti);
baseimage.size.Width = tex.width;
baseimage.size.Height = tex.height;
}
else
{
var tex = new Texture2D(4, 4, format, false);
if (tex.LoadImage(content))
{
ti = new TextureInfo(baseimage.filename, tex);
texture_dict.Add(baseimage.filename, ti);
baseimage.size.Width = tex.width;
baseimage.size.Height = tex.height;
}
}
}
List <CallbackInfo> list = null;
if (loading_set.TryGetValue(baseimage.filename, out list))
{
var count = list.Count;
CallbackInfo item = null;
for (int i = 0; i < count; ++i)
{
item = list[i];
item.DoCallback(GetSpriteInfo(ti, item.src));
}
list.Clear();
loading_set.Remove(baseimage.filename);
}
}
private unsafe List <(Texture2D, int)> LoadAnimation2(string loadPath)
{
List <ValueTuple <Texture2D, int> > ret = new List <ValueTuple <Texture2D, int> >();
TextAsset textasset = Resources.Load <TextAsset>(loadPath);
byte[] bytes = textasset.bytes;
WebPDecoderConfig config = new WebPDecoderConfig();
if (NativeLibwebp.WebPInitDecoderConfig(&config) == 0)
{
throw new Exception("WebPInitDecoderConfig failed. Wrong version?");
}
WebPIterator iter = new WebPIterator();
fixed(byte *p = bytes)
{
WebPData webpdata = new WebPData
{
bytes = p,
size = new UIntPtr((uint)bytes.Length)
};
WebPDemuxer *webPDemuxer = NativeLibwebpdemux.WebPDemuxInternal(&webpdata, 0, (WebPDemuxState *)IntPtr.Zero, NativeLibwebpdemux.WEBP_DEMUX_ABI_VERSION);
VP8StatusCode result = NativeLibwebp.WebPGetFeatures(webpdata.bytes, webpdata.size, &config.input);
if (result != VP8StatusCode.VP8_STATUS_OK)
{
throw new Exception(string.Format("Failed WebPGetFeatures with error {0}.", result.ToString()));
}
int height = config.input.height;
int width = config.input.height;
config.options.bypass_filtering = 0;
config.options.use_threads = 1;
config.options.no_fancy_upsampling = 0;
config.options.use_cropping = 0;
config.options.use_scaling = 1;
config.options.scaled_width = width;
config.options.scaled_height = height;
config.options.flip = 1;
config.options.dithering_strength = 0;
config.output.colorspace = WEBP_CSP_MODE.MODE_RGBA;
config.output.width = width;
config.output.height = height;
//byte[] bbb = new byte[width * height];
//fixed (byte* ppp = bbb)
//{
// config.output.u.RGBA.rgba = (IntPtr)ppp;
//}
//config.output.u.RGBA.stride = width * 4;
//config.output.u.RGBA.size = (UIntPtr)(width * height);
//config.output.is_external_memory = 1;
//config.output.is_external_memory = 1;
int success = NativeLibwebpdemux.WebPDemuxGetFrame(webPDemuxer, 1, &iter);
if (success != 1)
{
return(ret);
}
int timestamp = 0;
int size = width * height * 4;
do
{
WebPData frame = iter.fragment;
VP8StatusCode status = NativeLibwebp.WebPDecode(frame.bytes, frame.size, &config);
if (status != VP8StatusCode.VP8_STATUS_OK)
{
Debug.LogError(status);
break;
}
Texture2D texture = Texture2DExt.CreateWebpTexture2D(width, height, isUseMipmap: false, isLinear: false);
texture.LoadRawTextureData((IntPtr)config.output.u.RGBA.rgba, size);
texture.Apply(updateMipmaps: false, makeNoLongerReadable: true);
timestamp += iter.duration;
ret.Add((texture, timestamp));
}while (NativeLibwebpdemux.WebPDemuxNextFrame(&iter) == 1);
NativeLibwebpdemux.WebPDemuxDelete(webPDemuxer);
NativeLibwebpdemux.WebPDemuxReleaseIterator(&iter);
}
return(ret);
}
private unsafe List <(Texture2D, int)> LoadAnimation3(string loadPath)
{
List <ValueTuple <Texture2D, int> > ret = new List <ValueTuple <Texture2D, int> >();
TextAsset textasset = Resources.Load <TextAsset>(loadPath);
byte[] bytes = textasset.bytes;
WebPAnimDecoderOptions option = new WebPAnimDecoderOptions
{
use_threads = 1,
color_mode = (unity.libwebp.Interop.WEBP_CSP_MODE)WEBP_CSP_MODE.MODE_RGBA
};
unity.libwebp.Interop.WebPDecoderConfig config = new unity.libwebp.Interop.WebPDecoderConfig();
//if (Decode.WebPInitDecoderConfig(ref config) == 0)
//{
// throw new Exception("WebPInitDecoderConfig failed. Wrong version?");
//}
NativeLibwebpdemux.WebPAnimDecoderOptionsInit(&option);
fixed(byte *p = bytes)
{
WebPData webpdata = new WebPData
{
bytes = p,
size = new UIntPtr((uint)bytes.Length)
};
WebPAnimDecoderOptions opt = new WebPAnimDecoderOptions();
NativeLibwebpdemux.WebPAnimDecoderOptionsInit(&opt);
WebPAnimDecoder *webPAnimDecoderPtr = NativeLibwebpdemux.WebPAnimDecoderNewInternal(&webpdata, &opt, NativeLibwebpdemux.WEBP_DEMUX_ABI_VERSION);
//int width = 400;
//int height = 400;
{
//config.input.has_alpha = 1;
//config.options.bypass_filtering = 1;
//config.options.no_fancy_upsampling = 1;
config.options.use_threads = 1;
//config.options.no_fancy_upsampling = 0;
//config.options.use_cropping = 0;
//config.options.use_scaling = 1;
//config.options.scaled_width = width;
//config.options.scaled_height = height;
config.options.flip = 1;
//config.options.dithering_strength = 100;
config.output.colorspace = (unity.libwebp.Interop.WEBP_CSP_MODE)WEBP_CSP_MODE.MODE_RGBA;
//config.output.is_external_memory = 1;
//config.output.width = width;
//config.output.height = height;
}
webPAnimDecoderPtr->config_ = config;
WebPAnimInfo anim_info = new WebPAnimInfo();
NativeLibwebpdemux.WebPAnimDecoderGetInfo(webPAnimDecoderPtr, &anim_info);
Debug.LogWarning($"{anim_info.frame_count} {anim_info.canvas_width}/{anim_info.canvas_height}");
int size = (int)anim_info.canvas_width * 4 * (int)anim_info.canvas_height;
int timestamp = 0;
IntPtr pp = new IntPtr();
byte **unmanagedPointer = (byte **)&pp;
for (int i = 0; i < anim_info.frame_count; ++i)
{
int result = NativeLibwebpdemux.WebPAnimDecoderGetNext(webPAnimDecoderPtr, unmanagedPointer, ×tamp);
int lWidth = (int)anim_info.canvas_width;
int lHeight = (int)anim_info.canvas_height;
bool lMipmaps = false;
bool lLinear = false;
Texture2D texture = Texture2DExt.CreateWebpTexture2D(lWidth, lHeight, lMipmaps, lLinear);
texture.LoadRawTextureData((IntPtr)unmanagedPointer, size);
texture.Apply(updateMipmaps: false, makeNoLongerReadable: true);
ret.Add((texture, timestamp));
}
NativeLibwebpdemux.WebPAnimDecoderReset(webPAnimDecoderPtr);
NativeLibwebpdemux.WebPAnimDecoderDelete(webPAnimDecoderPtr);
}
return(ret);
}
){kind=link}
){kind=link}
){kind=link}