private void CheckContainsReferences(AssetType assetType, bool expected) { AssetBase asset = new AssetBase(); asset.Type = (sbyte)assetType; bool actual = asset.ContainsReferences; Assert.AreEqual(expected, actual, "Expected "+assetType+".ContainsReferences to be "+expected+" but was "+actual+"."); }
public bool StoreAsset(AssetBase asset) { try { if (asset.Name.Length > 64) asset.Name = asset.Name.Substring(0, 64); if (asset.Description.Length > 128) asset.Description = asset.Description.Substring(0, 128); if (ExistsAsset(asset.ID)) { AssetBase oldAsset = GetAsset(asset.ID); if (oldAsset == null || (oldAsset.Flags & AssetFlags.Rewritable) == AssetFlags.Rewritable) { MainConsole.Instance.Debug("[LocalAssetDatabase]: Asset already exists in the db, overwriting - " + asset.ID); Delete(asset.ID, true); InsertAsset(asset, asset.ID); } else { MainConsole.Instance.Warn("[LocalAssetDatabase]: Asset already exists in the db, fixing ID... - " + asset.ID); InsertAsset(asset, UUID.Random()); } } else { InsertAsset(asset, asset.ID); } } catch (Exception e) { MainConsole.Instance.ErrorFormat("[LocalAssetDatabase]: Failure creating asset {0} with name \"{1}\". Error: {2}", asset.ID, asset.Name, e); } return true; }
public LLUUID AddToInventory(LLUUID folderID, AssetBase asset) { if (this.InventoryFolders.ContainsKey(folderID)) { LLUUID NewItemID = LLUUID.Random(); InventoryItem Item = new InventoryItem(); Item.FolderID = folderID; Item.OwnerID = AgentID; Item.AssetID = asset.FullID; Item.ItemID = NewItemID; Item.Type = asset.Type; Item.Name = asset.Name; Item.Description = asset.Description; Item.InvType = asset.InvType; this.InventoryItems.Add(Item.ItemID, Item); InventoryFolder Folder = InventoryFolders[Item.FolderID]; Folder.Items.Add(Item); return (Item.ItemID); } else { return (null); } }
protected static void LoadAsset(AssetBase info, string path) { // bool image = // (info.Type == (sbyte)AssetType.Texture || // info.Type == (sbyte)AssetType.TextureTGA || // info.Type == (sbyte)AssetType.ImageJPEG || // info.Type == (sbyte)AssetType.ImageTGA); FileInfo fInfo = new FileInfo(path); long numBytes = fInfo.Length; if (fInfo.Exists) { FileStream fStream = new FileStream(path, FileMode.Open, FileAccess.Read); byte[] idata = new byte[numBytes]; BinaryReader br = new BinaryReader(fStream); idata = br.ReadBytes((int)numBytes); br.Close(); fStream.Close(); info.Data = idata; //info.loaded=true; } else { m_log.ErrorFormat("[ASSETS]: file: [{0}] not found !", path); } }
public void AddUpload(LLUUID transactionID, AssetBase asset) { AssetTransaction upload = new AssetTransaction(); lock (this.transactions) { upload.Asset = asset; upload.TransactionID = transactionID; this.transactions.Add(transactionID, upload); } if (upload.Asset.Data.Length > 2) { //is complete upload.UploadComplete = true; AssetUploadCompletePacket response = new AssetUploadCompletePacket(); response.AssetBlock.Type = asset.Type; response.AssetBlock.Success = true; response.AssetBlock.UUID = transactionID.Combine(this.ourClient.SecureSessionID); this.ourClient.OutPacket(response); m_assetCache.AddAsset(asset); } else { upload.UploadComplete = false; upload.XferID = Util.GetNextXferID(); RequestXferPacket xfer = new RequestXferPacket(); xfer.XferID.ID = upload.XferID; xfer.XferID.VFileType = upload.Asset.Type; xfer.XferID.VFileID = transactionID.Combine(this.ourClient.SecureSessionID); xfer.XferID.FilePath = 0; xfer.XferID.Filename = new byte[0]; this.ourClient.OutPacket(xfer); } }
public UUID SaveBitmap(Bitmap data, bool lossless, bool temporary) { AssetBase asset = new AssetBase(UUID.Random(), "MRMDynamicImage", AssetType.Texture, m_scene.RegionInfo.RegionID) { Data = OpenJPEG.EncodeFromImage(data, lossless), Description = "MRM Image", Flags = (temporary) ? AssetFlags.Temporary : 0 }; asset.ID = m_scene.AssetService.Store(asset); return asset.ID; }
/// <summary> /// Adds the given <see cref="AssetBase"/> to the <see cref="Asset.BaseParts"/> collection of this asset. /// </summary> /// <remarks>If the <see cref="Asset.BaseParts"/> collection already contains the argument. this method does nothing.</remarks> /// <param name="newBasePart">The base to add to the <see cref="Asset.BaseParts"/> collection.</param> public void AddBasePart(AssetBase newBasePart) { if (newBasePart == null) throw new ArgumentNullException(nameof(newBasePart)); if (BaseParts == null) { BaseParts = new List<AssetBase>(); } if (BaseParts.All(x => x.Id != newBasePart.Id)) { BaseParts.Add(newBasePart); } }
protected static AssetBase CreateAsset(string assetIdStr, string name, string path, sbyte type) { AssetBase asset = new AssetBase(new UUID(assetIdStr), name, type, LIBRARY_OWNER_ID.ToString()); if (!String.IsNullOrEmpty(path)) { //m_log.InfoFormat("[ASSETS]: Loading: [{0}][{1}]", name, path); LoadAsset(asset, path); } else { m_log.InfoFormat("[ASSETS]: Instantiated: [{0}]", name); } return asset; }
public override void StoreAsset(AssetBase asset) { byte[] idBytes = asset.FullID.Guid.ToByteArray(); string cdir = m_dir + Path.DirectorySeparatorChar + idBytes[0] + Path.DirectorySeparatorChar + idBytes[1]; if (!Directory.Exists(m_dir + Path.DirectorySeparatorChar + idBytes[0])) Directory.CreateDirectory(m_dir + Path.DirectorySeparatorChar + idBytes[0]); if (!Directory.Exists(cdir)) Directory.CreateDirectory(cdir); FileStream x = new FileStream(cdir + Path.DirectorySeparatorChar + asset.FullID + ".xml", FileMode.Create); m_xs.Serialize(x, asset); x.Flush(); x.Close(); }
protected static AssetBase CreateAsset(string assetIdStr, string name, string path, bool isImage) { AssetBase asset = new AssetBase( new UUID(assetIdStr), name ); if (!String.IsNullOrEmpty(path)) { //m_log.InfoFormat("[ASSETS]: Loading: [{0}][{1}]", name, path); LoadAsset(asset, isImage, path); } else { m_log.InfoFormat("[ASSETS]: Instantiated: [{0}]", name); } return asset; }
private bool ProcessMergeAssetItem(AssetItem assetItem, HashSet<Guid> beingProcessed) { if (beingProcessed.Contains(assetItem.Id)) { log.Error(package, assetItem.Asset.Base, AssetMessageCode.AssetNotFound, assetItem.Asset.Base); return false; } beingProcessed.Add(assetItem.Id); AssetItem existingAssetBase = null; List<AssetBase> existingBaseParts = null; // Process asset base if (assetItem.Asset.Base != null) { if (!ProcessMergeAssetBase(assetItem.Asset.Base, beingProcessed, out existingAssetBase)) { return false; } } // Process asset base parts if (assetItem.Asset.BaseParts != null && assetItem.Asset.BaseParts.Count > 0) { existingBaseParts = new List<AssetBase>(); foreach (var basePart in assetItem.Asset.BaseParts) { AssetItem existingAssetBasePart; if (!ProcessMergeAssetBase(basePart, beingProcessed, out existingAssetBasePart)) { return false; } // Replicate the group with the list of ids var newBasePart =new AssetBase(existingAssetBasePart.Location, (Asset)AssetCloner.Clone(existingAssetBasePart.Asset)); existingBaseParts.Add(newBasePart); } } // For simple merge (base, newAsset, newBase) => newObject // For multi-part prefabs merge (base, newAsset, newBase) + baseParts + newBaseParts => newObject if (!MergeAsset(assetItem, existingAssetBase, existingBaseParts)) { return false; } assetsProcessed.Add(assetItem.Id, assetItem); assetsToProcess.Remove(assetItem.Id); return true; }
public virtual string Store(AssetBase asset) { return(Store(asset, false)); }
public void LoadModuleFromArchive(byte[] data, string filePath, TarArchiveReader.TarEntryType type, IScene scene) { if (filePath.StartsWith("parcels/")) { if (!m_merge) { //Only use if we are not merging LandData parcel = new LandData(); OSD parcelData = OSDParser.DeserializeLLSDBinary(data); parcel.FromOSD((OSDMap)parcelData); m_parcels.Add(parcel); } } #region New Style Terrain Loading else if (filePath.StartsWith("newstyleterrain/")) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>(); terrainModule.TerrainMap = ReadTerrain(data, scene); } else if (filePath.StartsWith("newstylerevertterrain/")) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>(); terrainModule.TerrainRevertMap = ReadTerrain(data, scene); } else if (filePath.StartsWith("newstylewater/")) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>(); terrainModule.TerrainWaterMap = ReadTerrain(data, scene); } else if (filePath.StartsWith("newstylerevertwater/")) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>(); terrainModule.TerrainWaterRevertMap = ReadTerrain(data, scene); } #endregion #region Old Style Terrain Loading else if (filePath.StartsWith("terrain/")) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>(); MemoryStream ms = new MemoryStream(data); terrainModule.LoadFromStream(filePath, ms, 0, 0); ms.Close(); } else if (filePath.StartsWith("revertterrain/")) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>(); MemoryStream ms = new MemoryStream(data); terrainModule.LoadRevertMapFromStream(filePath, ms, 0, 0); ms.Close(); } else if (filePath.StartsWith("water/")) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>(); MemoryStream ms = new MemoryStream(data); terrainModule.LoadWaterFromStream(filePath, ms, 0, 0); ms.Close(); } else if (filePath.StartsWith("revertwater/")) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>(); MemoryStream ms = new MemoryStream(data); terrainModule.LoadWaterRevertMapFromStream(filePath, ms, 0, 0); ms.Close(); } #endregion else if (filePath.StartsWith("entities/")) { MemoryStream ms = new MemoryStream(data); ISceneEntity sceneObject = SceneEntitySerializer.SceneObjectSerializer.FromXml2Format(ref ms, scene); ms.Close(); ms = null; data = null; m_groups.Add(sceneObject); } else if (filePath.StartsWith("assets/")) { if (m_loadAssets) { AssetBase asset = new AssetBase(); asset.Unpack(OSDParser.DeserializeJson(Encoding.UTF8.GetString(data))); scene.AssetService.Store(asset); } } }
/// <summary> /// Builds a composited terrain texture given the region texture /// and heightmap settings /// </summary> /// <param name="heightmap">Terrain heightmap</param> /// <param name="textureIDs"></param> /// <param name="startHeights"></param> /// <param name="heightRanges"></param> /// <param name="regionPosition"></param> /// <param name="assetService"></param> /// <param name="textureTerrain"></param> /// <returns>A composited 256x256 RGB texture ready for rendering</returns> /// <remarks> /// Based on the algorithm described at http://opensimulator.org/wiki/Terrain_Splatting /// </remarks> public static Bitmap Splat(ITerrainChannel heightmap, UUID[] textureIDs, float[] startHeights, float[] heightRanges, Vector3d regionPosition, IAssetService assetService, bool textureTerrain) { Debug.Assert(textureIDs.Length == 4); Debug.Assert(startHeights.Length == 4); Debug.Assert(heightRanges.Length == 4); Bitmap[] detailTexture = new Bitmap[4]; if (textureTerrain) { // Swap empty terrain textureIDs with default IDs for (int i = 0; i < textureIDs.Length; i++) { if (textureIDs[i] == UUID.Zero) { textureIDs[i] = DEFAULT_TERRAIN_DETAIL[i]; } } #region Texture Fetching if (assetService != null) { for (int i = 0; i < 4; i++) { UUID cacheID = UUID.Combine(TERRAIN_CACHE_MAGIC, textureIDs[i]); AssetBase asset = assetService.Get(cacheID.ToString()); if ((asset != null) && (asset.Data != null) && (asset.Data.Length != 0)) { try { using (MemoryStream stream = new MemoryStream(asset.Data)) detailTexture[i] = (Bitmap)Image.FromStream(stream); } catch (Exception ex) { MainConsole.Instance.Warn("Failed to decode cached terrain texture " + cacheID + " (textureID: " + textureIDs[i] + "): " + ex.Message); } } if (detailTexture[i] == null) { // Try to fetch the original JPEG2000 texture, resize if needed, and cache as PNG byte[] assetData = assetService.GetData(textureIDs[i].ToString()); if (asset != null) { try { detailTexture[i] = (Bitmap)J2kImage.FromBytes(assetData); } catch (Exception ex) { MainConsole.Instance.Warn("Failed to decode terrain texture " + asset.ID + ": " + ex.Message); } } if (detailTexture[i] != null) { Bitmap bitmap = detailTexture[i]; // Make sure this texture is the correct size, otherwise resize if (bitmap.Width != 256 || bitmap.Height != 256) { bitmap = ImageUtils.ResizeImage(bitmap, 256, 256); } // Save the decoded and resized texture to the cache byte[] data; using (MemoryStream stream = new MemoryStream()) { bitmap.Save(stream, ImageFormat.Png); data = stream.ToArray(); } // Cache a PNG copy of this terrain texture AssetBase newAsset = new AssetBase { Data = data, Description = "PNG", Flags = AssetFlags.Collectable | AssetFlags.Temporary | AssetFlags.Local, ID = cacheID, Name = String.Empty, TypeString = "image/png" }; newAsset.ID = assetService.Store(newAsset); } } } } #endregion Texture Fetching } // Fill in any missing textures with a solid color for (int i = 0; i < 4; i++) { if (detailTexture[i] == null) { // Create a solid color texture for this layer detailTexture[i] = new Bitmap(256, 256, PixelFormat.Format24bppRgb); using (Graphics gfx = Graphics.FromImage(detailTexture[i])) { using (SolidBrush brush = new SolidBrush(DEFAULT_TERRAIN_COLOR[i])) gfx.FillRectangle(brush, 0, 0, 256, 256); } } else if (detailTexture[i].Width != 256 || detailTexture[i].Height != 256) { detailTexture[i] = ResizeBitmap(detailTexture[i], 256, 256); } } #region Layer Map float diff = (float)heightmap.Height / (float)Constants.RegionSize; float[] layermap = new float[Constants.RegionSize * Constants.RegionSize]; for (float y = 0; y < heightmap.Height; y += diff) { for (float x = 0; x < heightmap.Height; x += diff) { float newX = x / diff; float newY = y / diff; float height = heightmap[(int)newX, (int)newY]; float pctX = newX / 255f; float pctY = newY / 255f; // Use bilinear interpolation between the four corners of start height and // height range to select the current values at this position float startHeight = ImageUtils.Bilinear( startHeights[0], startHeights[2], startHeights[1], startHeights[3], pctX, pctY); startHeight = Utils.Clamp(startHeight, 0f, 255f); float heightRange = ImageUtils.Bilinear( heightRanges[0], heightRanges[2], heightRanges[1], heightRanges[3], pctX, pctY); heightRange = Utils.Clamp(heightRange, 0f, 255f); // Generate two frequencies of perlin noise based on our global position // The magic values were taken from http://opensimulator.org/wiki/Terrain_Splatting Vector3 vec = new Vector3 ( ((float)regionPosition.X + newX) * 0.20319f, ((float)regionPosition.Y + newY) * 0.20319f, height * 0.25f ); float lowFreq = Perlin.noise2(vec.X * 0.222222f, vec.Y * 0.222222f) * 6.5f; float highFreq = Perlin.turbulence2(vec.X, vec.Y, 2f) * 2.25f; float noise = (lowFreq + highFreq) * 2f; // Combine the current height, generated noise, start height, and height range parameters, then scale all of it float layer = ((height + noise - startHeight) / heightRange) * 4f; if (Single.IsNaN(layer)) { layer = 0f; } layermap[(int)(newY * Constants.RegionSize + newX)] = Utils.Clamp(layer, 0f, 3f); } } #endregion Layer Map #region Texture Compositing Bitmap output = new Bitmap(256, 256, PixelFormat.Format24bppRgb); BitmapData outputData = output.LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb); unsafe { // Get handles to all of the texture data arrays BitmapData[] datas = new[] { detailTexture[0].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[0].PixelFormat), detailTexture[1].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[1].PixelFormat), detailTexture[2].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[2].PixelFormat), detailTexture[3].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[3].PixelFormat) }; int[] comps = new[] { (datas[0].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3, (datas[1].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3, (datas[2].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3, (datas[3].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3 }; for (int y = 0; y < Constants.RegionSize; y++) { for (int x = 0; x < Constants.RegionSize; x++) { float layer = layermap[y * Constants.RegionSize + x]; // Select two textures int l0 = (int)Math.Floor(layer); int l1 = Math.Min(l0 + 1, 3); byte *ptrA = (byte *)datas[l0].Scan0 + y * datas[l0].Stride + x * comps[l0]; byte *ptrB = (byte *)datas[l1].Scan0 + y * datas[l1].Stride + x * comps[l1]; byte *ptrO = (byte *)outputData.Scan0 + y * outputData.Stride + x * 3; float aB = *(ptrA + 0); float aG = *(ptrA + 1); float aR = *(ptrA + 2); float bB = *(ptrB + 0); float bG = *(ptrB + 1); float bR = *(ptrB + 2); float layerDiff = layer - l0; // Interpolate between the two selected textures *(ptrO + 0) = (byte)Math.Floor(aB + layerDiff * (bB - aB)); *(ptrO + 1) = (byte)Math.Floor(aG + layerDiff * (bG - aG)); *(ptrO + 2) = (byte)Math.Floor(aR + layerDiff * (bR - aR)); } } for (int i = 0; i < 4; i++) { detailTexture[i].UnlockBits(datas[i]); detailTexture[i].Dispose(); } } layermap = null; output.UnlockBits(outputData); // We generated the texture upside down, so flip it output.RotateFlip(RotateFlipType.RotateNoneFlipY); #endregion Texture Compositing return(output); }
public string Store(AssetBase asset) { //m_log.DebugFormat("[ASSET SERVICE]: Store asset {0} {1}", asset.Name, asset.ID); m_Database.StoreAsset(asset); return asset.ID; }
/// /// UpdateInventoryItemAsset /// public override bool UpdateInventoryItemAsset(UUID ownerID, InventoryItemBase item, AssetBase asset) { if (base.UpdateInventoryItemAsset(ownerID, item, asset)) { PostInventoryAsset(item, 0); return(true); } return(false); }
public void Import(string conn, string table, int start, int count, bool force, FSStoreDelegate store) { MySqlConnection importConn; try { importConn = new MySqlConnection(conn); importConn.Open(); } catch (MySqlException e) { m_log.ErrorFormat("[FSASSETS]: Can't connect to database: {0}", e.Message.ToString()); return; } int imported = 0; MySqlCommand cmd = importConn.CreateCommand(); string limit = String.Empty; if (count != -1) { limit = String.Format(" limit {0},{1}", start, count); } cmd.CommandText = String.Format("select * from {0}{1}", table, limit); MainConsole.Instance.Output("Querying database"); IDataReader reader = cmd.ExecuteReader(); MainConsole.Instance.Output("Reading data"); while (reader.Read()) { if ((imported % 100) == 0) { MainConsole.Instance.Output(String.Format("{0} assets imported so far", imported)); } AssetBase asset = new AssetBase(); AssetMetadata meta = new AssetMetadata(); meta.ID = reader["id"].ToString(); meta.FullID = new UUID(meta.ID); meta.Name = reader["name"].ToString(); meta.Description = reader["description"].ToString(); meta.Type = (sbyte)Convert.ToInt32(reader["assetType"]); meta.ContentType = SLUtil.SLAssetTypeToContentType(meta.Type); meta.CreationDate = Util.ToDateTime(Convert.ToInt32(reader["create_time"])); asset.Metadata = meta; asset.Data = (byte[])reader["data"]; store(asset, force); imported++; } reader.Close(); cmd.Dispose(); importConn.Close(); MainConsole.Instance.Output(String.Format("Import done, {0} assets imported", imported)); }
private void Awake() { if (loaded) { Destroy(gameObject); } if (loadedPrefabs == null) { string path = KSPUtil.ApplicationRootPath + "GameData/SurfaceExperimentPackage/Resources"; AssetBundle prefabs = AssetBundle.LoadFromFile(path + "/sep_prefab"); if (prefabs != null) { loadedPrefabs = prefabs.LoadAllAssets <GameObject>(); } } if (loadedPrefabs != null) { if (!TMPLoaded) { processTMPPrefabs(); } if (UISkinManager.defaultSkin != null && !UILoaded) { if (sliderFrontForeground == null || sliderBackBackground == null || sliderBackForeground == null) { ExperimentsResultDialog scienceDialogPrefab = UnityEngine.Object.Instantiate <GameObject>(AssetBase.GetPrefab("ScienceResultsDialog")).GetComponent <ExperimentsResultDialog>(); if (scienceDialogPrefab != null) { Slider[] sliders = scienceDialogPrefab.GetComponentsInChildren <Slider>();; Slider backSlider = sliders[0]; Slider frontSlider = sliders[1]; sliderBackBackground = processSliderSprites(backSlider, true, ref sliderBackBackColor); sliderBackForeground = processSliderSprites(backSlider, false, ref sliderBackForeColor); sliderFrontForeground = processSliderSprites(frontSlider, false, ref sliderFrontForeColor); } } processUIPrefabs(); } } if (TMPLoaded && UILoaded) { loaded = true; } Destroy(gameObject); }
/// <summary> /// Load an asset /// </summary> /// <param name="assetPath"> </param> /// <param name="data"></param> /// <returns>true if asset was successfully loaded, false otherwise</returns> bool LoadAsset(string assetPath, byte [] data) { //IRegionSerialiser serialiser = scene.RequestModuleInterface<IRegionSerialiser>(); // Right now we're nastily obtaining the UUID from the filename string filename = assetPath.Remove(0, ArchiveConstants.ASSETS_PATH.Length); int i = filename.LastIndexOf(ArchiveConstants.ASSET_EXTENSION_SEPARATOR, StringComparison.Ordinal); if (i == -1) { MainConsole.Instance.ErrorFormat( "[Inventory Archiver]: Could not find extension information in asset path {0} since it's missing the separator {1}. Skipping", assetPath, ArchiveConstants.ASSET_EXTENSION_SEPARATOR); return(false); } string extension = filename.Substring(i); string uuid = filename.Remove(filename.Length - extension.Length); UUID assetID = UUID.Parse(uuid); if (ArchiveConstants.EXTENSION_TO_ASSET_TYPE.ContainsKey(extension)) { AssetType assetType = ArchiveConstants.EXTENSION_TO_ASSET_TYPE [extension]; if (assetType == AssetType.Unknown) { MainConsole.Instance.WarnFormat( "[Inventory Archiver]: Importing {0} byte asset {1} with unknown type", data.Length, uuid); } else if (assetType == AssetType.Object) { string xmlData = Utils.BytesToString(data); ISceneEntity sceneObject = SceneEntitySerializer.SceneObjectSerializer.FromOriginalXmlFormat( xmlData, m_registry); if (sceneObject != null) { if (m_creatorIdForAssetId.ContainsKey(assetID)) { foreach ( ISceneChildEntity sop in from sop in sceneObject.ChildrenEntities() where string.IsNullOrEmpty(sop.CreatorData) select sop) { sop.CreatorID = m_creatorIdForAssetId [assetID]; } } foreach (ISceneChildEntity sop in sceneObject.ChildrenEntities()) { //Fix ownerIDs and perms sop.Inventory.ApplyGodPermissions((uint)PermissionMask.All); sceneObject.ApplyPermissions((uint)PermissionMask.All); foreach (TaskInventoryItem item in sop.Inventory.GetInventoryItems()) { item.OwnerID = m_userInfo.PrincipalID; } sop.OwnerID = m_userInfo.PrincipalID; } data = Utils.StringToBytes( SceneEntitySerializer.SceneObjectSerializer.ToOriginalXmlFormat(sceneObject)); } } //MainConsole.Instance.DebugFormat("[Inventory Archiver]: Importing asset {0}, type {1}", uuid, assetType); AssetBase asset = new AssetBase(assetID, "From IAR", assetType, m_overridecreator) { Data = data, Flags = AssetFlags.Normal }; if (m_assetData != null && ReplaceAssets) { m_assetData.Delete(asset.ID, true); } // check if this asset already exists in the database try { if (!m_assetService.GetExists(asset.ID.ToString())) { m_assetService.Store(asset); } } catch { MainConsole.Instance.Error( "[Inventory Archiver]: Error checking if asset exists. Possibly 'Path too long' for file based asset storage"); } asset.Dispose(); return(true); } MainConsole.Instance.ErrorFormat( "[Inventory Archiver]: Tried to dearchive data with path {0} with an unknown type extension {1}", assetPath, extension); return(false); }
private Color4 GetFaceColor(Primitive.TextureEntryFace face) { Color4 color; if (face.TextureID == UUID.Zero) { return(face.RGBA); } if (!m_colors.TryGetValue(face.TextureID, out color)) { bool fetched = false; // Attempt to fetch the texture metadata UUID metadataID = UUID.Combine(face.TextureID, TEXTURE_METADATA_MAGIC); AssetBase metadata = m_scene.AssetService.GetCached(metadataID.ToString()); if (metadata != null) { OSDMap map = null; try { map = OSDParser.Deserialize(metadata.Data) as OSDMap; } catch { } if (map != null) { color = map["X-JPEG2000-RGBA"].AsColor4(); if (!(color.R == 0.5f && color.G == 0.5f && color.B == 0.5f && color.A == 1.0f)) { //If we failed, don't save it fetched = true; } } map = null; metadata = null; } if (!fetched) { // Fetch the texture, decode and get the average color, // then save it to a temporary metadata asset AssetBase textureAsset = m_scene.AssetService.Get(face.TextureID.ToString()); if (textureAsset != null) { int width, height; color = GetAverageColor(textureAsset.ID, textureAsset.Data, m_scene, out width, out height); if (!(color.R == 0.5f && color.G == 0.5f && color.B == 0.5f && color.A == 1.0f)) //If we failed, don't save it { OSDMap data = new OSDMap { { "X-JPEG2000-RGBA", OSD.FromColor4(color) } }; metadata = new AssetBase { Data = Encoding.UTF8.GetBytes(OSDParser.SerializeJsonString(data)), Description = "Avg Color-JPEG2000 texture " + face.TextureID.ToString(), Flags = AssetFlags.Collectable | AssetFlags.Temperary | AssetFlags.Local, ID = metadataID, Name = String.Empty, TypeAsset = AssetType.Simstate // Make something up to get around OpenSim's myopic treatment of assets }; metadata.ID = m_scene.AssetService.Store(metadata); } textureAsset = null; } else { color = new Color4(0.5f, 0.5f, 0.5f, 1.0f); } } m_colors[face.TextureID] = color; } return(color * face.RGBA); }
private void CreatePrim(WarpRenderer renderer, ISceneChildEntity prim) { try { const float MIN_SIZE = 2f; if ((PCode)prim.Shape.PCode != PCode.Prim) { return; } if (prim.Scale.LengthSquared() < MIN_SIZE * MIN_SIZE) { return; } Primitive omvPrim = prim.Shape.ToOmvPrimitive(prim.OffsetPosition, prim.RotationOffset); FacetedMesh renderMesh = null; // Are we dealing with a sculptie or mesh? if (omvPrim.Sculpt != null && omvPrim.Sculpt.SculptTexture != UUID.Zero) { // Try fetchinng the asset AssetBase sculptAsset = m_scene.AssetService.Get(omvPrim.Sculpt.SculptTexture.ToString()); if (sculptAsset != null) { // Is it a mesh? if (omvPrim.Sculpt.Type == SculptType.Mesh) { AssetMesh meshAsset = new AssetMesh(omvPrim.Sculpt.SculptTexture, sculptAsset.Data); FacetedMesh.TryDecodeFromAsset(omvPrim, meshAsset, DetailLevel.Highest, out renderMesh); } else // It's sculptie { IJ2KDecoder imgDecoder = m_scene.RequestModuleInterface <IJ2KDecoder>(); Image sculpt = imgDecoder.DecodeToImage(sculptAsset.Data); if (sculpt != null) { renderMesh = m_primMesher.GenerateFacetedSculptMesh(omvPrim, (Bitmap)sculpt, DetailLevel.Medium); sculpt.Dispose(); } } } } else // Prim { renderMesh = m_primMesher.GenerateFacetedMesh(omvPrim, DetailLevel.Medium); } if (renderMesh == null) { return; } warp_Vector primPos = ConvertVector(prim.GetWorldPosition()); warp_Quaternion primRot = ConvertQuaternion(prim.RotationOffset); warp_Matrix m = warp_Matrix.quaternionMatrix(primRot); if (prim.ParentID != 0) { ISceneEntity group = m_scene.GetGroupByPrim(prim.LocalId); if (group != null) { m.transform(warp_Matrix.quaternionMatrix(ConvertQuaternion(group.RootChild.RotationOffset))); } } warp_Vector primScale = ConvertVector(prim.Scale); string primID = prim.UUID.ToString(); // Create the prim faces for (int i = 0; i < renderMesh.Faces.Count; i++) { Face face = renderMesh.Faces[i]; string meshName = primID + "-Face-" + i.ToString(); warp_Object faceObj = new warp_Object(face.Vertices.Count, face.Indices.Count / 3); foreach (Vertex v in face.Vertices) { warp_Vector pos = ConvertVector(v.Position); warp_Vector norm = ConvertVector(v.Normal); if (prim.Shape.SculptTexture == UUID.Zero) { norm = norm.reverse(); } warp_Vertex vert = new warp_Vertex(pos, norm, v.TexCoord.X, v.TexCoord.Y); faceObj.addVertex(vert); } for (int j = 0; j < face.Indices.Count;) { faceObj.addTriangle( face.Indices[j++], face.Indices[j++], face.Indices[j++]); } Primitive.TextureEntryFace teFace = prim.Shape.Textures.GetFace((uint)i); string materialName; Color4 faceColor = GetFaceColor(teFace); if (m_texturePrims && prim.Scale.LengthSquared() > 48 * 48) { materialName = GetOrCreateMaterial(renderer, faceColor, teFace.TextureID); } else { materialName = GetOrCreateMaterial(renderer, faceColor); } faceObj.transform(m); faceObj.setPos(primPos); faceObj.scaleSelf(primScale.x, primScale.y, primScale.z); renderer.Scene.addObject(meshName, faceObj); renderer.SetObjectMaterial(meshName, materialName); } renderMesh.Faces.Clear(); renderMesh = null; } catch (Exception ex) { MainConsole.Instance.Warn("[Warp3D]: Exception creating prim, " + ex); } }
public void PostAnAsset(AssetBase asset) { PostAsset(asset); }
private void CreateMetaDataMap(AssetBase data, OSDMap map) { map["ContentType"] = OSD.FromString(data.TypeString); map["CreationDate"] = OSD.FromDate(data.CreationDate); map["CreatorID"] = OSD.FromUUID(data.CreatorID); map["Description"] = OSD.FromString(data.Description); map["ID"] = OSD.FromUUID(data.ID); map["Name"] = OSD.FromString(data.Name); map["Type"] = OSD.FromInteger(data.Type); }
/// <summary> /// Try to get an asset from the file cache. /// </summary> /// <param name="id"></param> /// <returns></returns> private AssetBase GetFromFileCache(string id) { AssetBase asset = null; string filename = GetFileName(id); if (File.Exists(filename)) { FileStream stream = null; try { stream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read); BinaryFormatter bformatter = new BinaryFormatter(); asset = (AssetBase)bformatter.Deserialize(stream); m_DiskHits++; } catch (System.Runtime.Serialization.SerializationException e) { m_log.ErrorFormat( "[FLOTSAM ASSET CACHE]: Failed to get file {0} for asset {1}. Exception {2} {3}", filename, id, e.Message, e.StackTrace); // If there was a problem deserializing the asset, the asset may // either be corrupted OR was serialized under an old format // {different version of AssetBase} -- we should attempt to // delete it and re-cache File.Delete(filename); } catch (Exception e) { m_log.ErrorFormat( "[FLOTSAM ASSET CACHE]: Failed to get file {0} for asset {1}. Exception {2} {3}", filename, id, e.Message, e.StackTrace); } finally { if (stream != null) { stream.Close(); } } } #if WAIT_ON_INPROGRESS_REQUESTS // Check if we're already downloading this asset. If so, try to wait for it to // download. if (m_WaitOnInprogressTimeout > 0) { m_RequestsForInprogress++; ManualResetEvent waitEvent; if (m_CurrentlyWriting.TryGetValue(filename, out waitEvent)) { waitEvent.WaitOne(m_WaitOnInprogressTimeout); return(Get(id)); } } #else // Track how often we have the problem that an asset is requested while // it is still being downloaded by a previous request. if (m_CurrentlyWriting.Contains(filename)) { m_RequestsForInprogress++; } #endif return(asset); }
private void SaveFileCacheForAsset(UUID AssetId, OpenJPEG.J2KLayerInfo[] Layers) { if (m_useCache) m_decodedCache.AddOrUpdate(AssetId, Layers, TimeSpan.FromMinutes(10)); if (m_cache != null) { string assetID = "j2kCache_" + AssetId.ToString(); AssetBase layerDecodeAsset = new AssetBase(assetID, assetID, AssetType.Notecard, UUID.Zero) {Flags = AssetFlags.Local | AssetFlags.Temporary}; #region Serialize Layer Data StringBuilder stringResult = new StringBuilder(); string strEnd = "\n"; for (int i = 0; i < Layers.Length; i++) { if (i == Layers.Length - 1) strEnd = String.Empty; stringResult.AppendFormat("{0}|{1}|{2}{3}", Layers[i].Start, Layers[i].End, Layers[i].End - Layers[i].Start, strEnd); } layerDecodeAsset.Data = Util.UTF8.GetBytes(stringResult.ToString()); #endregion Serialize Layer Data m_cache.Cache(assetID, layerDecodeAsset); } }
/// <summary> /// Called once new texture data has been received for this updater. /// </summary> public void DataReceived(byte[] data, IScene scene) { ISceneChildEntity part = scene.GetSceneObjectPart(PrimID); if (part == null || data == null || data.Length <= 1) { string msg = String.Format("DynamicTextureModule: Error preparing image using URL {0}", Url); IChatModule chatModule = scene.RequestModuleInterface <IChatModule>(); if (chatModule != null) { chatModule.SimChat(msg, ChatTypeEnum.Say, 0, part.ParentEntity.AbsolutePosition, part.Name, part.UUID, false, scene); } return; } byte[] assetData = null; AssetBase oldAsset = null; if (BlendWithOldTexture) { Primitive.TextureEntryFace defaultFace = part.Shape.Textures.DefaultTexture; if (defaultFace != null) { oldAsset = scene.AssetService.Get(defaultFace.TextureID.ToString()); if (oldAsset != null) { assetData = BlendTextures(data, oldAsset.Data, SetNewFrontAlpha, FrontAlpha, scene); } } } if (assetData == null) { assetData = new byte[data.Length]; Array.Copy(data, assetData, data.Length); } AssetBase asset = null; if (LastAssetID != UUID.Zero) { asset = scene.AssetService.Get(LastAssetID.ToString()); asset.Description = String.Format("URL image : {0}", Url); asset.Data = assetData; if ((asset.Flags & AssetFlags.Local) == AssetFlags.Local) { asset.Flags = asset.Flags & ~AssetFlags.Local; } if (((asset.Flags & AssetFlags.Temporary) == AssetFlags.Temporary) != ((Disp & DISP_TEMP) != 0)) { if ((Disp & DISP_TEMP) != 0) { asset.Flags |= AssetFlags.Temporary; } else { asset.Flags = asset.Flags & ~AssetFlags.Temporary; } } asset.ID = scene.AssetService.Store(asset); } else { // Create a new asset for user asset = new AssetBase(UUID.Random(), "DynamicImage" + Util.RandomClass.Next(1, 10000), AssetType.Texture, scene.RegionInfo.RegionID) { Data = assetData, Description = String.Format("URL image : {0}", Url) }; if ((Disp & DISP_TEMP) != 0) { asset.Flags = AssetFlags.Temporary; } asset.ID = scene.AssetService.Store(asset); } IJ2KDecoder cacheLayerDecode = scene.RequestModuleInterface <IJ2KDecoder>(); if (cacheLayerDecode != null) { cacheLayerDecode.Decode(asset.ID, asset.Data); cacheLayerDecode = null; LastAssetID = asset.ID; } UUID oldID = UUID.Zero; lock (part) { // mostly keep the values from before Primitive.TextureEntry tmptex = part.Shape.Textures; // remove the old asset from the cache oldID = tmptex.DefaultTexture.TextureID; if (Face == ALL_SIDES) { tmptex.DefaultTexture.TextureID = asset.ID; } else { try { Primitive.TextureEntryFace texface = tmptex.CreateFace((uint)Face); texface.TextureID = asset.ID; tmptex.FaceTextures[Face] = texface; } catch (Exception) { tmptex.DefaultTexture.TextureID = asset.ID; } } // I'm pretty sure we always want to force this to true // I'm pretty sure noone whats to set fullbright true if it wasn't true before. // tmptex.DefaultTexture.Fullbright = true; part.UpdateTexture(tmptex, true); } if (oldID != UUID.Zero && ((Disp & DISP_EXPIRE) != 0)) { if (oldAsset == null) { oldAsset = scene.AssetService.Get(oldID.ToString()); } if (oldAsset != null) { if ((oldAsset.Flags & AssetFlags.Temporary) == AssetFlags.Temporary) { scene.AssetService.Delete(oldID); } } } }
/// <summary> /// Called back by the asset cache when it has the asset /// </summary> /// <param name="assetID"></param> /// <param name="sender"></param> /// <param name="asset"></param> public void AssetRequestCallback(string assetID, object sender, AssetBase asset) { try { lock (this) { //MainConsole.Instance.DebugFormat("[ARCHIVER]: Received callback for asset {0}", id); m_requestCallbackTimer.Stop(); if (m_requestState == RequestState.Aborted) { MainConsole.Instance.WarnFormat( "[ARCHIVER]: Received information about asset {0} after archive save abortion. Ignoring.", assetID); return; } if (asset != null) { // MainConsole.Instance.DebugFormat("[ARCHIVER]: Writing asset {0}", id); m_foundAssetUuids.Add(asset.ID); m_assetsArchiver.WriteAsset(asset); } else { // MainConsole.Instance.DebugFormat("[ARCHIVER]: Recording asset {0} as not found", id); m_notFoundAssetUuids.Add(new UUID(assetID)); } if (m_foundAssetUuids.Count + m_notFoundAssetUuids.Count == m_repliesRequired) { m_requestState = RequestState.Completed; MainConsole.Instance.InfoFormat( "[ARCHIVER]: Successfully added {0} assets ({1} assets notified missing)", m_foundAssetUuids.Count, m_notFoundAssetUuids.Count); // We want to stop using the asset cache thread asap // as we now need to do the work of producing the rest of the archive Util.FireAndForget(PerformAssetsRequestCallback); } else m_requestCallbackTimer.Start(); } } catch (Exception e) { MainConsole.Instance.ErrorFormat("[ARCHIVER]: AssetRequestCallback failed with {0}", e); } }
private void UpdateFileCache(string key, AssetBase asset) { string filename = GetFileName(key); try { // If the file is already cached, don't cache it, just touch it so access time is updated if (File.Exists(filename)) { // We don't really want to know about sharing // violations here. If the file is locked, then // the other thread has updated the time for us. try { m_CurrentlyWritingRwLock.AcquireReaderLock(-1); try { if (!m_CurrentlyWriting.Contains(filename)) { File.SetLastAccessTime(filename, DateTime.Now); } } finally { m_CurrentlyWritingRwLock.ReleaseReaderLock(); } } catch { } } else { // Once we start writing, make sure we flag that we're writing // that object to the cache so that we don't try to write the // same file multiple times. m_CurrentlyWritingRwLock.AcquireReaderLock(-1); try { if (m_CurrentlyWriting.Contains(filename)) { return; } LockCookie lc = m_CurrentlyWritingRwLock.UpgradeToWriterLock(-1); try { /* recheck since we were in a reader lock before */ if (m_CurrentlyWriting.Contains(filename)) { return; } m_CurrentlyWriting.Add(filename); } finally { m_CurrentlyWritingRwLock.DowngradeFromWriterLock(ref lc); } } finally { m_CurrentlyWritingRwLock.ReleaseReaderLock(); } Util.FireAndForget( delegate { WriteFileCache(filename, asset); }); } } catch (Exception e) { m_log.ErrorFormat( "[FLOTSAM ASSET CACHE]: Failed to update cache for asset {0}. Exception {1} {2}", asset.ID, e.Message, e.StackTrace); } }
protected void ConstructDefaultIarBytesForTestLoad() { // log4net.Config.XmlConfigurator.Configure(); InventoryArchiverModule archiverModule = new InventoryArchiverModule(); Scene scene = new SceneHelpers().SetupScene(); SceneHelpers.SetupSceneModules(scene, archiverModule); UserAccountHelpers.CreateUserWithInventory(scene, m_uaLL1, "hampshire"); MemoryStream archiveWriteStream = new MemoryStream(); // Create scene object asset UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000040"); SceneObjectGroup object1 = SceneHelpers.CreateSceneObject(1, ownerId, "Ray Gun Object", 0x50); UUID asset1Id = UUID.Parse("00000000-0000-0000-0000-000000000060"); AssetBase asset1 = AssetHelpers.CreateAsset(asset1Id, object1); scene.AssetService.Store(asset1); // Create scene object item InventoryItemBase item1 = new InventoryItemBase(); item1.Name = m_item1Name; item1.ID = UUID.Parse("00000000-0000-0000-0000-000000000020"); item1.AssetID = asset1.FullID; item1.GroupID = UUID.Random(); item1.CreatorId = m_uaLL1.PrincipalID.ToString(); item1.Owner = m_uaLL1.PrincipalID; item1.Folder = scene.InventoryService.GetRootFolder(m_uaLL1.PrincipalID).ID; scene.AddInventoryItem(item1); // Create coalesced objects asset SceneObjectGroup cobj1 = SceneHelpers.CreateSceneObject(1, m_uaLL1.PrincipalID, "Object1", 0x120); cobj1.AbsolutePosition = new Vector3(15, 30, 45); SceneObjectGroup cobj2 = SceneHelpers.CreateSceneObject(1, m_uaLL1.PrincipalID, "Object2", 0x140); cobj2.AbsolutePosition = new Vector3(25, 50, 75); CoalescedSceneObjects coa = new CoalescedSceneObjects(m_uaLL1.PrincipalID, cobj1, cobj2); AssetBase coaAsset = AssetHelpers.CreateAsset(0x160, coa); scene.AssetService.Store(coaAsset); // Create coalesced objects inventory item InventoryItemBase coaItem = new InventoryItemBase(); coaItem.Name = m_coaItemName; coaItem.ID = UUID.Parse("00000000-0000-0000-0000-000000000180"); coaItem.AssetID = coaAsset.FullID; coaItem.GroupID = UUID.Random(); coaItem.CreatorId = m_uaLL1.PrincipalID.ToString(); coaItem.Owner = m_uaLL1.PrincipalID; coaItem.Folder = scene.InventoryService.GetRootFolder(m_uaLL1.PrincipalID).ID; scene.AddInventoryItem(coaItem); archiverModule.ArchiveInventory( Guid.NewGuid(), m_uaLL1.FirstName, m_uaLL1.LastName, "/*", "hampshire", archiveWriteStream); m_iarStreamBytes = archiveWriteStream.ToArray(); }
private string Store(AssetBase asset, bool force) { int tickCount = Environment.TickCount; string hash = GetSHA256Hash(asset.Data); if (asset.Name.Length > AssetBase.MAX_ASSET_NAME) { string assetName = asset.Name.Substring(0, AssetBase.MAX_ASSET_NAME); m_log.WarnFormat( "[FSASSETS]: Name '{0}' for asset {1} truncated from {2} to {3} characters on add", asset.Name, asset.ID, asset.Name.Length, assetName.Length); asset.Name = assetName; } if (asset.Description.Length > AssetBase.MAX_ASSET_DESC) { string assetDescription = asset.Description.Substring(0, AssetBase.MAX_ASSET_DESC); m_log.WarnFormat( "[FSASSETS]: Description '{0}' for asset {1} truncated from {2} to {3} characters on add", asset.Description, asset.ID, asset.Description.Length, assetDescription.Length); asset.Description = assetDescription; } if (!AssetExists(hash)) { string tempFile = Path.Combine(Path.Combine(m_SpoolDirectory, "spool"), hash + ".asset"); string finalFile = Path.Combine(m_SpoolDirectory, hash + ".asset"); if (!File.Exists(finalFile)) { // Deal with bug introduced in Oct. 20 (1eb3e6cc43e2a7b4053bc1185c7c88e22356c5e8) // Fix bad assets before storing on this server if (asset.Type == (int)AssetType.Object && asset.Data != null) { string xml = ExternalRepresentationUtils.SanitizeXml(Utils.BytesToString(asset.Data)); asset.Data = Utils.StringToBytes(xml); } FileStream fs = File.Create(tempFile); fs.Write(asset.Data, 0, asset.Data.Length); fs.Close(); File.Move(tempFile, finalFile); } } if (asset.ID == string.Empty) { if (asset.FullID == UUID.Zero) { asset.FullID = UUID.Random(); } asset.ID = asset.FullID.ToString(); } else if (asset.FullID == UUID.Zero) { UUID uuid = UUID.Zero; if (UUID.TryParse(asset.ID, out uuid)) { asset.FullID = uuid; } else { asset.FullID = UUID.Random(); } } if (!m_DataConnector.Store(asset.Metadata, hash)) { if (asset.Metadata.Type == -2) { return(asset.ID); } return(UUID.Zero.ToString()); } else { return(asset.ID); } }
//////////////////////////////////////////////////////////// // IImprovedAssetCache // private void UpdateMemoryCache(string key, AssetBase asset) { m_MemoryCache.AddOrUpdate(GetAssetID(key), asset, m_MemoryExpiration); }
public override void VisitArrayItem(Array array, ArrayDescriptor descriptor, int index, object item, ITypeDescriptor itemDescriptor) { base.VisitArrayItem(array, descriptor, index, item, itemDescriptor); var assetReference = item as AssetReference; var assetBase = item as AssetBase; var attachedReference = AttachedReferenceManager.GetAttachedReference(item); if (assetReference != null) { AddLink(item, (guid, location) => { var newValue = AssetReference.New(descriptor.ElementType, guid ?? assetReference.Id, location); array.SetValue(newValue, index); return(newValue); }); } else if (assetBase != null) { AddLink(item, (guid, location) => { var newValue = new AssetBase(location, assetBase.Asset); array.SetValue(newValue, index); return(newValue); }); } else if (attachedReference != null) { AddLink(attachedReference, (guid, location) => { object newValue = guid.HasValue && guid.Value != Guid.Empty ? AttachedReferenceManager.CreateProxyObject(descriptor.ElementType, guid.Value, location) : null; if (newValue != null) { IdentifiableHelper.SetId(newValue, IdentifiableHelper.GetId(item)); } array.SetValue(newValue, index); return(newValue); }); } else if (item is UFile) { AddLink(item, (guid, location) => { var newValue = new UFile(location); array.SetValue(newValue, index); return(newValue); }); } else if (item is UDirectory) { AddLink(item, (guid, location) => { var newValue = new UFile(location); array.SetValue(newValue, index); return(newValue); }); } }
/// <summary> /// Writes a file to the file cache, creating any nessesary /// tier directories along the way /// </summary> /// <param name="filename"></param> /// <param name="asset"></param> private void WriteFileCache(string filename, AssetBase asset) { Stream stream = null; // Make sure the target cache directory exists string directory = Path.GetDirectoryName(filename); // Write file first to a temp name, so that it doesn't look // like it's already cached while it's still writing. string tempname = Path.Combine(directory, Path.GetRandomFileName()); try { try { if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } stream = File.Open(tempname, FileMode.Create); BinaryFormatter bformatter = new BinaryFormatter(); bformatter.Serialize(stream, asset); } catch (IOException e) { m_log.WarnFormat( "[FLOTSAM ASSET CACHE]: Failed to write asset {0} to temporary location {1} (final {2}) on cache in {3}. Exception {4} {5}.", asset.ID, tempname, filename, directory, e.Message, e.StackTrace); return; } finally { if (stream != null) { stream.Close(); } } try { // Now that it's written, rename it so that it can be found. // // File.Copy(tempname, filename, true); // File.Delete(tempname); // // For a brief period, this was done as a separate copy and then temporary file delete operation to // avoid an IOException caused by move if some competing thread had already written the file. // However, this causes exceptions on Windows when other threads attempt to read a file // which is still being copied. So instead, go back to moving the file and swallow any IOException. // // This situation occurs fairly rarely anyway. We assume in this that moves are atomic on the // filesystem. File.Move(tempname, filename); if (m_LogLevel >= 2) { m_log.DebugFormat("[FLOTSAM ASSET CACHE]: Cache Stored :: {0}", asset.ID); } } catch (IOException) { // If we see an IOException here it's likely that some other competing thread has written the // cache file first, so ignore. Other IOException errors (e.g. filesystem full) should be // signally by the earlier temporary file writing code. } } finally { // Even if the write fails with an exception, we need to make sure // that we release the lock on that file, otherwise it'll never get // cached m_CurrentlyWritingRwLock.AcquireWriterLock(-1); try { m_CurrentlyWriting.Remove(filename); } finally { m_CurrentlyWritingRwLock.ReleaseWriterLock(); } } }
private void RunRequests() { while (true) { byte[] idata = null; bool found = false; AssetStorage foundAsset = null; ARequest req = this._assetRequests.Dequeue(); IObjectSet result = db.Query(new AssetUUIDQuery(req.AssetID)); if (result.Count > 0) { foundAsset = (AssetStorage)result.Next(); found = true; } AssetBase asset = new AssetBase(); if (found) { asset.FullID = foundAsset.UUID; asset.Type = foundAsset.Type; asset.InvType = foundAsset.Type; asset.Name = foundAsset.Name; idata = foundAsset.Data; } else { asset.FullID = LLUUID.Zero; } asset.Data = idata; _receiver.AssetReceived(asset, req.IsTexture); } }
public string Store(AssetBase asset) { //m_log.DebugFormat("[ASSET SERVICE]: Store asset {0} {1}", asset.Name, asset.ID); m_Database.StoreAsset (asset); IImprovedAssetCache cache = m_registry.RequestModuleInterface<IImprovedAssetCache> (); if (cache != null && asset != null) { cache.Expire (asset.ID); cache.Cache (asset); } return asset.ID; }
private AssetBase LoadAssetBase(OSDMap map) { AssetBase asset = new AssetBase(); asset.FromOSD(map); return asset; }
public override void VisitCollectionItem(IEnumerable collection, CollectionDescriptor descriptor, int index, object item, ITypeDescriptor itemDescriptor) { base.VisitCollectionItem(collection, descriptor, index, item, itemDescriptor); var assetReference = item as AssetReference; var assetBase = item as AssetBase; var attachedReference = AttachedReferenceManager.GetAttachedReference(item); // We cannot set links if we do not have indexer accessor if (!descriptor.HasIndexerAccessors) { return; } if (assetReference != null) { AddLink(assetReference, (guid, location) => { var link = AssetReference.New(descriptor.ElementType, guid ?? assetReference.Id, location); descriptor.SetValue(collection, index, link); return(link); }); } else if (assetBase != null) { AddLink(assetBase, (guid, location) => { var link = new AssetBase(location, assetBase.Asset); descriptor.SetValue(collection, index, link); return(link); }); } else if (attachedReference != null) { AddLink(attachedReference, (guid, location) => { var link = guid.HasValue && guid.Value != Guid.Empty ? AttachedReferenceManager.CreateProxyObject(descriptor.ElementType, guid.Value, location) : null; if (link != null) { IdentifiableHelper.SetId(link, IdentifiableHelper.GetId(item)); } descriptor.SetValue(collection, index, link); return(link); }); } else if (item is UFile) { AddLink(item, (guid, location) => { var link = new UFile(location); descriptor.SetValue(collection, index, link); return(link); }); } else if (item is UDirectory) { AddLink(item, (guid, location) => { var link = new UDirectory(location); descriptor.SetValue(collection, index, link); return(link); }); } }
private AssetBase Get(string id, out string sha) { string hash = string.Empty; int startTime = System.Environment.TickCount; AssetMetadata metadata; lock (m_readLock) { metadata = m_DataConnector.Get(id, out hash); } sha = hash; if (metadata == null) { AssetBase asset = null; if (m_FallbackService != null) { asset = m_FallbackService.Get(id); if (asset != null) { asset.Metadata.ContentType = SLUtil.SLAssetTypeToContentType((int)asset.Type); sha = GetSHA256Hash(asset.Data); m_log.InfoFormat("[FSASSETS]: Added asset {0} from fallback to local store", id); Store(asset); } } if (asset == null && m_showStats) { // m_log.InfoFormat("[FSASSETS]: Asset {0} not found", id); m_missingAssets++; } return(asset); } AssetBase newAsset = new AssetBase(); newAsset.Metadata = metadata; try { newAsset.Data = GetFsData(hash); if (newAsset.Data.Length == 0) { AssetBase asset = null; if (m_FallbackService != null) { asset = m_FallbackService.Get(id); if (asset != null) { asset.Metadata.ContentType = SLUtil.SLAssetTypeToContentType((int)asset.Type); sha = GetSHA256Hash(asset.Data); m_log.InfoFormat("[FSASSETS]: Added asset {0} from fallback to local store", id); Store(asset); } } if (asset == null) { if (m_showStats) { m_missingAssetsFS++; } // m_log.InfoFormat("[FSASSETS]: Asset {0}, hash {1} not found in FS", id, hash); } else { // Deal with bug introduced in Oct. 20 (1eb3e6cc43e2a7b4053bc1185c7c88e22356c5e8) // Fix bad assets before sending them elsewhere if (asset.Type == (int)AssetType.Object && asset.Data != null) { string xml = ExternalRepresentationUtils.SanitizeXml(Utils.BytesToString(asset.Data)); asset.Data = Utils.StringToBytes(xml); } return(asset); } } if (m_showStats) { lock (m_statsLock) { m_readTicks += Environment.TickCount - startTime; m_readCount++; } } // Deal with bug introduced in Oct. 20 (1eb3e6cc43e2a7b4053bc1185c7c88e22356c5e8) // Fix bad assets before sending them elsewhere if (newAsset.Type == (int)AssetType.Object && newAsset.Data != null) { string xml = ExternalRepresentationUtils.SanitizeXml(Utils.BytesToString(newAsset.Data)); newAsset.Data = Utils.StringToBytes(xml); } return(newAsset); } catch (Exception exception) { m_log.Error(exception.ToString()); return(null); } }
private void SetUpAssetDatabase() { try { Console.WriteLine("setting up Asset database"); AssetBase Image = new AssetBase(); Image.FullID = new LLUUID("00000000-0000-0000-9999-000000000001"); Image.Name = "Bricks"; this.LoadAsset(Image, true, "bricks.jp2"); AssetStorage store = new AssetStorage(); store.Data = Image.Data; store.Name = Image.Name; store.UUID = Image.FullID; db.Set(store); db.Commit(); Image = new AssetBase(); Image.FullID = new LLUUID("00000000-0000-0000-9999-000000000002"); Image.Name = "Plywood"; this.LoadAsset(Image, true, "plywood.jp2"); store = new AssetStorage(); store.Data = Image.Data; store.Name = Image.Name; store.UUID = Image.FullID; db.Set(store); db.Commit(); Image = new AssetBase(); Image.FullID = new LLUUID("00000000-0000-0000-9999-000000000003"); Image.Name = "Rocks"; this.LoadAsset(Image, true, "rocks.jp2"); store = new AssetStorage(); store.Data = Image.Data; store.Name = Image.Name; store.UUID = Image.FullID; db.Set(store); db.Commit(); Image = new AssetBase(); Image.FullID = new LLUUID("00000000-0000-0000-9999-000000000004"); Image.Name = "Granite"; this.LoadAsset(Image, true, "granite.jp2"); store = new AssetStorage(); store.Data = Image.Data; store.Name = Image.Name; store.UUID = Image.FullID; db.Set(store); db.Commit(); Image = new AssetBase(); Image.FullID = new LLUUID("00000000-0000-0000-9999-000000000005"); Image.Name = "Hardwood"; this.LoadAsset(Image, true, "hardwood.jp2"); store = new AssetStorage(); store.Data = Image.Data; store.Name = Image.Name; store.UUID = Image.FullID; db.Set(store); db.Commit(); Image = new AssetBase(); Image.FullID = new LLUUID("00000000-0000-0000-5005-000000000005"); Image.Name = "Prim Base Texture"; this.LoadAsset(Image, true, "plywood.jp2"); store = new AssetStorage(); store.Data = Image.Data; store.Name = Image.Name; store.UUID = Image.FullID; db.Set(store); db.Commit(); Image = new AssetBase(); Image.FullID = new LLUUID("66c41e39-38f9-f75a-024e-585989bfab73"); Image.Name = "Shape"; this.LoadAsset(Image, false, "base_shape.dat"); store = new AssetStorage(); store.Data = Image.Data; store.Name = Image.Name; store.UUID = Image.FullID; db.Set(store); db.Commit(); } catch (Exception e) { Console.WriteLine(e.Message); } }
public override void VisitDictionaryKeyValue(object dictionaryObj, DictionaryDescriptor descriptor, object key, ITypeDescriptor keyDescriptor, object value, ITypeDescriptor valueDescriptor) { base.VisitDictionaryKeyValue(dictionaryObj, descriptor, key, keyDescriptor, value, valueDescriptor); var assetReference = value as AssetReference; var assetBase = value as AssetBase; var attachedReference = AttachedReferenceManager.GetAttachedReference(value); if (assetReference != null) { AddLink(assetReference, (guid, location) => { var newValue = AssetReference.New(descriptor.ValueType, guid ?? assetReference.Id, location); descriptor.SetValue(dictionaryObj, key, newValue); return(newValue); }); } else if (assetBase != null) { AddLink(assetBase, (guid, location) => { var newValue = new AssetBase(location, assetBase.Asset); descriptor.SetValue(dictionaryObj, key, newValue); return(newValue); }); } else if (attachedReference != null) { AddLink(attachedReference, (guid, location) => { object newValue = guid.HasValue && guid.Value != Guid.Empty ? AttachedReferenceManager.CreateProxyObject(descriptor.ValueType, guid.Value, location) : null; if (newValue != null) { IdentifiableHelper.SetId(newValue, IdentifiableHelper.GetId(value)); } descriptor.SetValue(dictionaryObj, key, newValue); return(newValue); }); } else if (value is UFile) { AddLink(value, (guid, location) => { var newValue = new UFile(location); descriptor.SetValue(dictionaryObj, key, newValue); return(newValue); }); } else if (value is UDirectory) { AddLink(value, (guid, location) => { var newValue = new UDirectory(location); descriptor.SetValue(dictionaryObj, key, newValue); return(newValue); }); } }
protected AssetBase CreateAsset(string assetIdStr, string name, string path, AssetType type) { AssetBase asset = new AssetBase(new UUID(assetIdStr), name, type, m_service.LibraryOwner); if (!String.IsNullOrEmpty(path)) { //MainConsole.Instance.InfoFormat("[ASSETS]: Loading: [{0}][{1}]", name, path); LoadAsset(asset, path); } else { MainConsole.Instance.InfoFormat("[ASSETS]: Instantiated: [{0}]", name); } return asset; }
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value) { base.VisitObjectMember(container, containerDescriptor, member, value); var assetReference = value as AssetReference; var assetBase = value as AssetBase; var attachedReference = AttachedReferenceManager.GetAttachedReference(value); if (assetReference != null) { AddLink(assetReference, (guid, location) => { var newValue = AssetReference.New(member.Type, guid ?? assetReference.Id, location); member.Set(container, newValue); return(newValue); }); } else if (assetBase != null) { AddLink(assetBase, (guid, location) => { var newValue = new AssetBase(location, assetBase.Asset); member.Set(container, newValue); return(newValue); }); } else if (attachedReference != null) { AddLink(attachedReference, (guid, location) => { object newValue = guid.HasValue && guid.Value != Guid.Empty ? AttachedReferenceManager.CreateProxyObject(member.Type, guid.Value, location) : null; if (newValue != null) { IdentifiableHelper.SetId(newValue, IdentifiableHelper.GetId(value)); } member.Set(container, newValue); return(newValue); }); } else if (value is UFile) { AddLink(value, (guid, location) => { var newValue = new UFile(location); member.Set(container, newValue); return(newValue); }); } else if (value is UDirectory) { AddLink(value, (guid, location) => { var newValue = new UDirectory(location); member.Set(container, newValue); return(newValue); }); } }
private bool ProcessMergeAssetBase(AssetBase assetBase, HashSet<Guid> beingProcessed, out AssetItem existingAsset) { var baseId = assetBase.Id; // Make sure that the base asset exist existingAsset = session.FindAsset(baseId); if (existingAsset == null) { log.Warning(package, assetBase, AssetMessageCode.AssetNotFound, assetBase); return false; } // If the base asset hasn't been processed, continue on next asset if (!assetsProcessed.ContainsKey(baseId)) { // If asset is in the same package, we can process it right away if (existingAsset.Package == package) { if (!ProcessMergeAssetItem(existingAsset, beingProcessed)) { return false; } } } return true; }
/// <summary> /// Archive the assets given to this archiver to the given archive. /// </summary> /// <param name="archive"></param> public void WriteAsset(AssetBase asset) { //WriteMetadata(archive); WriteData(asset); }
/// <summary> /// Called once new texture data has been received for this updater. /// </summary> public void DataReceived(byte[] data, IScene scene) { ISceneChildEntity part = scene.GetSceneObjectPart(PrimID); if (part == null || data == null || data.Length <= 1) { string msg = String.Format("DynamicTextureModule: Error preparing image using URL {0}", Url); IChatModule chatModule = scene.RequestModuleInterface<IChatModule>(); if (chatModule != null) chatModule.SimChat(msg, ChatTypeEnum.Say, 0, part.ParentEntity.AbsolutePosition, part.Name, part.UUID, false, scene); return; } byte[] assetData = null; AssetBase oldAsset = null; if (BlendWithOldTexture) { Primitive.TextureEntryFace defaultFace = part.Shape.Textures.DefaultTexture; if (defaultFace != null) { oldAsset = scene.AssetService.Get(defaultFace.TextureID.ToString()); if (oldAsset != null) assetData = BlendTextures(data, oldAsset.Data, SetNewFrontAlpha, FrontAlpha, scene); } } if (assetData == null) { assetData = new byte[data.Length]; Array.Copy(data, assetData, data.Length); } AssetBase asset = null; if (LastAssetID != UUID.Zero) { asset = scene.AssetService.Get(LastAssetID.ToString()); asset.Description = String.Format("URL image : {0}", Url); asset.Data = assetData; if ((asset.Flags & AssetFlags.Local) == AssetFlags.Local) { asset.Flags = asset.Flags & ~AssetFlags.Local; } if (((asset.Flags & AssetFlags.Temporary) == AssetFlags.Temporary) != ((Disp & DISP_TEMP) != 0)) { if ((Disp & DISP_TEMP) != 0) asset.Flags |= AssetFlags.Temporary; else asset.Flags = asset.Flags & ~AssetFlags.Temporary; } asset.ID = scene.AssetService.Store(asset); } else { // Create a new asset for user asset = new AssetBase(UUID.Random(), "DynamicImage" + Util.RandomClass.Next(1, 10000), AssetType.Texture, scene.RegionInfo.RegionID) {Data = assetData, Description = String.Format("URL image : {0}", Url)}; if ((Disp & DISP_TEMP) != 0) asset.Flags = AssetFlags.Temporary; asset.ID = scene.AssetService.Store(asset); } IJ2KDecoder cacheLayerDecode = scene.RequestModuleInterface<IJ2KDecoder>(); if (cacheLayerDecode != null) { cacheLayerDecode.Decode(asset.ID, asset.Data); cacheLayerDecode = null; LastAssetID = asset.ID; } UUID oldID = UUID.Zero; lock (part) { // mostly keep the values from before Primitive.TextureEntry tmptex = part.Shape.Textures; // remove the old asset from the cache oldID = tmptex.DefaultTexture.TextureID; if (Face == ALL_SIDES) { tmptex.DefaultTexture.TextureID = asset.ID; } else { try { Primitive.TextureEntryFace texface = tmptex.CreateFace((uint) Face); texface.TextureID = asset.ID; tmptex.FaceTextures[Face] = texface; } catch (Exception) { tmptex.DefaultTexture.TextureID = asset.ID; } } // I'm pretty sure we always want to force this to true // I'm pretty sure noone whats to set fullbright true if it wasn't true before. // tmptex.DefaultTexture.Fullbright = true; part.UpdateTexture(tmptex, true); } if (oldID != UUID.Zero && ((Disp & DISP_EXPIRE) != 0)) { if (oldAsset == null) oldAsset = scene.AssetService.Get(oldID.ToString()); if (oldAsset != null) { if ((oldAsset.Flags & AssetFlags.Temporary) == AssetFlags.Temporary) { scene.AssetService.Delete(oldID); } } } }
public void TestLoadIarPathWithEscapedChars() { TestHelpers.InMethod(); // log4net.Config.XmlConfigurator.Configure(); string itemName = "You & you are a mean/man/"; string humanEscapedItemName = @"You & you are a mean\/man\/"; string userPassword = "******"; InventoryArchiverModule archiverModule = new InventoryArchiverModule(); Scene scene = new SceneHelpers().SetupScene(); SceneHelpers.SetupSceneModules(scene, archiverModule); // Create user string userFirstName = "Jock"; string userLastName = "Stirrup"; UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000020"); UserAccountHelpers.CreateUserWithInventory(scene, userFirstName, userLastName, userId, "meowfood"); // Create asset SceneObjectGroup object1; SceneObjectPart part1; { string partName = "part name"; UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000040"); PrimitiveBaseShape shape = PrimitiveBaseShape.CreateSphere(); Vector3 groupPosition = new Vector3(10, 20, 30); Quaternion rotationOffset = new Quaternion(20, 30, 40, 50); Vector3 offsetPosition = new Vector3(5, 10, 15); part1 = new SceneObjectPart( ownerId, shape, groupPosition, rotationOffset, offsetPosition); part1.Name = partName; object1 = new SceneObjectGroup(part1); scene.AddNewSceneObject(object1, false); } UUID asset1Id = UUID.Parse("00000000-0000-0000-0000-000000000060"); AssetBase asset1 = AssetHelpers.CreateAsset(asset1Id, object1); scene.AssetService.Store(asset1); // Create item UUID item1Id = UUID.Parse("00000000-0000-0000-0000-000000000080"); InventoryItemBase item1 = new InventoryItemBase(); item1.Name = itemName; item1.AssetID = asset1.FullID; item1.ID = item1Id; InventoryFolderBase objsFolder = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, userId, "Objects")[0]; item1.Folder = objsFolder.ID; scene.AddInventoryItem(item1); MemoryStream archiveWriteStream = new MemoryStream(); archiverModule.OnInventoryArchiveSaved += SaveCompleted; mre.Reset(); archiverModule.ArchiveInventory( Guid.NewGuid(), userFirstName, userLastName, "Objects", userPassword, archiveWriteStream); mre.WaitOne(60000, false); // LOAD ITEM MemoryStream archiveReadStream = new MemoryStream(archiveWriteStream.ToArray()); archiverModule.DearchiveInventory(userFirstName, userLastName, "Scripts", userPassword, archiveReadStream); InventoryItemBase foundItem1 = InventoryArchiveUtils.FindItemByPath( scene.InventoryService, userId, "Scripts/Objects/" + humanEscapedItemName); Assert.That(foundItem1, Is.Not.Null, "Didn't find loaded item 1"); // Assert.That( // foundItem1.CreatorId, Is.EqualTo(userUuid), // "Loaded item non-uuid creator doesn't match that of the loading user"); Assert.That( foundItem1.Name, Is.EqualTo(itemName), "Loaded item name doesn't match saved name"); }
private AssetBase LoadAssetBase(OSDMap map) { AssetBase asset = new AssetBase(); asset.Data = map["AssetData"].AsBinary(); asset.TypeString = map["ContentType"].AsString(); asset.CreationDate = map["CreationDate"].AsDate(); asset.CreatorID = map["CreatorID"].AsUUID(); asset.Description = map["Description"].AsString(); asset.ID = map["ID"].AsUUID(); asset.Name = map["Name"].AsString(); asset.Type = map["Type"].AsInteger(); return asset; }
public bool PostAsset(string url, AssetBase asset, bool verbose = true) { if (asset == null) { m_log.Warn("[HG ASSET MAPPER]: Tried to post asset to remote server, but asset not in local cache."); return(false); } if (string.IsNullOrEmpty(url)) { return(false); } if (!url.EndsWith("/") && !url.EndsWith("=")) { url = url + "/"; } // See long comment in AssetCache.AddAsset if (asset.Temporary || asset.Local) { return(true); } // We need to copy the asset into a new asset, because // we need to set its ID to be URL+UUID, so that the // HGAssetService dispatches it to the remote grid. // It's not pretty, but the best that can be done while // not having a global naming infrastructure AssetBase asset1 = new AssetBase(asset.FullID, asset.Name, asset.Type, asset.Metadata.CreatorID); Copy(asset, asset1); asset1.ID = url + asset.ID; AdjustIdentifiers(asset1.Metadata); if (asset1.Metadata.Type == (sbyte)AssetType.Object) { asset1.Data = AdjustIdentifiers(asset.Data); } else { asset1.Data = asset.Data; } string id = m_scene.AssetService.Store(asset1); if (String.IsNullOrEmpty(id)) { if (verbose) { m_log.DebugFormat("[HG ASSET MAPPER]: Asset server {0} did not accept {1}", url, asset.ID); } return(false); } if (verbose) { m_log.DebugFormat("[HG ASSET MAPPER]: Posted copy of asset {0} from local asset server to {1}", asset1.ID, url); } return(true); }
public void SculptTextureCallback(UUID textureID, AssetBase texture) { if (m_shape.SculptEntry) { // commented out for sculpt map caching test - null could mean a cached sculpt map has been found //if (texture != null) { if (texture != null) m_shape.SculptData = texture.Data; if (PhysActor != null) { // Tricks physics engine into thinking we've changed the part shape. PrimitiveBaseShape m_newshape = m_shape.Copy(); PhysActor.Shape = m_newshape; m_shape = m_newshape; m_parentGroup.Scene.SceneGraph.PhysicsScene.AddPhysicsActorTaint(PhysActor); } } } }
public void Post(UUID assetID, UUID ownerID, string userAssetURL) { AssetBase asset = m_scene.AssetService.Get(assetID.ToString()); if (asset == null) { m_log.DebugFormat("[HG ASSET MAPPER POST]: Something wrong with asset {0}, it could not be found", assetID); return; } m_log.DebugFormat("[HG ASSET MAPPER POST]: Starting to send asset {0} to asset server {1}", assetID, userAssetURL); // Find all the embedded assets HGUuidGatherer uuidGatherer = new HGUuidGatherer(m_scene.AssetService, string.Empty); uuidGatherer.AddForInspection(asset.FullID); uuidGatherer.GatherAll(true); // Check which assets already exist in the destination server string url = userAssetURL; if (!url.EndsWith("/") && !url.EndsWith("=")) { url = url + "/"; } string[] remoteAssetIDs = new string[uuidGatherer.GatheredUuids.Count]; int i = 0; foreach (UUID id in uuidGatherer.GatheredUuids.Keys) { remoteAssetIDs[i++] = url + id.ToString(); } bool[] exist; try { exist = m_scene.AssetService.AssetsExist(remoteAssetIDs); } catch { m_log.DebugFormat("[HG ASSET MAPPER POST]: Problems sending asset {0} to asset server {1}", assetID, userAssetURL); return; } var existSet = new HashSet <string>(); i = 0; foreach (UUID id in uuidGatherer.GatheredUuids.Keys) { if (exist[i]) { existSet.Add(id.ToString()); } ++i; } // Send only those assets which don't already exist in the destination server bool success = true; var notFound = new List <string>(); var posted = new List <string>(); foreach (UUID uuid in uuidGatherer.GatheredUuids.Keys) { string idstr = uuid.ToString(); if (existSet.Contains(idstr)) { continue; } asset = m_scene.AssetService.Get(idstr); if (asset == null) { notFound.Add(idstr); continue; } try { bool b = PostAsset(userAssetURL, asset, false); if (b) { posted.Add(idstr); } success &= b; } catch (Exception e) { m_log.Error( string.Format( "[HG ASSET MAPPER POST]: Failed to post asset {0} (type {1}, length {2}) referenced from {3} to {4} with exception ", asset.ID, asset.Type, asset.Data.Length, assetID, userAssetURL), e); // For debugging purposes for now we will continue to throw the exception up the stack as was already happening. However, after // debugging we may want to simply report the failure if we can tell this is due to a failure // with a particular asset and not a destination network failure where all asset posts will fail (and // generate large amounts of log spam). throw; } } StringBuilder sb = null; if (notFound.Count > 0) { if (sb == null) { sb = new StringBuilder(512); } i = notFound.Count; sb.Append("[HG ASSET MAPPER POST]: did not find embedded UUIDs as assets:\n\t"); for (int j = 0; j < notFound.Count; ++j) { sb.Append(notFound[j]); if (i < j) { sb.Append(','); } } m_log.Debug(sb.ToString()); sb.Clear(); } if (existSet.Count > 0) { if (sb == null) { sb = new StringBuilder(512); } i = existSet.Count; sb.Append("[HG ASSET MAPPER POST]: embedded assets already at destination server:\n\t"); foreach (UUID id in existSet) { sb.Append(id); if (--i > 0) { sb.Append(','); } } m_log.Debug(sb.ToString()); sb.Clear(); } if (posted.Count > 0) { if (sb == null) { sb = new StringBuilder(512); } i = posted.Count; sb.Append("[HG ASSET MAPPER POST]: Posted assets:\n\t"); for (int j = 0; j < posted.Count; ++j) { sb.Append(posted[j]); if (i < j) { sb.Append(','); } } m_log.Debug(sb.ToString()); } if (!success) { m_log.DebugFormat("[HG ASSET MAPPER POST]: Problems sending asset {0} to asset server {1}", assetID, userAssetURL); } else { m_log.DebugFormat("[HG ASSET MAPPER POST]: Successfully sent asset {0} to asset server {1}", assetID, userAssetURL); } }
private void CheckContainsReferences(AssetType assetType, bool expected) { AssetBase asset = new AssetBase(UUID.Zero, String.Empty, (sbyte)assetType, UUID.Zero.ToString()); bool actual = asset.ContainsReferences; Assert.AreEqual(expected, actual, "Expected "+assetType+".ContainsReferences to be "+expected+" but was "+actual+"."); }
public bool BuyObject(IClientAPI remoteClient, UUID categoryID, uint localID, byte saleType, int salePrice) { SceneObjectPart rootpart = m_scene.GetSceneObjectPart(localID); if (rootpart == null) { return(false); } SceneObjectGroup group = rootpart.ParentGroup; if (group == null || group.IsDeleted || group.inTransit) { return(false); } // make sure we are not buying a child part rootpart = group.RootPart; switch (saleType) { case 1: // Sell as original (in-place sale) uint effectivePerms = group.EffectiveOwnerPerms; if ((effectivePerms & (uint)PermissionMask.Transfer) == 0) { if (m_dialogModule != null) { m_dialogModule.SendAlertToUser(remoteClient, "This item doesn't appear to be for sale"); } return(false); } group.SetOwner(remoteClient.AgentId, remoteClient.ActiveGroupId); if (m_scene.Permissions.PropagatePermissions()) { foreach (SceneObjectPart child in group.Parts) { child.Inventory.ChangeInventoryOwner(remoteClient.AgentId); child.TriggerScriptChangedEvent(Changed.OWNER); child.ApplyNextOwnerPermissions(); } group.InvalidateDeepEffectivePerms(); } rootpart.ObjectSaleType = 0; rootpart.SalePrice = 10; rootpart.ClickAction = Convert.ToByte(0); group.HasGroupChanged = true; rootpart.SendPropertiesToClient(remoteClient); rootpart.TriggerScriptChangedEvent(Changed.OWNER); group.ResumeScripts(); rootpart.ScheduleFullUpdate(); break; case 2: // Sell a copy uint perms = group.EffectiveOwnerPerms; if ((perms & (uint)PermissionMask.Transfer) == 0) { if (m_dialogModule != null) { m_dialogModule.SendAlertToUser(remoteClient, "This item doesn't appear to be for sale"); } return(false); } if ((perms & (uint)PermissionMask.Copy) == 0) { if (m_dialogModule != null) { m_dialogModule.SendAlertToUser(remoteClient, "This sale has been blocked by the permissions system"); } return(false); } string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(group); string name = rootpart.Name; string desc = rootpart.Description; AssetBase asset = m_scene.CreateAsset( name, desc, (sbyte)AssetType.Object, Utils.StringToBytes(sceneObjectXml), rootpart.CreatorID); m_scene.AssetService.Store(asset); InventoryItemBase item = new InventoryItemBase(); item.CreatorId = rootpart.CreatorID.ToString(); item.CreatorData = rootpart.CreatorData; item.ID = UUID.Random(); item.Owner = remoteClient.AgentId; item.AssetID = asset.FullID; item.Description = desc; item.Name = name; item.AssetType = asset.Type; item.InvType = (int)InventoryType.Object; item.Folder = categoryID; perms = group.CurrentAndFoldedNextPermissions(); // apply parts inventory next perms PermissionsUtil.ApplyNoModFoldedPermissions(perms, ref perms); // change to next owner perms perms &= rootpart.NextOwnerMask; // update folded perms = PermissionsUtil.FixAndFoldPermissions(perms); item.BasePermissions = perms; item.CurrentPermissions = perms; item.NextPermissions = rootpart.NextOwnerMask & perms; item.EveryOnePermissions = rootpart.EveryoneMask & perms; item.GroupPermissions = rootpart.GroupMask & perms; item.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm; item.CreationDate = Util.UnixTimeSinceEpoch(); if (m_scene.AddInventoryItem(item)) { remoteClient.SendInventoryItemCreateUpdate(item, 0); } else { if (m_dialogModule != null) { m_dialogModule.SendAlertToUser(remoteClient, "Cannot buy now. Your inventory is unavailable"); } return(false); } break; case 3: // Sell contents List <UUID> invList = rootpart.Inventory.GetInventoryList(); bool okToSell = true; foreach (UUID invID in invList) { TaskInventoryItem item1 = rootpart.Inventory.GetInventoryItem(invID); if ((item1.CurrentPermissions & (uint)PermissionMask.Transfer) == 0) { okToSell = false; break; } } if (!okToSell) { if (m_dialogModule != null) { m_dialogModule.SendAlertToUser( remoteClient, "This item's inventory doesn't appear to be for sale"); } return(false); } if (invList.Count > 0) { m_scene.MoveTaskInventoryItems(remoteClient.AgentId, rootpart.Name, rootpart, invList); } break; } return(true); }
protected void PreAssetRequestCallback(string fetchedAssetID, object assetType, AssetBase fetchedAsset) { // Check for broken asset types and fix them with the AssetType gleaned by UuidGatherer if (fetchedAsset != null && fetchedAsset.Type == (sbyte) AssetType.Unknown) { AssetType type = (AssetType) assetType; MainConsole.Instance.InfoFormat("[ARCHIVER]: Rewriting broken asset type for {0} to {1}", fetchedAsset.ID, type); fetchedAsset.Type = (sbyte) type; } AssetRequestCallback(fetchedAssetID, this, fetchedAsset); }
private void RetrievedAsset(string id, Object sender, AssetBase asset) { m_missingAssets.Remove(UUID.Parse(id)); TarArchiveWriter writer = (TarArchiveWriter)sender; if (writer == null) { if (m_missingAssets.Count == 0) m_isArchiving = false; return; } //Add the asset WriteAsset(asset, writer); if (m_missingAssets.Count == 0) m_isArchiving = false; }
public void SendTexture(AssetBase TextureAsset) { }
protected void AssetReceived(string id, Object sender, AssetBase asset) { SceneObjectPart sop = (SceneObjectPart)sender; if (sop != null) { if (asset != null) sop.SculptTextureCallback(asset.FullID, asset); } }
private void WriteAsset(AssetBase asset, TarArchiveWriter writer) { writer.WriteFile("assets", asset.Data); }
public AssetMetadata GetMetadata(string id) { AssetBase asset = Get(id); return(asset.Metadata); }
//////////////////////////////////////////////////////////// // IImprovedAssetCache // public void Cache(string assetID, AssetBase asset) { if (asset != null) m_Cache.AddOrUpdate(asset.IDString, asset); }
public byte[] GetData(string id) { AssetBase asset = Get(id); return(asset.Data); }