private Shader(GraphicsDevice device, ShaderStage shaderStage, byte[] shaderStageBytecode) : base(device) { this.stage = shaderStage; var shaderStageGl = ConvertShaderStage(shaderStage); // Decode shader StageBytecode var binarySerializationReader = new BinarySerializationReader(new MemoryStream(shaderStageBytecode)); var shaderBytecodeData = new OpenGLShaderBytecodeData(); shaderBytecodeData.Serialize(binarySerializationReader, ArchiveMode.Deserialize); using (GraphicsDevice.UseOpenGLCreationContext()) { resourceId = GL.CreateShader(shaderStageGl); if (shaderBytecodeData.IsBinary) { GL.ShaderBinary(1, ref resourceId, (BinaryFormat)shaderBytecodeData.BinaryFormat, shaderBytecodeData.Binary, shaderBytecodeData.Binary.Length); } else { GL.ShaderSource(resourceId, shaderBytecodeData.Source); GL.CompileShader(resourceId); var log = GL.GetShaderInfoLog(resourceId); int compileStatus; GL.GetShader(resourceId, ShaderParameter.CompileStatus, out compileStatus); if (compileStatus != 1) throw new InvalidOperationException(string.Format("Error while compiling GLSL shader: {0}", log)); } } }
private Shader(GraphicsDevice device, ShaderStage shaderStage, byte[] shaderBytecode) : base(device) { this.stage = shaderStage; switch (shaderStage) { case ShaderStage.Vertex: NativeDeviceChild = new VertexShader(device.NativeDevice, shaderBytecode); NativeInputSignature = shaderBytecode; break; case ShaderStage.Hull: NativeDeviceChild = new HullShader(device.NativeDevice, shaderBytecode); break; case ShaderStage.Domain: NativeDeviceChild = new DomainShader(device.NativeDevice, shaderBytecode); break; case ShaderStage.Geometry: NativeDeviceChild = new GeometryShader(device.NativeDevice, shaderBytecode); break; case ShaderStage.Pixel: NativeDeviceChild = new PixelShader(device.NativeDevice, shaderBytecode); break; case ShaderStage.Compute: NativeDeviceChild = new ComputeShader(device.NativeDevice, shaderBytecode); break; default: throw new ArgumentOutOfRangeException("shaderStage"); } }
/// <summary> /// Creates a texture from an image file data (png, dds, ...). /// </summary> /// <param name="graphicsDevice">The graphics device in which to create the texture</param> /// <param name="data">The image file data</param> /// <returns>The texture</returns> public static Texture FromFileData(GraphicsDevice graphicsDevice, byte[] data) { Texture result; var loadAsSRgb = graphicsDevice.ColorSpace == ColorSpace.Linear; using (var imageStream = new MemoryStream(data)) { using (var image = Image.Load(imageStream, loadAsSRgb)) { result = Texture.New(graphicsDevice, image); } } result.Reload = graphicsResource => { using (var imageStream = new MemoryStream(data)) { using (var image = Image.Load(imageStream, loadAsSRgb)) { ((Texture)graphicsResource).Recreate(image.ToDataBox()); } } }; return result; }
internal DepthStencilBuffer(GraphicsDevice device, Texture2D depthTexture, bool isReadOnly) : base(device) { DescriptionInternal = depthTexture.Description; depthTexture.AddReferenceInternal(); Texture = depthTexture; resourceId = Texture.ResourceId; if (Description.Format == PixelFormat.D24_UNorm_S8_UInt || Description.Format == PixelFormat.D32_Float_S8X24_UInt) { IsDepthBuffer = true; IsStencilBuffer = true; } else if (Description.Format == PixelFormat.D32_Float || Description.Format == PixelFormat.D16_UNorm) { IsDepthBuffer = true; IsStencilBuffer = false; } else throw new NotSupportedException("The provided depth stencil format is currently not supported"); // implement composition for other formats #if !SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES if (isReadOnly) { if (device.versionMajor < 4) { needReadOnlySynchronization = true; throw new NotImplementedException(); } } #endif }
public SwapChainGraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters) : base(device, presentationParameters) { gameWindow = (iPhoneOSGameView)Description.DeviceWindowHandle.NativeHandle; device.InitDefaultRenderTarget(presentationParameters); backBuffer = Texture.New2D(device, Description.BackBufferWidth, Description.BackBufferHeight, presentationParameters.BackBufferFormat, TextureFlags.RenderTarget | TextureFlags.ShaderResource); }
private DepthStencilState(GraphicsDevice device, DepthStencilStateDescription depthStencilStateDescription) : base(device) { Description = depthStencilStateDescription; depthFunction = Description.DepthBufferFunction.ToOpenGLDepthFunction(); }
/// <summary> /// Initializes a new instance of the <see cref="BlendStateFactory"/> class. /// </summary> /// <param name="device">The device.</param> internal BlendStateFactory(GraphicsDevice device) { var blendDescription = new BlendStateDescription(Blend.One, Blend.Zero); blendDescription.SetDefaults(); Default = BlendState.New(device, blendDescription).DisposeBy(device); Default.Name = "Default"; Additive = BlendState.New(device, new BlendStateDescription(Blend.SourceAlpha, Blend.One)).DisposeBy(device); Additive.Name = "Additive"; AlphaBlend = BlendState.New(device, new BlendStateDescription(Blend.One, Blend.InverseSourceAlpha)).DisposeBy(device); AlphaBlend.Name = "AlphaBlend"; NonPremultiplied = BlendState.New(device, new BlendStateDescription(Blend.SourceAlpha, Blend.InverseSourceAlpha)).DisposeBy(device); NonPremultiplied.Name = "NonPremultiplied"; Opaque = BlendState.New(device, new BlendStateDescription(Blend.One, Blend.Zero)).DisposeBy(device); Opaque.Name = "Opaque"; var colorDisabledDescription = new BlendStateDescription(); colorDisabledDescription.SetDefaults(); colorDisabledDescription.RenderTargets[0].ColorWriteChannels = ColorWriteChannels.None; ColorDisabled = BlendState.New(device, colorDisabledDescription).DisposeBy(device); ColorDisabled.Name = "ColorDisabled"; }
public SwapChainGraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters) : base(device, presentationParameters) { gameWindow = (iPhoneOSGameView)Description.DeviceWindowHandle.NativeHandle; device.InitDefaultRenderTarget(presentationParameters); backBuffer = device.DefaultRenderTarget; DepthStencilBuffer = device.windowProvidedDepthTexture; }
/// <summary> /// Initializes a new instance of the <see cref="DepthStencilState"/> class. /// </summary> /// <param name="depthEnable">if set to <c>true</c> [depth enable].</param> /// <param name="depthWriteEnable">if set to <c>true</c> [depth write enable].</param> /// <param name="name">The name.</param> private DepthStencilState(GraphicsDevice device, DepthStencilStateDescription depthStencilStateDescription) : base(device) { Description = depthStencilStateDescription; CreateNativeDeviceChild(); }
public override MeshDraw CreateDebugPrimitive(GraphicsDevice device) { if (cachedDebugPrimitive != null) return cachedDebugPrimitive; var verts = new VertexPositionNormalTexture[pointsList.Count]; for (var i = 0; i < pointsList.Count; i++) { verts[i].Position = pointsList[i]; verts[i].TextureCoordinate = Vector2.Zero; verts[i].Normal = Vector3.Zero; } var intIndices = indicesList.Select(x => (int)x).ToArray(); ////calculate basic normals ////todo verify, winding order might be wrong? for (var i = 0; i < indicesList.Count; i += 3) { var i1 = intIndices[i]; var i2 = intIndices[i + 1]; var i3 = intIndices[i + 2]; var a = verts[i1]; var b = verts[i2]; var c = verts[i3]; var n = Vector3.Cross((b.Position - a.Position), (c.Position - a.Position)); n.Normalize(); verts[i1].Normal = verts[i2].Normal = verts[i3].Normal = n; } var meshData = new GeometricMeshData<VertexPositionNormalTexture>(verts, intIndices, false); cachedDebugPrimitive = new GeometricPrimitive(device, meshData).ToMeshDraw(); return cachedDebugPrimitive; }
internal GraphicsDeviceFeatures(GraphicsDevice deviceRoot) { mapFeaturesPerFormat = new FeaturesPerFormat[256]; IsProfiled = false; using (deviceRoot.UseOpenGLCreationContext()) { Vendor = GL.GetString(StringName.Vendor); Renderer = GL.GetString(StringName.Renderer); #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES SupportedExtensions = GL.GetString(StringName.Extensions).Split(' '); #else int numExtensions; GL.GetInteger(GetPName.NumExtensions, out numExtensions); SupportedExtensions = new string[numExtensions]; for (int extensionIndex = 0; extensionIndex < numExtensions; ++extensionIndex) { SupportedExtensions[extensionIndex] = GL.GetString(StringName.Extensions, extensionIndex); } #endif } #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES var isOpenGLES3 = deviceRoot.versionMajor >= 3; deviceRoot.HasDepth24 = isOpenGLES3 || SupportedExtensions.Contains("GL_OES_depth24"); deviceRoot.HasPackedDepthStencilExtension = SupportedExtensions.Contains("GL_OES_packed_depth_stencil"); deviceRoot.HasExtTextureFormatBGRA8888 = SupportedExtensions.Contains("GL_EXT_texture_format_BGRA8888") || SupportedExtensions.Contains("GL_APPLE_texture_format_BGRA8888"); deviceRoot.HasRenderTargetFloat = SupportedExtensions.Contains("GL_EXT_color_buffer_float"); deviceRoot.HasRenderTargetHalf = SupportedExtensions.Contains("GL_EXT_color_buffer_half_float"); deviceRoot.HasVAO = isOpenGLES3 || SupportedExtensions.Contains("GL_OES_vertex_array_object"); // Compute shaders available in OpenGL ES 3.1 HasComputeShaders = isOpenGLES3 && deviceRoot.versionMinor >= 1; HasDoublePrecision = false; // TODO: from 3.1: draw indirect, separate shader object // TODO: check tessellation & geometry shaders: GL_ANDROID_extension_pack_es31a #else deviceRoot.HasVAO = true; // Compute shaders available in OpenGL 4.3 HasComputeShaders = deviceRoot.versionMajor >= 4 && deviceRoot.versionMinor >= 3; HasDoublePrecision = SupportedExtensions.Contains("GL_ARB_vertex_attrib_64bit"); // TODO: from 4.0: tessellation, draw indirect // TODO: from 4.1: separate shader object #endif HasDriverCommandLists = false; HasMultiThreadingConcurrentResources = false; // TODO: Enum supported formats in mapFeaturesPerFormat // Find shader model based on OpenGL version (might need to check extensions more carefully) Profile = OpenGLUtils.GetFeatureLevel(deviceRoot.versionMajor, deviceRoot.versionMinor); }
protected internal Texture3D(GraphicsDevice device, TextureDescription description3D, DataBox[] dataBoxes = null) : base(device, description3D, ViewType.Full, 0, 0) { #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES throw new NotImplementedException(); #else Target = TextureTarget.Texture3D; #endif }
/// <summary> /// Initializes a new instance of the <see cref="Buffer" /> class. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/>.</param> /// <param name="description">The description.</param> /// <param name="bufferFlags">Type of the buffer.</param> /// <param name="viewFormat">The view format.</param> /// <param name="dataPointer">The data pointer.</param> protected Buffer(GraphicsDevice device, BufferDescription description, BufferFlags bufferFlags, PixelFormat viewFormat, IntPtr dataPointer) : base(device) { Description = description; BufferFlags = bufferFlags; ViewFormat = viewFormat; //InitCountAndViewFormat(out this.elementCount, ref ViewFormat); //Initialize(device.RootDevice, null); }
protected internal Texture3D(GraphicsDevice device, Texture3D texture) : base(device, texture, ViewType.Full, 0, 0) { #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES throw new NotImplementedException(); #else Target = TextureTarget.Texture3D; #endif }
public PhysicsDebugEffect(GraphicsDevice graphicsDevice) : base(graphicsDevice, bytecode ?? (bytecode = EffectBytecode.FromBytesSafe(binaryBytecode))) { parameters = new ParameterCollection(); Color = new Color4(1.0f); WorldViewProj = Matrix.Identity; UseUv = true; }
public SwapChainGraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters) : base(device, presentationParameters) { device.InitDefaultRenderTarget(Description); //backBuffer = device.DefaultRenderTarget; // TODO: Review Depth buffer creation for both Android and iOS //DepthStencilBuffer = device.windowProvidedDepthTexture; backBuffer = Texture.New2D(device, Description.BackBufferWidth, Description.BackBufferHeight, presentationParameters.BackBufferFormat, TextureFlags.RenderTarget | TextureFlags.ShaderResource); }
private static Texture CreateWhiteTexture(GraphicsDevice device) { const int Size = 2; var whiteData = new Color[Size * Size]; for (int i = 0; i < Size*Size; i++) whiteData[i] = Color.White; return Texture.New2D(device, Size, Size, PixelFormat.R8G8B8A8_UNorm, whiteData); }
/// <summary> /// Initializes a new instance of the <see cref="PrimitiveQuad" /> class with a particular effect. /// </summary> /// <param name="graphicsDevice">The graphics device.</param> /// <param name="effect">The effect.</param> public PrimitiveQuad(GraphicsDevice graphicsDevice, Effect effect) { GraphicsDevice = graphicsDevice; simpleEffect = effect; parameters = new ParameterCollection(); parameters.Set(SpriteBaseKeys.MatrixTransform, Matrix.Identity); parameterCollectionGroup = new EffectParameterCollectionGroup(graphicsDevice, simpleEffect, new[] { parameters }); sharedData = GraphicsDevice.GetOrCreateSharedData(GraphicsDeviceSharedDataType.PerDevice, "PrimitiveQuad::VertexBuffer", d => new SharedData(GraphicsDevice, simpleEffect.InputSignature)); }
private VertexArrayObject(GraphicsDevice graphicsDevice, EffectInputSignature shaderSignature, IndexBufferBinding indexBufferBinding, VertexBufferBinding[] vertexBufferBindings) : base(graphicsDevice) { this.vertexBufferBindings = vertexBufferBindings; this.indexBufferBinding = indexBufferBinding; this.preferredInputSignature = shaderSignature; CreateAttributes(); }
/// <summary> /// Initializes a new instance of the <see cref="BlendState"/> class. /// </summary> /// <param name="device">The device.</param> /// <param name="name">The name.</param> /// <param name="blendStateDescription">The blend state description.</param> internal BlendState(GraphicsDevice device, BlendStateDescription blendStateDescription) : base(device) { BlendFactor = SiliconStudio.Core.Mathematics.Color4.White; MultiSampleMask = -1; Description = blendStateDescription; CreateNativeDeviceChild(); }
public LightShadowProcessorWithBudget(GraphicsDevice device, bool manageShadows) : base(device, manageShadows) { shadowMapDefaultTextures = new List<ShadowMapTexture>(); shadowMapVsmTextures = new List<ShadowMapTexture>(); texturesDefault = new Dictionary<ShadowMapTexture, int>(); texturesVsm = new Dictionary<ShadowMapTexture, int>(); activeLightShadowMaps = new List<EntityLightShadow>(); }
private RasterizerState(GraphicsDevice device, RasterizerStateDescription rasterizerStateDescription) : base(device) { Description = rasterizerStateDescription; #if !SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES polygonMode = Description.FillMode == FillMode.Solid ? PolygonMode.Fill : PolygonMode.Line; #endif // TODO: DepthBiasClamp and various other properties are not fully supported yet if (Description.DepthBiasClamp != 0.0f) throw new NotSupportedException(); }
/// <summary> /// Initializes a new instance of the <see cref="GraphicsPresenter" /> class. /// </summary> /// <param name="device">The device.</param> /// <param name="presentationParameters"> </param> protected GraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters) { GraphicsDevice = device.RootDevice; Description = presentationParameters.Clone(); ProcessPresentationParameters(); DefaultViewport = new Viewport(0, 0, Description.BackBufferWidth, Description.BackBufferHeight); // Creates a default DepthStencilBuffer. CreateDepthStencilBuffer(); }
public EffectProgram GetOrCreateShader(GraphicsDevice graphicsDevice, EffectBytecode bytecode) { lock (ShaderLibrary) { EffectProgram effectProgram; if (!ShaderLibrary.TryGetValue(bytecode, out effectProgram)) { effectProgram = new EffectProgram(graphicsDevice, bytecode); ShaderLibrary.Add(bytecode, effectProgram); } return effectProgram; } }
public SwapChainGraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters) : base(device, presentationParameters) { PresentInterval = presentationParameters.PresentationInterval; // Initialize the swap chain swapChain = CreateSwapChain(); backBuffer = new Texture(device).InitializeFrom(swapChain.GetBackBuffer<SharpDX.Direct3D11.Texture2D>(0), Description.BackBufferFormat.IsSRgb()); // Reload should get backbuffer from swapchain as well //backBufferTexture.Reload = graphicsResource => ((Texture)graphicsResource).Recreate(swapChain.GetBackBuffer<SharpDX.Direct3D11.Texture>(0)); }
public void Update(GraphicsDevice graphicsDevice, EffectParameterCollectionGroup parameterCollectionGroup) { var threadIndex = graphicsDevice.ThreadIndex; bool dataChanged = constantBufferDatas[threadIndex].Update(parameterCollectionGroup); // Check if update is really needed if (forceDataChanged) forceDataChanged = false; else if (!dataChanged) return; // Upload data to constant buffer Buffer.SetData(graphicsDevice, dataStreams[threadIndex]); }
/// <summary> /// Initializes a new instance of the <see cref="DepthStencilStateFactory"/> class. /// </summary> /// <param name="device">The device.</param> internal DepthStencilStateFactory(GraphicsDevice device) : base(device) { Default = DepthStencilState.New(device, new DepthStencilStateDescription(true, true)).KeepAliveBy(this); Default.Name = "DepthStencilState.Default"; DefaultInverse = DepthStencilState.New(device, new DepthStencilStateDescription(true, true) { DepthBufferFunction = CompareFunction.GreaterEqual }).KeepAliveBy(this); DefaultInverse.Name = "DepthStencilState.DefaultInverse"; DepthRead = DepthStencilState.New(device, new DepthStencilStateDescription(true, false)).KeepAliveBy(this); DepthRead.Name = "DepthStencilState.DepthRead"; None = DepthStencilState.New(device, new DepthStencilStateDescription(false, false)).KeepAliveBy(this); None.Name = "DepthStencilState.None"; }
public UseOpenGLCreationContext(GraphicsDevice graphicsDevice) : this() { #if SILICONSTUDIO_PLATFORM_ANDROID // Unfortunately, android seems to not use GraphicsContext.CurrentContext to register its AndroidGraphicsContext, // so let's query EGL directly. if (GraphicsDevice.EglGetCurrentContext() == IntPtr.Zero) #elif SILICONSTUDIO_PLATFORM_IOS if (OpenGLES.EAGLContext.CurrentContext == null) #else if (GraphicsContext.CurrentContext == null) #endif { needUnbindContext = true; useDeviceCreationContext = true; #if SILICONSTUDIO_PLATFORM_ANDROID tegraWorkaround = graphicsDevice.Workaround_Context_Tegra2_Tegra3; // Notify main rendering thread there is some pending async work to do if (tegraWorkaround) { useDeviceCreationContext = false; // We actually use real main context, so states will be kept graphicsDevice.AsyncPendingTaskWaiting = true; } #endif // Lock, since there is only one deviceCreationContext. // TODO: Support multiple deviceCreationContext (TLS creation of context was crashing, need to investigate why) asyncCreationLockObject = graphicsDevice.asyncCreationLockObject; Monitor.Enter(graphicsDevice.asyncCreationLockObject, ref asyncCreationLockTaken); #if SILICONSTUDIO_PLATFORM_ANDROID if (tegraWorkaround) graphicsDevice.AsyncPendingTaskWaiting = false; // On android, bind the actual android context // The deviceCreationContext is a dummy one, so that CurrentContext works. androidDeviceCreationContext = graphicsDevice.androidAsyncDeviceCreationContext; if (androidDeviceCreationContext != null) androidDeviceCreationContext.MakeCurrent(graphicsDevice.deviceCreationWindowInfo); #endif // Bind the context deviceCreationContext = graphicsDevice.deviceCreationContext; deviceCreationContext.MakeCurrent(graphicsDevice.deviceCreationWindowInfo); } }
private VertexArrayObject(GraphicsDevice graphicsDevice, EffectInputSignature shaderSignature, IndexBufferBinding indexBufferBinding, VertexBufferBinding[] vertexBufferBindings) : base(graphicsDevice) { this.vertexBufferBindings = vertexBufferBindings; this.indexBufferBinding = indexBufferBinding; this.preferredInputSignature = shaderSignature; // Increase the reference count on the provided buffers -> we do not want to take the ownership foreach (VertexBufferBinding vertexBufferBinding in vertexBufferBindings) vertexBufferBinding.Buffer.AddReferenceInternal(); if (indexBufferBinding != null) indexBufferBinding.Buffer.AddReferenceInternal(); CreateAttributes(); }
internal void AttachToGraphicsDevice(GraphicsDevice device) { GraphicsDevice = device; if (device != null) { // Add GraphicsResourceBase to device resources var resources = device.Resources; lock (resources) { resources.Add(this); } } Initialize(); }
/// <summary> /// Creates a cylinder primitive. /// </summary> /// <param name="device">The device.</param> /// <param name="height">The height.</param> /// <param name="diameter">The diameter.</param> /// <param name="tessellation">The tessellation.</param> /// <param name="textureTiling">The texture tiling.</param> /// <param name="toLeftHanded">if set to <c>true</c> vertices and indices will be transformed to left handed. Default is false.</param> /// <returns>A cylinder primitive.</returns> /// <exception cref="System.ArgumentOutOfRangeException">tessellation;tessellation must be >= 3</exception> public static GeometricPrimitive New(GraphicsDevice device, float height = 1.0f, float diameter = 1.0f, int tessellation = 32, float textureTiling = 1, bool toLeftHanded = false) { // Create the primitive object. return(new GeometricPrimitive(device, New(height, diameter, tessellation, textureTiling, toLeftHanded))); }
protected internal Texture2D(GraphicsDevice device, TextureDescription description2D, DataBox[] dataBoxes = null, bool initialize = true) : base(device, description2D, TextureTarget.Texture2D, dataBoxes, initialize) { }
protected internal Texture2D(GraphicsDevice device, Texture2D texture) : base(device, texture) { }
protected static Texture2DDescription ConvertToNativeDescription(GraphicsDevice device, TextureDescription description) { var format = (Format)description.Format; var flags = description.Flags; // If the texture is going to be bound on the depth stencil, for to use TypeLess format if ((flags & TextureFlags.DepthStencil) != 0) { if (device.Features.Profile < GraphicsProfile.Level_10_0) { flags &= ~TextureFlags.ShaderResource; } else { // Determine TypeLess Format and ShaderResourceView Format switch (description.Format) { case PixelFormat.D16_UNorm: format = SharpDX.DXGI.Format.R16_Typeless; break; case PixelFormat.D32_Float: format = SharpDX.DXGI.Format.R32_Typeless; break; case PixelFormat.D24_UNorm_S8_UInt: format = SharpDX.DXGI.Format.R24G8_Typeless; break; case PixelFormat.D32_Float_S8X24_UInt: format = SharpDX.DXGI.Format.R32G8X24_Typeless; break; default: throw new InvalidOperationException(string.Format("Unsupported DepthFormat [{0}] for depth buffer", description.Format)); } } } var desc = new Texture2DDescription() { Width = description.Width, Height = description.Height, ArraySize = description.ArraySize, // TODO calculate appropriate MultiSamples SampleDescription = new SampleDescription(1, 0), BindFlags = GetBindFlagsFromTextureFlags(flags), Format = format, MipLevels = description.MipLevels, Usage = (ResourceUsage)description.Usage, CpuAccessFlags = GetCpuAccessFlagsFromUsage(description.Usage), OptionFlags = ResourceOptionFlags.None }; if (description.Dimension == TextureDimension.TextureCube) { desc.OptionFlags = ResourceOptionFlags.TextureCube; } return(desc); }