public void Init(UUID id)
{
if (id == UUID.Zero)
{
return;
}
AssetType assetType = AssetType.Texture;
SimAsset sa = SimAssetStore.FindOrCreateAsset(id, assetType);
if (!sa.NeedsRequest)
{
return;
}
{
StartTextureDownload(id);
}
sa.NeedsRequest = false;
lock (AssetRequestType)
{
if (AssetRequestType.ContainsKey(id))
{
return;
}
AssetRequestType[id] = AssetType.Texture;
}
// Callbacks
client.Assets.RequestImage(id, ImageType.Normal, 101300.0f, 0, 0, delegate(TextureRequestState state, AssetTexture assetTexture)
{
if (state == TextureRequestState.Finished)
{
Assets_OnImageReceived(assetTexture);
sa.SetAsset(assetTexture);
return;
}
else if (state == TextureRequestState.Progress)
{
// DisplayPartialImage(assetTexture);
}
else if (state == TextureRequestState.Timeout)
{
AssetRequestType.Remove(id);
}
}, false);
}
internal void OnAssetDownloaded(UUID uUID, Asset asset)
{
EnsureCached(asset, uUID);
WorldObjects.RegisterUUIDMaybe(uUID, asset);
SimAsset A = SimAssetStore.FindOrCreateAsset(uUID, asset.AssetType);
A.SetAsset(asset);
//A.TypeData = asset.AssetData;
if (false)
{
BotClient Client = this.client;
AutoResetEvent UploadCompleteEvent = new AutoResetEvent(false);
if (Client.AnimationFolder == UUID.Zero)
{
Client.AnimationFolder = Client.Inventory.FindFolderForType(AssetType.Animation);
}
DateTime start = new DateTime();
Client.Inventory.RequestCreateItemFromAsset(asset.AssetData, A.Name, "Anim captured " + uUID,
AssetType.Animation,
InventoryType.Animation, Client.AnimationFolder,
delegate(bool success, string status, UUID itemID,
UUID assetID)
{
WriteLine(
String.Format(
"RequestCreateItemFromAsset() returned: Success={0}, Status={1}, ItemID={2}, AssetID={3}",
success, status, itemID, assetID));
WriteLine(String.Format("Upload took {0}",
DateTime.Now.
Subtract(start)));
UploadCompleteEvent.Set();
});
UploadCompleteEvent.WaitOne();
//A.Name
//SetAnimationName(asset.AssetID, s);
}
// Debug(s);
// RegisterUUID(asset.AssetID, s);
}
private void Assets_OnImageReceived(AssetTexture assetTexture)
{
try
{
byte[] jpegdata;
ManagedImage imgManaged;
Image image;
SimAsset sa = SimAssetStore.FindOrCreateAsset(assetTexture.AssetID, assetTexture.AssetType);
if (!OpenJPEG.DecodeToImage(assetTexture.AssetData, out imgManaged, out image))
{
throw new Exception("decoding failure");
}
jpegdata = assetTexture.AssetData;
sa._TypeData = jpegdata;
UUIDTypeObjectSetValue(assetTexture.AssetID, jpegdata);
assetTexture.Decode();
}
catch (Exception excp)
{
System.Console.WriteLine("Error decoding image: " + excp.Message);
}
}
private CogbotEvent AnimEvent(UUID uuid, SimEventType status, int serial)
{
SimAsset a = SimAssetStore.FindOrCreateAsset(uuid, AssetType.Animation);
string headingString;
switch (status)
{
case SimEventType.Start:
{
headingString = "eventOccursAt";
break;
}
case SimEventType.Stop:
{
headingString = "toLocation";
break;
}
default:
{
headingString = "eventOccursAt";
break;
}
}
object m = a.GetMeaning();
CogbotEvent oe = CreateAEvent(status, "OnAnim", SimEventType.ANIM | SimEventType.REGIONAL,
WorldObjects.ToParameter("doneBy", this),
WorldObjects.ToParameter("isa", a),
WorldObjects.ToParameter(headingString, GetHeading()));
oe.Serial = serial;
if (m != null)
{
oe.AddParam("isa", m);
}
return(oe);
}
public ImageDownload StartTextureDownload(UUID id)
{
AssetType type = AssetType.Texture;
SimAsset simAsset = SimAssetStore.FindOrCreateAsset(id, type);
AssetCache Cache =
(RegionMasterTexturePipeline == null ? null : RegionMasterTexturePipeline.Cache);
if (Cache != null && Cache.HasAsset(id
#if COGBOT_LIBOMV
, type
#endif
))
{
ImageDownload dl = Cache.GetCachedImage(id);
if (dl != null)
{
simAsset.SetAsset(dl);
}
return(dl);
}
lock (TexturesSkipped) if (TexturesSkipped.Contains(id))
{
return(null);
}
lock (AssetRequestType)
{
if (AssetRequestType.ContainsKey(id))
{
return(null);
}
AssetRequestType[id] = AssetType.Texture;
}
TextureRequested++;
SlowConnectedQueue.Enqueue(() => client.Assets.RequestImage(id, ImageType.Normal, RegionMasterTexturePipeline_OnDownloadFinished));
return(null);
}
//public override void Assets_OnXferReceived(XferDownload xfer)
//{
// //AssetRequests.
// //RegisterUUIDMaybe(xfer.ID, xfer);
//}
public SimAsset EnqueueRequestAsset(UUID id, AssetType assetType, bool priority)
{
if (id == UUID.Zero)
{
return(null);
}
SimAsset sa = SimAssetStore.FindOrCreateAsset(id, assetType);
if (!sa.NeedsRequest)
{
return(sa);
}
if (assetType == AssetType.Texture)
{
StartTextureDownload(id);
return(sa);
}
sa.NeedsRequest = false;
if (assetType == AssetType.SoundWAV)
{
return(sa);
}
//if (assetType == AssetType.Sound) return sa;
lock (AssetRequestType)
{
if (AssetRequestType.ContainsKey(id))
{
return(sa);
}
AssetRequestType[id] = assetType;
SlowConnectedQueue.Enqueue(
() => RegionMasterTexturePipeline.RequestAsset(id, assetType, priority, Assets_OnAssetReceived));
}
return(sa);
}
public byte[] TextureBytesForUUID(UUID uUID)
{
//imlicitly DeclareTexture(uUID);
SimAsset assettt = SimAssetStore.FindOrCreateAsset(uUID, AssetType.Texture);
var AssetData = assettt.AssetData;
if (AssetData != null)
{
assettt.IsTraced = false;
return(AssetData);
}
assettt.IsTraced = true;
ImageDownload ID = null;
//lock (uuidTypeObject)
{
object iObject;
if (UUIDTypeObjectTryGetValue(uUID, out iObject))
{
if (iObject is ImageDownload)
{
ID = (ImageDownload)iObject;
}
}
}
if (ID == null)
{
ID = StartTextureDownload(uUID);
if (ID == null)
{
var giveUpTick = DateTime.Now;//.AddMinutes(1);// +1 * 60000;
while (ID == null)
{
ID = StartTextureDownload(uUID);
if (ID == null)
{
lock (TexturesSkipped) if (TexturesSkipped.Contains(uUID))
{
return(null);
}
if (DateTime.Now > giveUpTick)
{
lock (TexturesSkipped) TexturesSkipped.Add(uUID);
//if (Settings.LOG_LEVEL == Helpers.LogLevel.Warning)
Debug("-- ---- ---GIVEUP SculptMesh " + uUID);
return(null);
}
//Thread.Sleep(5000);
DoEvents();
return(null);
}
}
}
lock (UUIDTypeObjectLock)
{
UUIDTypeObjectSetValue(uUID, ID);
}
}
if (Settings.LOG_LEVEL == Helpers.LogLevel.Debug)
{
Debug("-|-|- SUCCEED SculptMesh " + uUID);
}
return(ID.AssetData);
}
public void DeclareTexture(UUID tid)
{
SimAssetStore.FindOrCreateAsset(tid, AssetType.Texture);
}
static UUIDGleaner GetUUIDGleaner(string p, MemberInfo info)
{
lock (UUID2Type)
if (UUID2Type.Count == 0)
{
UUIDGleaner texture = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Texture); });
UUIDGleaner avatar = ((obj, sim) => { GridMaster.DeclareAvatarProfile(obj); });
UUIDGleaner task = ((obj, sim) => { GridMaster.DeclareTask(obj, sim); });
UUIDGleaner nothing = ((obj, sim) => { });
UUIDGleaner objectID = ((obj, sim) => { GridMaster.CreateSimObject(obj, GridMaster, sim); });
UUIDGleaner role = ((obj, sim) => DeclareGeneric("GroupRole", obj, " +p"));
UUID2Type[""] = nothing;
UUID2Type["ID"] = nothing;
UUID2Type["Sound"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Sound); });
UUID2Type["Gesture"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Gesture); });
UUID2Type["Landmark"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Landmark); });
UUID2Type["Animation"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Animation); });
UUID2Type["Clothing"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Clothing); });
UUID2Type["Region"] = ((obj, sim) => { RegisterUUIDMaybe(obj, typeof(SimRegion)); });
UUID2Type["Estate"] = ((obj, sim) => { RegisterUUIDMaybe(obj, typeof(EstateAssetType)); });
UUID2Type["Image"]
= UUID2Type["SculptTexture"]
= UUID2Type["Photo"]
= UUID2Type["Insignia"]
= UUID2Type["Picture"]
= UUID2Type["Texture"]
= UUID2Type["Sculpt"]
= UUID2Type["ProfileImage"] = texture;
UUID2Type["Owner"] = UUID2Type["Partner"] = UUID2Type["Creator"] = UUID2Type["Founder"] = avatar;
UUID2Type["Group"] = ((obj, sim) => { GridMaster.DeclareGroup(obj); });
UUID2Type["Object"] = objectID;
UUID2Type["Primitive"] = objectID;
// todo inventory item
UUID2Type["OwnerRole"] = role;
UUID2Type["FromTask"] = task;
UUID2Type["FolderID"] = nothing;
UUID2Type["ItemID"] = nothing;
// ussualyl objects but need to confirm: The Key of the specified target object or avatar particles will follow"
UUID2Type["Target"] = nothing;
UUID2Type["Asset"] = nothing;
}
UUIDGleaner o;
lock (UUID2Type)
{
if (UUID2Type.TryGetValue(p, out o))
{
return(o);
}
foreach (var s in new[] { "From", "To", "Next", "Last", "First", "Second", "Life", "Life", })
{
if (p.StartsWith(s))
{
return(UUID2Type[p] = GetUUIDGleaner(p.Substring(s.Length), info));
}
}
foreach (var s in new[] { "ID", "UUID", "Asset" })
{
if (p.EndsWith(s))
{
return(UUID2Type[p] = GetUUIDGleaner(p.Substring(0, p.Length - s.Length), info));
}
}
Debug("Dont know what UUID means in " + p);
return((obj, sim) => { RegisterUUIDMaybe(obj, info); });
}
}
protected override List <SimAsset> GetParts()
{
AssetGesture gestureAsset = GetGesture();
// StringBuilder sb = new StringBuilder();
//sb.Append("2\n");
if (gestureAsset == null)
{
return(null);
}
Name = gestureAsset.Trigger;
//sb.Append(TriggerKey + "\n");
//sb.Append(TriggerKeyMask + "\n");
//sb.Append(Trigger + "\n");
Name = gestureAsset.ReplaceWith;//sb.Append(ReplaceWith + "\n");
List <GestureStep> Sequence = gestureAsset.Sequence;
int count = 0;
if (Sequence != null)
{
count = Sequence.Count;
}
List <SimAsset> parts = new List <SimAsset>(count);
//sb.Append(count + "\n");
_Length = 0;
for (int i = 0; i < count; i++)
{
GestureStep step = Sequence[i];
// sb.Append((int)step.GestureStepType + "\n");
SimAsset asset;
switch (step.GestureStepType)
{
case GestureStepType.EOF:
goto Finish;
case GestureStepType.Animation:
GestureStepAnimation animstep = (GestureStepAnimation)step;
asset = SimAssetStore.FindOrCreateAsset(animstep.ID, AssetType.Animation);
asset.Name = animstep.Name;
if (animstep.AnimationStart)
{
parts.Add(asset);
// sb.Append("0\n");
_Length += asset.Length;
}
else
{
// sb.Append("1\n");
}
break;
case GestureStepType.Sound:
GestureStepSound soundstep = (GestureStepSound)step;
asset = SimAssetStore.FindOrCreateAsset(soundstep.ID, AssetType.Sound);
asset.Name = soundstep.Name;
parts.Add(asset);
_Length += asset.Length;
break;
case GestureStepType.Chat:
GestureStepChat chatstep = (GestureStepChat)step;
Name = chatstep.Text;
//sb.Append(chatstep.Text + "\n");
//sb.Append("0\n");
_Length += 10;
break;
case GestureStepType.Wait:
GestureStepWait waitstep = (GestureStepWait)step;
//sb.AppendFormat("{0:0.000000}\n", waitstep.WaitTime);
int waitflags = 0;
if (waitstep.WaitForTime)
{
waitflags |= 0x01;
_Length += waitstep.WaitTime;
}
if (waitstep.WaitForAnimation)
{
waitflags |= 0x02;
_Length += 10;
}
//sb.Append(waitflags + "\n");
break;
}
}
Finish:
if (parts.Count == 1)
{
SimAsset A = parts[0];
if (A is SimAnimation)
{
AnimationGestures[A.AssetID] = this;
if (A.Item == null)
{
A.Item = Item;
}
}
}
return(parts);
}
