public override Texture Load(IResource resource, LoaderParameters parameters) { Stream stream = resource.OpenStream(); BinaryReader input = new BinaryReader(stream); DDSImageInfo image = ReadHeaderInfo(input); SurfaceFormat format = DetermineFormat(image); TextureDimensions dimensions = DetermineTextureDimensions(image); switch (dimensions) { case TextureDimensions.Two: Texture2D tex2d = LoadTexture2D(image, input, format); tex2d.Name = resource.Name; input.Close(); return(tex2d); case TextureDimensions.Three: Texture3D tex3d = LoadTexture3D(image, input, format); tex3d.Name = resource.Name; input.Close(); return(tex3d); case TextureDimensions.Cube: TextureCube texcube = LoadTextureCube(image, input, format); texcube.Name = resource.Name; input.Close(); return(texcube); default: input.Close(); throw new InvalidOperationException("Error loading DDS file"); } }
/// <summary> /// Load the DXS model. If the model is a single mesh, Mesh will /// be returned. Otherwise Node will be returned. /// </summary> /// <param name="resource">Dxs resource</param> /// <param name="parameters">Model loader parameters, must be of type ModelLoaderParameters otherwise it's ignored.</param> /// <returns>The model</returns> public override Spatial Load(IResource resource, LoaderParameters parameters) { _parser.Reset(); ModelLoaderParameters modelParams = parameters as ModelLoaderParameters; if (modelParams == null) { modelParams = _defaultParams; } DxsNode dxsModel; using (Stream stream = resource.OpenStream()) { dxsModel = _parser.Parse(stream, resource.Name); } Node root = new Node(dxsModel.Name); foreach (DxsNode node in dxsModel.Children) { ParseDxsTree(node, root, modelParams); } if (root.Count == 1 && root[0] is Mesh) { Spatial s = root[0]; s.RemoveFromParent(); return(s); } return(root); }
/// <summary> /// Loads the specified resource. /// </summary> /// <param name="resource">The resource to load.</param> /// <param name="parameters">Loader parameters.</param> /// <returns>The loaded MaterialCollection</returns> public override MaterialCollection Load(IResource resource, LoaderParameters parameters) { if (_parser == null) { _parser = new MaterialParser(ContentManager); } return(_parser.LoadAllMaterials(resource, parameters)); }
protected TExpectedType ValidateParameterType <TExpectedType>(LoaderParameters parameters) where TExpectedType : LoaderParameters { if (!(parameters is TExpectedType aParameters)) { throw new Exception($"{nameof(LoaderParameters)} are of the wrong type: {parameters.GetType().Name}"); } return(aParameters); }
public override Texture Load(IResource resource, LoaderParameters parameters) { ImageLoaderParameters imageParams = parameters as ImageLoaderParameters; if (imageParams == null) { imageParams = new ImageLoaderParameters(); } return(m_translator.Load(resource, m_imageType, imageParams)); }
public override Object Load(IResource resource, Type type, LoaderParameters parameters) { if (type.Equals(this.TargetType)) { return(Load(resource, parameters)); } else { throw new InvalidCastException("Invalid type to load, must be an Effect."); } }
/// <summary> /// Loads the specified resource. /// </summary> /// <param name="resource">The resource to load</param> /// <param name="parameters">Loader parameters</param> /// <returns>The loaded resource</returns> public override Spatial Load(IResource resource, LoaderParameters parameters) { ModelLoaderParameters modelParams = parameters as ModelLoaderParameters; if (modelParams == null) { modelParams = new ModelLoaderParameters(); } return(m_translator.Load(resource, base.Extension, modelParams)); }
/// <summary> /// Loads the specified resource. /// </summary> /// <param name="resource">The resource to load</param> /// <param name="parameters">Any loading parameters</param> /// <exception cref="System.IO.InvalidDataException">Thrown if the stream does not contain a valid TEBO file.</exception> /// <returns>The loaded resource</returns> public override ISavable Load(IResource resource, LoaderParameters parameters) { //Read header Stream stream = resource.OpenStream(); if (!ReadHeader(stream)) { throw new InvalidDataException("Invalid binary file, either it is not a tesla engine binary object or the version is not compatible."); } BinarySavableReader reader = new BinarySavableReader(stream, ContentManager); ISavable savable = reader.ReadSavable <ISavable>(); reader.Dispose(); return(savable); }
public override Texture Load(IResource resource, LoaderParameters parameters) { Stream str = resource.OpenStream(); SD.Bitmap bitmap = new SD.Bitmap(str); ImageLoaderParameters imageParams = parameters as ImageLoaderParameters; if (imageParams != null) { if (imageParams.FlipImage) { bitmap.RotateFlip(SD.RotateFlipType.RotateNoneFlipY); } } byte[] data = GetData(bitmap); SD.Imaging.PixelFormat pixelFormat = bitmap.PixelFormat; Color[] colors = null; switch (pixelFormat) { case SD.Imaging.PixelFormat.Format32bppArgb: colors = GetRGBA(bitmap, data); break; case SD.Imaging.PixelFormat.Format24bppRgb: colors = GetRGB(bitmap, data); break; case SD.Imaging.PixelFormat.Format8bppIndexed: colors = GetIndexed(bitmap, data); break; default: throw new InvalidOperationException("Cannot read from that format encoding"); } Texture2D tex = new Texture2D(bitmap.Width, bitmap.Height, true, SurfaceFormat.Color, new DataBuffer <Color>(colors)); tex.Name = resource.Name; bitmap.Dispose(); str.Close(); return(tex); }
/// <summary> /// Loads an Effect from the resource. /// </summary> /// <param name="resource">Resource that references the FX file</param> /// <param name="parameters">Loader parameters</param> /// <returns>Compiled effect</returns> public override Effect Load(IResource resource, LoaderParameters parameters) { EffectInclude include = new EffectInclude(ContentManager, Path.GetDirectoryName(resource.FullName)); D3DC.ShaderBytecode byteCode = D3DC.ShaderBytecode.CompileFromFile(resource.FullName, "fx_4_0", D3DC.ShaderFlags.None, D3DC.EffectFlags.None, null, include); byte[] bytes = new byte[byteCode.Data.Length]; System.IntPtr ptr = Tesla.Util.MemoryHelper.PinObject(bytes); Tesla.Util.MemoryHelper.Copy(byteCode.Data.DataPointer, ptr, bytes.Length); Tesla.Util.MemoryHelper.UnpinObject(bytes); byteCode.Dispose(); Effect e = new Effect(bytes); e.Name = resource.Name; return(e); }
protected override void Load(LoaderParameters parameters) { var tParameters = ValidateParameterType <AddressableLoaderParameters>(parameters); switch (tParameters.behaviour) { case LoaderBehaviour.Asset: { LoadAsset(); break; } case LoaderBehaviour.Scene: { LoadSceneAsync(tParameters); break; } } }
public override Effect Load(IResource resource, LoaderParameters parameters) { FileInfo info = new FileInfo(resource.FullName); if (!info.Exists) { throw new FileNotFoundException("Effect file does not exist in directory"); } EffectContent content = new EffectContent(); content.Identity = new ContentIdentity(resource.FullName); content.EffectCode = File.ReadAllText(resource.FullName); CompiledEffectContent compiled = _processor.Process(content, _xnaContext); Effect effect = new Effect(compiled.GetEffectCode()); effect.Name = resource.Name; return(effect); }
protected override void Load(LoaderParameters parameters) { status = ContentAsyncStatus.Loading; if (!ValidateLoadOperation(parameters)) { status = ContentAsyncStatus.Failed; OnLoadCompleted(); return; } var job = GetLoadJob(parameters); if (job == null) { status = ContentAsyncStatus.Failed; return; } handler.Schedule(this, job); }
protected override void Unload(LoaderParameters parameters) { if (!(parameters is AddressableLoaderParameters aParameters)) { throw new Exception($"{nameof(LoaderParameters)} are of the wrong type: {parameters.GetType().Name}"); } switch (aParameters.behaviour) { case LoaderBehaviour.Asset: { UnloadAsset(); break; } case LoaderBehaviour.Scene: { UnloadSceneAsync(); break; } } }
protected override LoadJob GetLoadJob(LoaderParameters parameters) { this.parameters = ValidateParameterType <LocalLoaderParameters>(parameters); switch (this.parameters.format) { case LocalAssetFormat.Byte: { return(new ReadAllBytes(contentPath.FileInfo.FullName)); } case LocalAssetFormat.Text: { return(new ReadAllText(contentPath.FileInfo.FullName)); } case LocalAssetFormat.Lines: { return(new ReadAllLines(contentPath.FileInfo.FullName)); } } return(null); }
public override SpriteFont Load(IResource resource, LoaderParameters parameters) { document.RemoveAll(); document.Load(resource.OpenStream()); XmlNode fontNode = GetFontNode(); XmlNode charsNode; XmlNode kerningsNode; String texturePath; int lineHeight; GetFontData(fontNode, out texturePath, out lineHeight, out charsNode, out kerningsNode); Texture2D texture = ContentManager.LoadRelativeTo <Texture2D>(texturePath, resource); Glyph? defaultChar = GetDefaultCharacter(texture, charsNode); SpriteFont spriteFont; if (defaultChar.HasValue) { spriteFont = new SpriteFont(texture, lineHeight, defaultChar.Value); } else { spriteFont = new SpriteFont(texture, lineHeight); } GetCharacters(spriteFont, charsNode); if (kerningsNode != null) { GetKernings(spriteFont, kerningsNode); } return(spriteFont); }
protected abstract LoadJob GetLoadJob(LoaderParameters parameters);
protected virtual bool ValidateLoadOperation(LoaderParameters parameters) { return(contentPath.FileInfo.Exists); }
protected override void Unload(LoaderParameters parameters) { byteData = null; textData = null; linesData = null; }
public void SetLoadContextParameters(LoaderParameters parameters) { this.parameters = parameters; }