/// <summary>Saves the specified file.</summary> /// <param name="file">The file.</param> public void Save(string file) { var dirPath = Path.GetDirectoryName(file); // If output directory doesn't exist, we can create it if (dirPath != null && !Directory.Exists(dirPath)) { Directory.CreateDirectory(dirPath); } using (var stream = new NativeFileStream(file, NativeFileMode.Create, NativeFileAccess.Write, NativeFileShare.ReadWrite)) Save(stream); }
public Stream Open(IncludeType type, string fileName, Stream parentStream) { Debug.WriteLine(fileName); // Include dynamic (:D) constants if (fileName.ToLower().Equals("raymarchengine")) { return(GetShaderConstantsStream()); } string currentDirectory = CurrentDirectory.Peek(); if (currentDirectory == null) { #if NETFX_CORE currentDirectory = Windows.ApplicationModel.Package.Current.InstalledLocation.Path; #else currentDirectory = Environment.CurrentDirectory; #endif } string filePath = fileName; if (!Path.IsPathRooted(filePath)) { var directoryToSearch = new List <string> { currentDirectory }; directoryToSearch.AddRange(IncludeDirectories); foreach (string dirPath in directoryToSearch) { string selectedFile = Path.GetFullPath(Path.Combine(dirPath, fileName)); if (NativeFile.Exists(selectedFile)) { filePath = selectedFile; break; } } } if (filePath == null || !NativeFile.Exists(filePath)) { throw new FileNotFoundException(String.Format("Unable to find file [{0}]", filePath ?? fileName)); } NativeFileStream fs = new NativeFileStream(filePath, NativeFileMode.Open, NativeFileAccess.Read); CurrentDirectory.Push(Path.GetDirectoryName(filePath)); return(fs); }
private AudioBufferAndMetaData GetBuffer(string soundfile) { var nativefilestream = new NativeFileStream(soundfile, NativeFileMode.Open, NativeFileAccess.Read, NativeFileShare.Read); var soundstream = new SoundStream(nativefilestream); var buffer = new AudioBufferAndMetaData { Stream = soundstream.ToDataStream(), AudioBytes = (int)soundstream.Length, Flags = BufferFlags.EndOfStream, WaveFormat = soundstream.Format, DecodedPacketsInfo = soundstream.DecodedPacketsInfo }; return(buffer); }
public void Register(string filepath) { CheckSupported(); if (sounds.ContainsKey(filepath)) { return; } var nfs = new NativeFileStream(filepath, NativeFileMode.Open, NativeFileAccess.Read); var decoder = new AudioDecoder(nfs); lock (sounds) sounds.Add(filepath, decoder); var freelist = new Queue <SourceVoice>(); voices.Add(decoder, freelist); }
public static Image2D LoadFromFile(string path, Canvas canvas) { ImagingFactory imagingFactory = new ImagingFactory(); NativeFileStream fileStream = new NativeFileStream(path, NativeFileMode.Open, NativeFileAccess.Read); BitmapDecoder bitmapDecoder = new BitmapDecoder(imagingFactory, fileStream, DecodeOptions.CacheOnDemand); BitmapFrameDecode frame = bitmapDecoder.GetFrame(0); FormatConverter converter = new FormatConverter(imagingFactory); converter.Initialize(frame, PixelFormatWic.Format32bppPRGBA); var result = new Image2D(); result.nativeBitmap = Bitmap2D.FromWicBitmap(canvas.NativeDeviceContext, converter); return(result); }
public void LoadAssetList(string assetListFile) { var serializer = new Serializer(); serializer.Settings.RegisterTagMapping("Asset", typeof(AssetIdentifier)); serializer.Settings.RegisterTagMapping("Assets", typeof(AssetIdentifier[])); AssetIdentifier[] assetList; using (var nativeStream = new NativeFileStream(assetListFile, NativeFileMode.Open, NativeFileAccess.Read)) assetList = serializer.Deserialize <AssetIdentifier[]>(nativeStream); foreach (AssetIdentifier assetIdentifier in assetList) { LoadAsset(assetIdentifier); } OnAssetsLoaded(new AssetsLoadedEventArgs(assetListFile)); }
// Reads a sound and puts it in the dictionary public AudioBuffer AddWave(string key, string filepath) { MyWave wave = new MyWave(); var nativeFileStream = new NativeFileStream(filepath, NativeFileMode.Open, NativeFileAccess.Read, NativeFileShare.Read); var soundStream = new SoundStream(nativeFileStream); var buffer = new AudioBuffer() { Stream = soundStream, AudioBytes = (int)soundStream.Length, Flags = SharpDX.XAudio2.BufferFlags.EndOfStream }; wave.Buffer = buffer; wave.DecodedPacketsInfo = soundStream.DecodedPacketsInfo; wave.WaveFormat = soundStream.Format; this.sounds.Add(key, wave); return(buffer); }
public Bitmap GetBitmap(string file) { string full; System.IO.FileInfo fi = null; if (BitmapFile.ContainsKey(file)) { full = BitmapFile[file]; } else { fi = new System.IO.FileInfo(file); full = fi.FullName; BitmapFile.Add(file, full); } if (Bitmaps.ContainsKey(full)) { return(Bitmaps[full]); } if (fi == null) { fi = new System.IO.FileInfo(full); } if (fi.Exists) { using (var fac = new ImagingFactory()) using (var fs = new NativeFileStream(full, NativeFileMode.Open, NativeFileAccess.Read)) using (var dec = new BitmapDecoder(fac, fs, DecodeOptions.CacheOnDemand)) using (var frame = dec.GetFrame(0)) using (var conv = new FormatConverter(fac)) { conv.Initialize(frame, SharpDX.WIC.PixelFormat.Format32bppPBGRA); var bit = Bitmap.FromWicBitmap(target, conv); Bitmaps[full] = bit; return(bit); } } else { Bitmaps.Add(full, null); return(null); } }
public static Bitmap1 GetBitmap(D2D.DeviceContext context, string filePath) { ImagingFactory imagingFactory = new ImagingFactory(); NativeFileStream fileStream = new NativeFileStream( Package.Current.InstalledLocation.Path + filePath, NativeFileMode.Open, NativeFileAccess.Read); BitmapDecoder bitmapDecoder = new BitmapDecoder( imagingFactory, fileStream, DecodeOptions.CacheOnDemand); BitmapFrameDecode frame = bitmapDecoder.GetFrame(0); FormatConverter converter = new FormatConverter(imagingFactory); converter.Initialize(frame, SharpDX.WIC.PixelFormat.Format32bppPRGBA); return(SharpDX.Direct2D1.Bitmap1.FromWicBitmap(context, converter)); }
//--------------------------------------------------------------------------------------------------------- /// <summary> /// Загрузка рисунка из файла /// </summary> /// <param name="file_name">Имя файла</param> /// <returns>Рисунок Direct2D</returns> //--------------------------------------------------------------------------------------------------------- public static Direct2D.Bitmap LoadFromFile(String file_name) { if (mD2DImagingFactory == null) { mD2DImagingFactory = new ImagingFactory(); } NativeFileStream file_stream = new NativeFileStream(file_name, NativeFileMode.Open, NativeFileAccess.Read); BitmapDecoder bitmap_decoder = new BitmapDecoder(mD2DImagingFactory, file_stream, DecodeOptions.CacheOnDemand); BitmapFrameDecode frame = bitmap_decoder.GetFrame(0); FormatConverter converter = new FormatConverter(mD2DImagingFactory); converter.Initialize(frame, PixelFormat.Format32bppPRGBA); Direct2D.Bitmap bitmap = Direct2D.Bitmap.FromWicBitmap(D2DRenderTarget, converter); return(bitmap); }
public static Bitmap1 CreateD2DBitmap(this DeviceContext deviceContext, string filePath) { var imagingFactory = new ImagingFactory(); var fileStream = new NativeFileStream( filePath, NativeFileMode.Open, NativeFileAccess.Read); var bitmapDecoder = new BitmapDecoder(imagingFactory, fileStream, DecodeOptions.CacheOnDemand); var frame = bitmapDecoder.GetFrame(0); var converter = new FormatConverter(imagingFactory); converter.Initialize(frame, SharpDX.WIC.PixelFormat.Format32bppPRGBA); var newBitmap = Bitmap1.FromWicBitmap(deviceContext, converter); return(newBitmap); }
Bitmap1 createD2DBitmap(string filePath, _d2d.DeviceContext deviceContext) { var imagingFactory = new _wic.ImagingFactory(); var fileStream = new NativeFileStream( filePath, NativeFileMode.Open, NativeFileAccess.Read); var bitmapDecoder = new _wic.BitmapDecoder(imagingFactory, fileStream, _wic.DecodeOptions.CacheOnDemand); var frame = bitmapDecoder.GetFrame(0); var converter = new _wic.FormatConverter(imagingFactory); converter.Initialize(frame, SharpDX.WIC.PixelFormat.Format32bppPRGBA); var newBitmap = SharpDX.Direct2D1.Bitmap1.FromWicBitmap(deviceContext, converter); return(newBitmap); }
private void ReadSoundBytes(string fileName, Channel channel) { var fileStream = new NativeFileStream(fileName, NativeFileMode.Open, NativeFileAccess.Read); var soundStream = new SoundStream(fileStream); var dataStream = soundStream.ToDataStream(); int k = 1; List <short> test = new List <short>(); List <float> test2 = new List <float>(); List <float> test3 = new List <float>(); test.Add(0); test.Add(0); if (channel == Channel.Right) { chartR.Series[0].Points.Clear(); } else { chartL.Series[0].Points.Clear(); } while (dataStream.Length / sizeof(short) > k) { byte[] bytess = new byte[4]; test[1] = dataStream.Read <short>(); test2.Add(test[1]); var y = (100 * test[1]) / short.MaxValue; if (channel == Channel.Right) { chartR.Series[0].Points.AddY(y); } else { chartL.Series[0].Points.AddY(y); } k++; } }
protected override Diagnostics.Logger ProcessFileAndGetLogResults(string inputFilePath, string outputFilePath, string dependencyFilePath, TkItem item) { var compilerFlags = Debug ? EffectCompilerFlags.Debug : EffectCompilerFlags.None; if (!string.IsNullOrEmpty(CompilerFlags)) { compilerFlags |= (EffectCompilerFlags)Enum.Parse(typeof(EffectCompilerFlags), CompilerFlags); } var compilerResult = compiler.CompileFromFile(inputFilePath, compilerFlags, null, null, item.DynamicCompiling, dependencyFilePath); if (!compilerResult.HasErrors && compilerResult.EffectData != null) { CreateDirectoryIfNotExists(outputFilePath); if (item.OutputCs) { var codeWriter = new EffectDataCodeWriter { Namespace = item.OutputNamespace, ClassName = item.OutputClassName, FieldName = item.OutputFieldName, }; using (var stream = new NativeFileStream(outputFilePath, NativeFileMode.Create, NativeFileAccess.Write, NativeFileShare.Write)) codeWriter.Write(compilerResult.EffectData, new StreamWriter(stream, Encoding.UTF8)); } else { compilerResult.EffectData.Save(outputFilePath); } } return(compilerResult.Logger); }
public Stream Open(IncludeType type, string fileName, Stream parentStream) { var currentDirectory = CurrentDirectory.Peek(); if (currentDirectory == null) #if NETFX_CORE { currentDirectory = Windows.ApplicationModel.Package.Current.InstalledLocation.Path; } #else { currentDirectory = Environment.CurrentDirectory; } #endif var filePath = fileName; if (!Path.IsPathRooted(filePath)) { var directoryToSearch = new List <string> { currentDirectory }; directoryToSearch.AddRange(IncludeDirectories); foreach (var dirPath in directoryToSearch) { var selectedFile = Path.Combine(dirPath, fileName); if (NativeFile.Exists(selectedFile)) { filePath = selectedFile; break; } } } if (filePath == null || !NativeFile.Exists(filePath)) { throw new FileNotFoundException(String.Format("Unable to find file [{0}]", filePath ?? fileName)); } NativeFileStream fs = new NativeFileStream(filePath, NativeFileMode.Open, NativeFileAccess.Read); CurrentDirectory.Push(Path.GetDirectoryName(filePath)); return(fs); }
/// <summary> /// Loads a new Texture from a file on disk. /// </summary> /// <param name="device">DirectX device.</param> /// <param name="filename">Path to the texture file.</param> /// <returns></returns> public static async Task <Texture> LoadFromFile(SharpDX.Direct3D11.Device1 device, string filename) { Texture newTexture = new Texture(); newTexture.texturePath = filename; NativeFileStream fileStream = new NativeFileStream(filename, NativeFileMode.Open, NativeFileAccess.Read); using (BinaryReader reader = new BinaryReader(fileStream)) { int width = reader.ReadInt32(); int height = reader.ReadInt32(); int dataLength = reader.ReadInt32(); byte[] data = new byte[dataLength]; data = reader.ReadBytes(dataLength); DataStream stream = new DataStream(dataLength, false, true); stream.Write(data, 0, dataLength); newTexture.texture = new Texture2D(device, new Texture2DDescription() { ArraySize = 1, BindFlags = BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Format = Format.BC3_UNorm, Height = height, MipLevels = 1, OptionFlags = ResourceOptionFlags.None, SampleDescription = new SampleDescription(1, 0), Usage = ResourceUsage.Immutable, Width = width, }, new DataRectangle(stream.DataPointer, width * 4)); newTexture.resourceView = new ShaderResourceView(device, newTexture.texture); } return(newTexture); }
public static void Save(string fullPath, ShaderCollection shaderCollection) { NativeFileStream fs = new NativeFileStream(fullPath, NativeFileMode.Create, NativeFileAccess.Write); try { BinarySerializer bs = new BinarySerializer(fs, SerializerMode.Write) { AllowIdentity = true }; bs.Serialize(ref shaderCollection); } catch (SerializationException e) { LogEvent.Tool.Error(e.Message); throw; } finally { fs.Dispose(); } }
public AudioClip(string wavFilePath, float initialVolumne = 1, bool loopForever = false) { _loopForever = loopForever; _wavFilePath = wavFilePath; _initialVolumne = initialVolumne; var masteringsound = new MasteringVoice(_xaudio); //Yes, this is required. var nativefilestream = new NativeFileStream(wavFilePath, NativeFileMode.Open, NativeFileAccess.Read, NativeFileShare.Read); _soundstream = new SoundStream(nativefilestream); _waveFormat = _soundstream.Format; _buffer = new AudioBuffer { Stream = _soundstream.ToDataStream(), AudioBytes = (int)_soundstream.Length, Flags = BufferFlags.EndOfStream }; if (loopForever) { _buffer.LoopCount = 100; } }
public static ShaderCollection Load(string fullPath) { NativeFileStream fs = new NativeFileStream(fullPath, NativeFileMode.Open, NativeFileAccess.Read); try { ShaderCollection sc = null; BinarySerializer bs = new BinarySerializer(fs, SerializerMode.Read) { AllowIdentity = true }; bs.Serialize(ref sc); return(sc); } catch (SerializationException e) { LogEvent.Tool.Error(e.Message); throw; } finally { fs.Dispose(); } }
/// <summary> /// Loads the specified image from a file. /// </summary> /// <param name="fileName">The filename.</param> /// <returns>An new image.</returns> /// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks> public static Image Load(string fileName) { NativeFileStream stream = null; var memoryPtr = IntPtr.Zero; int size; try { stream = new NativeFileStream(fileName, NativeFileMode.Open, NativeFileAccess.Read); size = (int)stream.Length; memoryPtr = Utilities.AllocateMemory(size); stream.Read(memoryPtr, 0, size); } catch (Exception) { if (memoryPtr != IntPtr.Zero) { Utilities.FreeMemory(memoryPtr); } throw; } finally { try { if (stream != null) { stream.Dispose(); } } catch { } } // If everything was fine, load the image from memory return(Load(memoryPtr, size, false)); }
public void SetAudioHandler(string strFileName, int nVolume) { try { _xAudio2 = new XAudio2(); _masteringVoice = new MasteringVoice(_xAudio2); _masteringVoice.SetVolume(nVolume / 100f, 0); _nativeFilestream = new NativeFileStream(strFileName, NativeFileMode.Open, NativeFileAccess.Read, NativeFileShare.Read); _soundStream = new SoundStream(_nativeFilestream); _waveFormat = _soundStream.Format; _audioBuffer = new AudioBuffer { Stream = _soundStream.ToDataStream(), AudioBytes = (int)_soundStream.Length, Flags = BufferFlags.EndOfStream }; } catch (Exception ex) { DeadlyLog4Net._log.Error($"catch {MethodBase.GetCurrentMethod().Name}", ex); } }
private static AudioBufferAndMetaData GetBuffer(string soundfile) { if (!AudioBuffers.ContainsKey(soundfile)) { var nativefilestream = new NativeFileStream( soundfile, NativeFileMode.Open, NativeFileAccess.Read, NativeFileShare.Read); var soundstream = new SoundStream(nativefilestream); var buffer = new AudioBufferAndMetaData() { Stream = soundstream.ToDataStream(), AudioBytes = (int)soundstream.Length, Flags = BufferFlags.EndOfStream, WaveFormat = soundstream.Format, DecodedPacketsInfo = soundstream.DecodedPacketsInfo }; AudioBuffers[soundfile] = buffer; } return(AudioBuffers[soundfile]); }
/// <summary> /// Loads a Cube texture from a stream. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="filePath">The file to load the texture from.</param> /// <param name="flags">Sets the texture flags (for unordered access...etc.)</param> /// <param name="usage">Usage of the resource. Default is <see cref="ResourceUsage.Immutable"/> </param> /// <exception cref="ArgumentException">If the texture is not of type Cube</exception> /// <returns>A texture</returns> public static new TextureCube Load(GraphicsDevice device, string filePath, TextureFlags flags = TextureFlags.ShaderResource, ResourceUsage usage = ResourceUsage.Immutable) { using (var stream = new NativeFileStream(filePath, NativeFileMode.Open, NativeFileAccess.Read)) return(Load(device, stream, flags | TextureFlags.ShaderResource, usage)); }
void Run(string[] args) { var assemblyUri = new Uri(Assembly.GetEntryAssembly().CodeBase); var assemblyPath = Path.GetDirectoryName(assemblyUri.LocalPath); var newPath = Path.GetFullPath(Path.Combine(assemblyPath, @"..\Redist\D3D\" + (IntPtr.Size == 4 ? "x86" : "x64"))) + ";" + Environment.GetEnvironmentVariable("PATH"); Environment.SetEnvironmentVariable("PATH", newPath); // Print the exe header PrintHeader(); // Parse the command line if (!ParseCommandLine(args)) { Environment.Exit(-1); } var options = this; // ---------------------------------------------------------------- // Process macros // ---------------------------------------------------------------- var macros = new List <EffectData.ShaderMacro>(); foreach (var define in options.Defines) { var nameValue = define.Split('='); string name = nameValue[0]; string value = null; if (nameValue.Length > 1) { value = nameValue[1]; } macros.Add(new EffectData.ShaderMacro(name, value)); } // ---------------------------------------------------------------- // Setup compiler flags // ---------------------------------------------------------------- var flags = EffectCompilerFlags.None; if (options.Debug) { flags |= EffectCompilerFlags.Debug; } switch (options.OptimizationLevel) { case 0: flags |= EffectCompilerFlags.OptimizationLevel0; break; case 1: flags |= EffectCompilerFlags.OptimizationLevel1; break; case 2: flags |= EffectCompilerFlags.OptimizationLevel2; break; case 3: flags |= EffectCompilerFlags.OptimizationLevel3; break; } if (options.PackRowMajor) { flags |= EffectCompilerFlags.PackMatrixRowMajor; } if (options.PackColumnMajor) { flags |= EffectCompilerFlags.PackMatrixColumnMajor; } if (options.AvoidFlowControl) { flags |= EffectCompilerFlags.AvoidFlowControl; } if (options.PreferFlowControl) { flags |= EffectCompilerFlags.PreferFlowControl; } if (options.EnableStrictness) { flags |= EffectCompilerFlags.EnableStrictness; } if (options.EnableBackwardsCompatibility) { flags |= EffectCompilerFlags.EnableBackwardsCompatibility; } if (options.IeeeStrictness) { flags |= EffectCompilerFlags.IeeeStrictness; } hasErrors = false; // ---------------------------------------------------------------- // Process each fx files / tkfxo files // ---------------------------------------------------------------- var fxFile = options.FxFile; var filePath = Path.Combine(Environment.CurrentDirectory, fxFile); // Check that input file exists if (!File.Exists(filePath)) { ErrorColor(); Console.Error.WriteLine("File [{0}] does not exist", fxFile); ResetColor(); Abort(); } // ---------------------------------------------------------------- // Pre check files // ---------------------------------------------------------------- if (options.OutputClassFile == null && options.OutputFile == null) { options.OutputFile = Path.GetFileNameWithoutExtension(options.FxFile) + ".tkb"; } // Check for output files bool outputFileExist = options.OutputClassFile != null && File.Exists(options.OutputClassFile); if (options.OutputFile != null && !File.Exists(options.OutputFile)) { outputFileExist = false; } // New Compiler var compiler = new EffectCompiler(); string outputDependencyDirPath = Path.Combine(Environment.CurrentDirectory, OutputDependencyDirectory); string outputDependencyFilePath = Path.Combine(outputDependencyDirPath, compiler.GetDependencyFileNameFromSourcePath(options.FxFile)); if (AllowDynamicCompiling) { CompileOnlyIfNewer = true; } if (CompileOnlyIfNewer) { if (!compiler.CheckForChanges(outputDependencyFilePath) && outputFileExist) { Console.Error.WriteLine("Nothing to compile. Output file [{0}] is up-to-date", options.OutputFile); Environment.Exit(0); } } var viewOnly = false; // Try to load this file as a precompiled file var effectData = EffectData.Load(fxFile); EffectCompilerResult compilerResult = null; if (effectData != null) { Console.WriteLine("Load Compiled File [{0}]", fxFile); viewOnly = true; } else { // Compile the fx file Console.WriteLine("Compile Effect File [{0}]", filePath); compilerResult = compiler.Compile(File.ReadAllText(filePath), filePath, flags, macros, options.IncludeDirs, AllowDynamicCompiling, CompileOnlyIfNewer ? outputDependencyFilePath : null); // If there is any warning, errors, turn Error color on if (compilerResult.Logger.Messages.Count > 0) { ErrorColor(); } // Show a message error for the current file if (compilerResult.HasErrors) { Console.Error.WriteLine("Error when compiling file [{0}]:", fxFile); hasErrors = true; } // Print all messages (warning and errors) foreach (var logMessage in compilerResult.Logger.Messages) { Console.WriteLine(logMessage); } // If we have some messages, reset the color back if (compilerResult.Logger.Messages.Count > 0) { ResetColor(); } effectData = compilerResult.EffectData; } if (!NoDisassembly && effectData != null) { DumpBytecode(compiler, effectData); } if (hasErrors) { Abort(); } if (!viewOnly) { Console.WriteLine(); if (CompileOnlyIfNewer && compilerResult.DependencyFilePath != null) { // Dependency file save to Console.WriteLine("Save dependency list to [{0}]", outputDependencyFilePath); } if (OutputClassFile != null) { var codeWriter = new EffectDataCodeWriter { Namespace = OutputNamespace, ClassName = OutputClassname ?? Path.GetFileNameWithoutExtension(OutputClassFile), FieldName = OutputFieldName, }; Console.WriteLine("Save C# code output to [{0}]", OutputClassFile); using (var stream = new NativeFileStream(OutputClassFile, NativeFileMode.Create, NativeFileAccess.Write, NativeFileShare.Write)) codeWriter.Write(effectData, new StreamWriter(stream, Encoding.UTF8)); } if (options.OutputFile != null) { Console.WriteLine("Save binary output to [{0}]", options.OutputFile); // Save the result effectData.Save(options.OutputFile); } } }
public FileStream(String path, FileMode mode, FileAccess access, FileShare share, int bufferSize) { // This will perform validation on path _fileName = Path.GetFullPath(path); // make sure mode, access, and share are within range if (mode < FileMode.CreateNew || mode > FileMode.Append || access < FileAccess.Read || access > FileAccess.ReadWrite || share < FileShare.None || share > FileShare.ReadWrite) { throw new ArgumentOutOfRangeException(); } // Get wantsRead and wantsWrite from access, note that they cannot both be false bool wantsRead = (access & FileAccess.Read) == FileAccess.Read; bool wantsWrite = (access & FileAccess.Write) == FileAccess.Write; // You can't open for readonly access (wantsWrite == false) when // mode is CreateNew, Create, Truncate or Append (when it's not Open or OpenOrCreate) if (mode != FileMode.Open && mode != FileMode.OpenOrCreate && !wantsWrite) { throw new ArgumentException(); } // We need to register the share information prior to the actual file open call (the NativeFileStream ctor) // so subsequent file operation on the same file will behave correctly _fileRecord = FileSystemManager.AddToOpenList(_fileName, (int)access, (int)share); try { uint attributes = NativeIO.GetAttributes(_fileName); bool exists = (attributes != 0xFFFFFFFF); bool isReadOnly = (exists) ? (((FileAttributes)attributes) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly : false; // If the path specified is an existing directory, fail if (exists && ((((FileAttributes)attributes) & FileAttributes.Directory) == FileAttributes.Directory)) { throw new IOException("", (int)IOException.IOExceptionErrorCode.UnauthorizedAccess); } // The seek limit is 0 (the beginning of the file) for all modes except Append _seekLimit = 0; switch (mode) { case FileMode.CreateNew: // if the file exists, IOException is thrown if (exists) { throw new IOException("", (int)IOException.IOExceptionErrorCode.PathAlreadyExists); } _nativeFileStream = new NativeFileStream(_fileName, bufferSize); break; case FileMode.Create: // if the file exists, it should be overwritten _nativeFileStream = new NativeFileStream(_fileName, bufferSize); if (exists) { _nativeFileStream.SetLength(0); } break; case FileMode.Open: // if the file does not exist, IOException/FileNotFound is thrown if (!exists) { throw new IOException("", (int)IOException.IOExceptionErrorCode.FileNotFound); } _nativeFileStream = new NativeFileStream(_fileName, bufferSize); break; case FileMode.OpenOrCreate: // if the file does not exist, it is created _nativeFileStream = new NativeFileStream(_fileName, bufferSize); break; case FileMode.Truncate: // the file would be overwritten. if the file does not exist, IOException/FileNotFound is thrown if (!exists) { throw new IOException("", (int)IOException.IOExceptionErrorCode.FileNotFound); } _nativeFileStream = new NativeFileStream(_fileName, bufferSize); _nativeFileStream.SetLength(0); break; case FileMode.Append: // Opens the file if it exists and seeks to the end of the file. Append can only be used in conjunction with FileAccess.Write // Attempting to seek to a position before the end of the file will throw an IOException and any attempt to read fails and throws an NotSupportedException if (access != FileAccess.Write) { throw new ArgumentException(); } _nativeFileStream = new NativeFileStream(_fileName, bufferSize); _seekLimit = _nativeFileStream.Seek(0, (uint)SeekOrigin.End); break; // We've already checked the mode value previously, so no need for default //default: // throw new ArgumentOutOfRangeException(); } // Now that we have a valid NativeFileStream, we add it to the FileRecord, so it could gets clean up // in case an eject or force format _fileRecord.NativeFileStream = _nativeFileStream; // Retrive the filesystem capabilities _nativeFileStream.GetStreamProperties(out _canRead, out _canWrite, out _canSeek); // If the file is readonly, regardless of the filesystem capability, we'll turn off write if (isReadOnly) { _canWrite = false; } // Make sure the requests (wantsRead / wantsWrite) matches the filesystem capabilities (canRead / canWrite) if ((wantsRead && !_canRead) || (wantsWrite && !_canWrite)) { throw new IOException("", (int)IOException.IOExceptionErrorCode.UnauthorizedAccess); } // finally, adjust the _canRead / _canWrite to match the requests if (!wantsWrite) { _canWrite = false; } else if (!wantsRead) { _canRead = false; } } catch { // something went wrong, clean up and re-throw the exception if (_nativeFileStream != null) { _nativeFileStream.Close(); } FileSystemManager.RemoveFromOpenList(_fileRecord); throw; } }
public void CheckFileStreamException() { var test = new NativeFileStream("blabla", NativeFileMode.Open, NativeFileAccess.Read); }
/// <summary> /// Saves this <see cref="ModelData"/> instance to the specified file. /// </summary> /// <param name="fileName">The output filename.</param> public void Save(string fileName) { using (var stream = new NativeFileStream(fileName, NativeFileMode.Create, NativeFileAccess.Write, NativeFileShare.Write)) Save(stream); }
/// <summary> /// Loads an <see cref="ModelData"/> from the specified file. /// </summary> /// <param name="fileName">The filename.</param> /// <returns>A <see cref="ModelData"/> </returns> public static ModelData Load(string fileName) { using (var stream = new NativeFileStream(fileName, NativeFileMode.Open, NativeFileAccess.Read)) return(Load(stream)); }
public static FileDependencyList FromFile(string file) { using (var stream = new NativeFileStream(file, NativeFileMode.Open, NativeFileAccess.Read, NativeFileShare.ReadWrite)) return(FromStream(stream)); }
/// <summary> /// Loads a model from a file on disk. /// </summary> /// <param name="device">DirectX device.</param> /// <param name="filename">Path of the model.</param> /// <returns>Loaded model.</returns> public static Model Load(SharpDX.Direct3D11.Device1 device, string filename) { Model newModel = new Model(); newModel.modelPath = filename; NativeFileStream fileStream = new NativeFileStream(filename, NativeFileMode.Open, NativeFileAccess.Read); using (BinaryReader reader = new BinaryReader(fileStream)) { Vector3 bbMin; Vector3 bbMax; bbMin.X = reader.ReadSingle(); bbMin.Y = reader.ReadSingle(); bbMin.Z = reader.ReadSingle(); bbMax.X = reader.ReadSingle(); bbMax.Y = reader.ReadSingle(); bbMax.Z = reader.ReadSingle(); newModel.BBox = new BoundingBox(bbMin, bbMax); int numMeshes = reader.ReadInt32(); for (int i = 0; i < numMeshes; i++) { List <ModelVertex> vertices = new List <ModelVertex>(); List <int> indices = new List <int>(); List <int> invertedIndices = new List <int>(); int numVertices = reader.ReadInt32(); for (int j = 0; j < numVertices; j++) { float x = reader.ReadSingle(); float y = reader.ReadSingle(); float z = reader.ReadSingle(); float s = reader.ReadSingle(); float t = reader.ReadSingle(); vertices.Add(new ModelVertex(new Vector3(x, y, z), new Vector2(s, t))); } int numIndices = reader.ReadInt32(); for (int j = 0; j < numIndices; j++) { int index = reader.ReadInt32(); indices.Add(index); invertedIndices.Add(index); if ((j > 0) && ((j + 1) % 3 == 0)) { int tempIndex = invertedIndices[j - 1]; invertedIndices[j - 1] = invertedIndices[j]; invertedIndices[j] = tempIndex; } } Buffer vertexBuffer = Buffer.Create(device, BindFlags.VertexBuffer, vertices.ToArray()); Buffer indexBuffer = Buffer.Create(device, BindFlags.IndexBuffer, indices.ToArray()); Buffer invertedIndexBuffer = Buffer.Create(device, BindFlags.IndexBuffer, invertedIndices.ToArray()); newModel.meshes.Add(new ModelMesh(vertexBuffer, indexBuffer, invertedIndexBuffer, numIndices)); } } return(newModel); }
/// <summary> /// Initializes a new wave bank from the file located at the provided file path. /// </summary> /// <param name="audioManager">The associated audio manager.</param> /// <param name="filePath">The path to the wave bank file.</param> /// <returns>The wave bank initialized from provided file.</returns> public static WaveBank FromFile(AudioManager audioManager, string filePath) { using (var stream = new NativeFileStream(filePath, NativeFileMode.Open, NativeFileAccess.Read)) return new WaveBank(audioManager, stream); }
/// <summary> /// Creates a new instance of the <see cref="SoundEffect"/> class from the specified file path. /// </summary> /// <param name="audioManager">The audio manager associated to the created instance.</param> /// <param name="filePath">The path to the file from which to create the effect.</param> /// <returns>The created effect.</returns> public static SoundEffect FromFile(AudioManager audioManager, string filePath) { using (var stream = new NativeFileStream(filePath, NativeFileMode.Open, NativeFileAccess.Read)) return FromStream(audioManager, stream, Path.GetFileNameWithoutExtension(filePath)); }