internal VkTexture( VkGraphicsDevice gd, uint width, uint height, uint mipLevels, uint arrayLayers, VkFormat vkFormat, TextureUsage usage, TextureSampleCount sampleCount, VkImage existingImage) { Debug.Assert(width > 0 && height > 0); _gd = gd; MipLevels = mipLevels; Width = width; Height = height; Depth = 1; VkFormat = vkFormat; Format = VkFormats.VkToVdPixelFormat(VkFormat); ArrayLayers = arrayLayers; Usage = usage; SampleCount = sampleCount; VkSampleCount = VkFormats.VdToVkSampleCount(sampleCount); _optimalImage = existingImage; }
public static ResourceFlags Convert(TextureUsage usage, PixelFormat format) { var flags = ResourceFlags.None; if ((usage & TextureUsage.ShaderRead) == 0) { flags |= ResourceFlags.DenyShaderResource; } if ((usage & TextureUsage.ShaderWrite) != 0) { flags |= ResourceFlags.AllowUnorderedAccess; } if ((usage & TextureUsage.RenderTarget) != 0) { if (!PixelFormatUtil.IsDepthStencilFormat(format)) { flags |= ResourceFlags.AllowRenderTarget; } else { flags |= ResourceFlags.AllowDepthStencil; } } return(flags); }
/// <summary> /// Initializes a new instance of the <see cref="TypelessTexture2D"/> class. /// </summary> /// <param name="usage">The usage.</param> /// <param name="textureUsage">The texture usage.</param> /// <param name="fmt">The FMT.</param> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="dp">The dp.</param> public TypelessTexture2D(GraphicsDevice device, Usage usage, TextureUsage textureUsage, CPUAccess cpuAccess, PixelFormat fmt, uint width, uint height, uint mipmaps, uint sampleCount, uint sampleQuality, GraphicsLocality locality, byte[][] data) : base(usage, textureUsage, cpuAccess, locality) { Validate(mipmaps, width, height); this.width = width; this.height = height; this.format = fmt; this.mipmapCount = mipmaps == 0 ? Images.MipmapHelper.MipmapCount(width, height) : mipmaps; // We create driver part. if (locality != GraphicsLocality.SystemMemoryOnly) { this.device = device; this.driverPart = device.DriverDevice.CreateTexture2D(usage, fmt.CommonFormatLayout, CPUAccess, width, height, mipmaps, textureUsage, sampleCount, sampleQuality, data); } // We may need to create sw part. if (locality == GraphicsLocality.DeviceAndSystemMemory || locality == GraphicsLocality.SystemMemoryOnly) { this.swData = data; } }
public Texture CreateManual(string name, string group, TextureType type, int width, int height, int numMipmaps, PixelFormat format, TextureUsage usage, IManualResourceLoader loader, bool hwGammaCorrection, int fsaa, string fsaaHint) { return(CreateManual(name, group, type, width, height, 1, numMipmaps, format, usage, loader, hwGammaCorrection, fsaa, string.Empty)); }
private static Usage GetUsage(TextureUsage usage) { return(usage switch { TextureUsage.Sampler => Usage.Diffuse, TextureUsage.Sampler0 => Usage.Diffuse, TextureUsage.Sampler1 => Usage.Diffuse, TextureUsage.SamplerCatchlight => Usage.Catchlight, TextureUsage.SamplerColorMap0 => Usage.Diffuse, TextureUsage.SamplerColorMap1 => Usage.Diffuse, TextureUsage.SamplerDiffuse => Usage.Diffuse, TextureUsage.SamplerEnvMap => Usage.Envmap, TextureUsage.SamplerMask => Usage.Mask, TextureUsage.SamplerNormal => Usage.Normal, TextureUsage.SamplerNormalMap0 => Usage.Normal, TextureUsage.SamplerNormalMap1 => Usage.Normal, TextureUsage.SamplerReflection => Usage.Reflection, TextureUsage.SamplerSpecular => Usage.Specular, TextureUsage.SamplerSpecularMap0 => Usage.Specular, TextureUsage.SamplerSpecularMap1 => Usage.Specular, TextureUsage.SamplerWaveMap => Usage.Wave, TextureUsage.SamplerWaveletMap0 => Usage.Wave, TextureUsage.SamplerWaveletMap1 => Usage.Wave, TextureUsage.SamplerWhitecapMap => Usage.Whitecap, _ => throw new ArgumentOutOfRangeException(nameof(usage), usage, null) });
public override void SetTexture(TextureUsage usage, Texture texture) { if (usage == TextureUsage.Detail) { DetailTexture = texture as Texture2D; } }
// Used to construct Swapchain textures. internal VkTexture( VkGraphicsDevice gd, uint width, uint height, uint mipLevels, uint arrayLayers, VkFormat vkFormat, TextureUsage usage, TextureSampleCount sampleCount, VkImage existingImage) { Debug.Assert(width > 0 && height > 0); _gd = gd; MipLevels = mipLevels; _width = width; _height = height; _depth = 1; VkFormat = vkFormat; _format = VkFormats.VkToVdPixelFormat(VkFormat); ArrayLayers = arrayLayers; Usage = usage; Type = TextureType.Texture2D; SampleCount = sampleCount; VkSampleCount = VkFormats.VdToVkSampleCount(sampleCount); _optimalImage = existingImage; _imageLayouts = new[] { VkImageLayout.Undefined }; ClearIfRenderTarget(); }
public override void SetTexture(TextureUsage usage, Texture texture) { if (usage == TextureUsage.Specular) { SpecularMap = texture as Texture2D; } }
public override void SetTexture(TextureUsage textureUsage, Texture texture) { if (textureUsage == TextureUsage.Bloom) { GraphicsDevice.Textures[1] = texture; } }
public override void SetTexture(TextureUsage usage, Texture texture) { if (usage == TextureUsage.NormalMap) { NormalMap = texture as Texture2D; } }
public override void SetTexture(TextureUsage usage, Texture texture) { if (usage == TextureUsage.Dual) { Texture2 = texture as Texture2D; } }
internal static bool IsFormatSupported(PixelFormat format, TextureUsage usage, MTLFeatureSupport metalFeatures) { switch (format) { case PixelFormat.BC1_Rgb_UNorm: case PixelFormat.BC1_Rgba_UNorm: case PixelFormat.BC2_UNorm: case PixelFormat.BC3_UNorm: return(metalFeatures.IsSupported(MTLFeatureSet.macOS_GPUFamily1_v1) || metalFeatures.IsSupported(MTLFeatureSet.macOS_GPUFamily1_v2) || metalFeatures.IsSupported(MTLFeatureSet.macOS_GPUFamily1_v3)); case PixelFormat.ETC2_R8_G8_B8_UNorm: case PixelFormat.ETC2_R8_G8_B8_A1_UNorm: case PixelFormat.ETC2_R8_G8_B8_A8_UNorm: return(metalFeatures.IsSupported(MTLFeatureSet.iOS_GPUFamily1_v1) || metalFeatures.IsSupported(MTLFeatureSet.iOS_GPUFamily2_v1) || metalFeatures.IsSupported(MTLFeatureSet.iOS_GPUFamily3_v1) || metalFeatures.IsSupported(MTLFeatureSet.iOS_GPUFamily4_v1)); case PixelFormat.R16_UNorm: return(((usage & TextureUsage.DepthStencil) == 0) || metalFeatures.IsSupported(MTLFeatureSet.macOS_GPUFamily1_v2) || metalFeatures.IsSupported(MTLFeatureSet.macOS_GPUFamily1_v3)); default: return(true); } }
public static BindFlags ToDirectX(this TextureUsage usage, PixelFormat format) { var bindFlags = BindFlags.None; if ((usage & TextureUsage.ShaderRead) != 0) { bindFlags |= BindFlags.ShaderResource; } if ((usage & TextureUsage.ShaderWrite) != 0) { bindFlags |= BindFlags.UnorderedAccess; } if ((usage & TextureUsage.RenderTarget) != 0) { if (!PixelFormatUtil.IsDepthStencilFormat(format)) { bindFlags |= BindFlags.RenderTarget; } else { bindFlags |= BindFlags.DepthStencil; } } return(bindFlags); }
internal static VkImageUsageFlags VdToVkTextureUsage(TextureUsage vdUsage) { VkImageUsageFlags vkUsage = VkImageUsageFlags.None; vkUsage = VkImageUsageFlags.TransferDst | VkImageUsageFlags.TransferSrc; bool isDepthStencil = (vdUsage & TextureUsage.DepthStencil) == TextureUsage.DepthStencil; if ((vdUsage & TextureUsage.Sampled) == TextureUsage.Sampled) { vkUsage |= VkImageUsageFlags.Sampled; } if (isDepthStencil) { vkUsage |= VkImageUsageFlags.DepthStencilAttachment; } if ((vdUsage & TextureUsage.RenderTarget) == TextureUsage.RenderTarget) { vkUsage |= VkImageUsageFlags.ColorAttachment; } if ((vdUsage & TextureUsage.Storage) == TextureUsage.Storage) { vkUsage |= VkImageUsageFlags.Storage; } return(vkUsage); }
/// <summary> /// Initializes a new instance of the <see cref="Texture"/> class. /// </summary> /// <param name="usage">The usage.</param> /// <param name="texUsage">The texture usage.</param> public TypelessTexture(Usage usage, TextureUsage texUsage, CPUAccess cpuAccess, GraphicsLocality locality) { this.usage = usage; textureUsage = texUsage; this.locality = locality; this.cpuAccess = cpuAccess; }
internal static TextureUsage GetVdUsage(BindFlags bindFlags, CpuAccessFlags cpuFlags, ResourceOptionFlags optionFlags) { TextureUsage usage = 0; if ((bindFlags & BindFlags.RenderTarget) != 0) { usage |= TextureUsage.RenderTarget; } if ((bindFlags & BindFlags.DepthStencil) != 0) { usage |= TextureUsage.DepthStencil; } if ((bindFlags & BindFlags.ShaderResource) != 0) { usage |= TextureUsage.Sampled; } if ((bindFlags & BindFlags.UnorderedAccess) != 0) { usage |= TextureUsage.Storage; } if ((optionFlags & ResourceOptionFlags.TextureCube) != 0) { usage |= TextureUsage.Cubemap; } if ((optionFlags & ResourceOptionFlags.GenerateMipMaps) != 0) { usage |= TextureUsage.GenerateMipmaps; } return(usage); }
public override void SetTexture(TextureUsage usage, Texture texture) { if (usage == TextureUsage.Emissive) { EmissiveMap = texture as Texture2D; } }
/// <summary> /// Create new instance of <see cref="TextureDescriptor"/> struct describing 2D texture. /// </summary> /// <param name="width">The width</param> /// <param name="height">The height</param> /// <param name="mipMap">Whether to compute mip levels from width and height, otherwise 1.</param> /// <param name="arrayLayers">The array layers count.</param> /// <param name="format">The <see cref="PixelFormat"/></param> /// <param name="textureUsage">The texture usage.</param> /// <param name="samples">The number of samples.</param> /// <returns></returns> public static TextureDescriptor Texture2D( int width, int height, bool mipMap, int arrayLayers = 1, PixelFormat format = PixelFormat.RGBA8UNorm, TextureUsage textureUsage = TextureUsage.ShaderRead, SampleCount samples = SampleCount.Count1) { int mipLevels = 1; if (mipMap) { while (height > 1 || width > 1) { ++mipLevels; if (height > 1) { height >>= 1; } if (width > 1) { width >>= 1; } } } width = Math.Max(width, 1); height = Math.Max(height, 1); arrayLayers = Math.Max(arrayLayers, 1); return(new TextureDescriptor(TextureType.Texture2D, width, height, 1, mipLevels, arrayLayers, format, textureUsage, samples)); }
/// <summary> /// Creates a new Texture instance without resolving any game data. /// </summary> /// <param name="parent">The Material this Texture has been instantiated for.</param> /// <param name="raw">The <see cref="TextureUsage"/> this Texture is input for.</param> /// <param name="texturePath">The path to this Texture.</param> public Texture(Material parent, TextureUsage raw, string texturePath) { Parent = parent; TextureUsageRaw = raw; TextureUsageSimple = GetUsage(raw); TexturePath = texturePath; }
public Texture CreateDeviceTexture(GraphicsDevice gd, ResourceFactory rf, TextureUsage usage) { IsDirty = false; var texture = _texture.CreateDeviceTexture(gd, rf); texture.Name = "T_" + Name; return(texture); }
/// <summary> /// <para>Specifies if the texture will be used as a render target attachment.</para> /// <para>If the texture is potentially rendered into, it may require a different memory layout, which needs to /// be known during construction.</para> /// </summary> /// <param name="usage">Defaults to <see cref="TextureUsage.Default"/>; c.f. /// <see cref="TextureUsage.ColorAttachment"/>.</param> /// <returns>This Builder, for chaining calls.</returns> public TextureBuilder WithUsage(TextureUsage usage) { ThrowExceptionIfDisposed(); Native.TextureBuilder.Usage(NativePtr, (byte)usage); return(this); }
public static unsafe Texture CreateSimpleTexture <T>(GraphicsDevice gd, TextureUsage usage, IReadOnlyTexture <T> texture) where T : unmanaged { if (gd == null) { throw new ArgumentNullException(nameof(gd)); } if (texture == null) { throw new ArgumentNullException(nameof(texture)); } var pixelFormat = GetFormat(typeof(T)); bool mip = (usage & TextureUsage.GenerateMipmaps) != 0; uint mipLevels = mip ? MipLevelCount(texture.Width, texture.Height) : 1; using Texture staging = gd.ResourceFactory.CreateTexture(new TextureDescription( (uint)texture.Width, (uint)texture.Height, 1, mipLevels, 1, pixelFormat, TextureUsage.Staging, TextureType.Texture2D)); staging.Name = "T_" + texture.Name + "_Staging"; var buffer = texture.PixelData; fixed(T *texDataPtr = &buffer[0]) { gd.UpdateTexture( staging, (IntPtr)texDataPtr, (uint)(buffer.Length * Unsafe.SizeOf <T>()), 0, 0, 0, (uint)texture.Width, (uint)texture.Height, 1, 0, 0); } Texture veldridTexture = gd.ResourceFactory.CreateTexture(new TextureDescription( (uint)texture.Width, (uint)texture.Height, 1, mipLevels, 1, pixelFormat, usage, TextureType.Texture2D)); veldridTexture.Name = "T_" + texture.Name; using CommandList cl = gd.ResourceFactory.CreateCommandList(); cl.Begin(); cl.CopyTexture(staging, veldridTexture); if (mip) { cl.GenerateMipmaps(veldridTexture); } cl.End(); gd.SubmitCommands(cl); return(veldridTexture); }
/// <summary> /// Sets the texture based on the texture usage. /// </summary> public override void SetTexture(TextureUsage textureUsage, Texture texture) { var count = materialParts.Count; for (int i = 0; i < count; ++i) { materialParts[i].SetTexture(textureUsage, texture); } }
/// <summary> /// Create a new filled texture with the given dimensions and format. /// </summary> /// <param name="width">The width of the texture.</param> /// <param name="format">The texel format.</param> /// <param name="data">The initial texture data. Must be large enough to fill entire texture.</param> /// <param name="usage">The texture usage policy.</param> public Texture1D(uint width, TexelFormat format, void *data, TextureUsage usage = TextureUsage.Static) : base(width, 1, 1, 1, 1, format, usage, ResourceType.Texture1D) { if (data == null) { throw new ArgumentException("Initial texture data pointer cannot be null", nameof(data)); } SetDataImpl(data, new(0, 0, 0, width, 1, 1, 0, 1)); }
/// <summary> /// Creates a new blank cubemap texture. /// </summary> /// <param name="size">Width & height of a single cubemap face in pixels.</param> /// <param name="format">Format of the pixels.</param> /// <param name="usage">Describes planned texture use.</param> /// <param name="hasMipmaps">Should the texture allocate memory for the entire mip-map chain or only the top level. /// </param> /// <param name="gammaCorrection">If true the texture data is assumed to have be gamma corrected and will be /// converted back to linear space when sampled on GPU, and converted to gamma space /// before being written by the GPU.</param> public static Texture CreateCube(uint size, PixelFormat format = PixelFormat.RGBA8, TextureUsage usage = TextureUsage.Default, bool hasMipmaps = false, bool gammaCorrection = false) { Texture texture = new Texture(true); Internal_create(texture, format, size, size, 1, TextureType.TextureCube, usage, 1, hasMipmaps, gammaCorrection); return(texture); }
/// <summary> /// Creates a new blank 3D texture. /// </summary> /// <param name="width">Width of the texture in pixels.</param> /// <param name="height">Height of the texture in pixels.</param> /// <param name="depth">Depth of the texture in pixels.</param> /// <param name="format">Format of the pixels.</param> /// <param name="usage">Describes planned texture use.</param> /// <param name="hasMipmaps">Should the texture allocate memory for the entire mip-map chain or only the top level. /// </param> public static Texture Create3D(uint width, uint height, uint depth, PixelFormat format = PixelFormat.RGBA8, TextureUsage usage = TextureUsage.Default, bool hasMipmaps = false) { Texture texture = new Texture(true); Internal_create(texture, format, width, height, depth, TextureType.Texture3D, usage, 1, hasMipmaps, false); return(texture); }
/// <summary> /// Creates a new blank 2D texture. /// </summary> /// <param name="width">Width of the texture in pixels.</param> /// <param name="height">Height of the texture in pixels.</param> /// <param name="format">Format of the pixels.</param> /// <param name="usage">Describes planned texture use.</param> /// <param name="numSamples">If higher than 1, texture containing multiple samples per pixel is created.</param> /// <param name="hasMipmaps">Should the texture allocate memory for the entire mip-map chain or only the top level. /// </param> /// <param name="gammaCorrection">If true the texture data is assumed to have be gamma corrected and will be /// converted back to linear space when sampled on GPU, and converted to gamma space /// before being written by the GPU.</param> public static Texture Create2D(uint width, uint height, PixelFormat format = PixelFormat.RGBA8, TextureUsage usage = TextureUsage.Default, uint numSamples = 1, bool hasMipmaps = false, bool gammaCorrection = false) { Texture texture = new Texture(true); Internal_create(texture, format, width, height, 1, TextureType.Texture2D, usage, numSamples, hasMipmaps, gammaCorrection); return(texture); }
public Texture2D(GraphicsDevice graphicsDevice, int width, int height, int numberLevels, TextureUsage usage, SurfaceFormat format) { this.device = graphicsDevice; this.width = width; this.height = height; this.numberOfLevels = numberLevels; this.textureUsage = usage; this.surfaceFormat = format; initGL(); }
public TextureCreationParameters(int width, int height, int depth, int mipLevels, SurfaceFormat format, TextureUsage textureUsage, Color colorKey, FilterOptions filter, FilterOptions mipFilter) { m_Width = width; m_Height = height; m_Depth = depth; m_MipLevels = mipLevels; m_Format = format; m_ColorKey = colorKey; m_Filter = filter; m_MipFilter = mipFilter; }
public OpenGLPlaceholderTexture( uint width, uint height, PixelFormat format, TextureUsage usage, TextureSampleCount sampleCount) { _width = width; _height = height; Format = format; Usage = usage; SampleCount = sampleCount; }
/// <summary> /// Constructor. /// </summary> /// <param name="graphicsDevice"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="usage"></param> public Texture(GraphicsDevice graphicsDevice, int width, int height, TextureUsage usage) : base() { if (graphicsDevice == null) throw new ArgumentNullException("graphicsDevice"); graphicsDevice.EnsureDeviceCreated(); this.Width = width; this.Height = height; this.Usage = usage; this.CalculateInternalSize(graphicsDevice); this.InternalTexture = D3DHelper.CreateTexture(graphicsDevice.InternalDevice, this.InternalWidth, this.InternalHeight, this.Usage); }
public override Axiom.Media.PixelFormat GetNativeFormat( TextureType ttype, PixelFormat format, TextureUsage usage ) { // Basic filtering var d3dPF = D3D9Helper.ConvertEnum( D3D9Helper.GetClosestSupported( format ) ); // Calculate usage var d3dusage = D3D9.Usage.None; var pool = D3D9.Pool.Managed; if ( ( usage & TextureUsage.RenderTarget ) != 0 ) { d3dusage |= D3D9.Usage.RenderTarget; pool = D3D9.Pool.Default; } if ( ( usage & TextureUsage.Dynamic ) != 0 ) { d3dusage |= D3D9.Usage.Dynamic; pool = D3D9.Pool.Default; } var curDevice = D3D9RenderSystem.ActiveD3D9Device; // Use D3DX to adjust pixel format switch ( ttype ) { case TextureType.OneD: case TextureType.TwoD: var tReqs = D3D9.Texture.CheckRequirements( curDevice, 0, 0, 0, d3dusage, D3D9Helper.ConvertEnum( format ), pool ); d3dPF = tReqs.Format; break; case TextureType.ThreeD: var volReqs = D3D9.VolumeTexture.CheckRequirements( curDevice, 0, 0, 0, 0, d3dusage, D3D9Helper.ConvertEnum( format ), pool ); d3dPF = volReqs.Format; break; case TextureType.CubeMap: var cubeReqs = D3D9.CubeTexture.CheckRequirements( curDevice, 0, 0, d3dusage, D3D9Helper.ConvertEnum( format ), pool ); d3dPF = cubeReqs.Format; break; } return D3D9Helper.ConvertEnum( d3dPF ); }
// This ends up just discarding the format passed in; the C# methods don't let you supply // a "recommended" format. Ah well. public override Axiom.Media.PixelFormat GetNativeFormat( TextureType ttype, PixelFormat format, TextureUsage usage ) { // Basic filtering D3D.Format d3dPF = D3DHelper.ConvertEnum( D3DHelper.GetClosestSupported( format ) ); // Calculate usage D3D.Usage d3dusage = 0; D3D.Pool pool = D3D.Pool.Managed; if ( ( usage & TextureUsage.RenderTarget ) != 0 ) { d3dusage |= D3D.Usage.RenderTarget; pool = D3D.Pool.Default; } if ( ( usage & TextureUsage.Dynamic ) != 0 ) { d3dusage |= D3D.Usage.Dynamic; pool = D3D.Pool.Default; } // Use D3DX to adjust pixel format switch ( ttype ) { case TextureType.OneD: case TextureType.TwoD: D3D.TextureRequirements tReqs = D3D.Texture.CheckRequirements( device, 0, 0, 0, d3dusage, D3DHelper.ConvertEnum( format ), pool ); d3dPF = tReqs.Format; break; case TextureType.ThreeD: D3D.VolumeTextureRequirements volReqs = D3D.VolumeTexture.CheckRequirements( device, 0, 0, 0, 0, d3dusage, D3DHelper.ConvertEnum( format ), pool ); d3dPF = volReqs.Format; break; case TextureType.CubeMap: D3D.CubeTextureRequirements cubeReqs = D3D.CubeTexture.CheckRequirements( device, 0, 0, d3dusage, D3DHelper.ConvertEnum( format ), pool ); d3dPF = cubeReqs.Format; break; } return D3DHelper.ConvertEnum( d3dPF ); }
internal static D3D.Texture CreateTexture(D3D.Device device, int width, int height, TextureUsage usage) { D3D.Usage nativeUsage = D3D.Usage.None; D3D.Format nativeFormat = D3D.Format.A8R8G8B8; D3D.Pool nativePool = D3D.Pool.Managed; switch (usage) { case TextureUsage.RenderTarget: nativeUsage = D3D.Usage.RenderTarget; nativePool = D3D.Pool.Default; break; } return new D3D.Texture( device, width, height, 1, nativeUsage, nativeFormat, nativePool); }
protected virtual void LoadImages(List<Image> images) { Debug.Assert(images.Count >= 1); if (isLoaded) { log.InfoFormat("Unloading image: {0}", name); Unload(); } srcWidth = width = images[0].Width; srcHeight = height = images[0].Height; srcDepth = depth = images[0].Depth; if (hasAlpha && images[0].Format == PixelFormat.L8) { format = PixelFormat.A8; srcBpp = 8; } else { this.Format = images[0].Format; } if (finalBpp == 16) { switch (format) { case PixelFormat.R8G8B8: case PixelFormat.X8R8G8B8: format = PixelFormat.R5G6B5; break; case PixelFormat.B8G8R8: case PixelFormat.X8B8G8R8: format = PixelFormat.B5G6R5; break; case PixelFormat.A8R8G8B8: case PixelFormat.R8G8B8A8: case PixelFormat.A8B8G8R8: case PixelFormat.B8G8R8A8: format = PixelFormat.A4R4G4B4; break; default: // use the original format break; } } // The custom mipmaps in the image have priority over everything int imageMips = images[0].NumMipMaps; if (imageMips > 0) { numMipmaps = imageMips; usage &= ~TextureUsage.AutoMipMap; } // Create the texture CreateInternalResources(); // Check if we're loading one image with multiple faces // or a vector of images representing the faces int faces; bool multiImage; // Load from multiple images? if (images.Count > 1) { faces = images.Count; multiImage = true; } else { faces = images[0].NumFaces; multiImage = false; } // Check wether number of faces in images exceeds number of faces // in this texture. If so, clamp it. if (faces > this.NumFaces) faces = this.NumFaces; // Say what we're doing log.InfoFormat("Texture: {0}: Loading {1} faces({2},{3}x{4}x{5})", name, faces, PixelUtil.GetFormatName(images[0].Format), images[0].Width, images[0].Height, images[0].Depth); #if NOT // crazy ogre logging if (!(mMipmapsHardwareGenerated && mNumMipmaps == 0)) str << mNumMipmaps; if(mUsage & TU_AUTOMIPMAP) { if (mMipmapsHardwareGenerated) str << " hardware"; str << " generated mipmaps"; } else { str << " custom mipmaps"; } if(multiImage) str << " from multiple Images."; else str << " from Image."; // Scoped { // Print data about first destination surface HardwarePixelBufferSharedPtr buf = getBuffer(0, 0); str << " Internal format is " << PixelUtil::getFormatName(buf->getFormat()) << "," << buf->getWidth() << "x" << buf->getHeight() << "x" << buf->getDepth() << "."; } LogManager::getSingleton().logMessage( LML_NORMAL, str.str()); #endif // Main loading loop // imageMips == 0 if the image has no custom mipmaps, otherwise contains the number of custom mips for (int mip = 0; mip <= imageMips; ++mip) { for (int i = 0; i < faces; ++i) { PixelBox src; if (multiImage) { // Load from multiple images src = images[i].GetPixelBox(0, mip); } else { // Load from faces of images[0] src = images[0].GetPixelBox(i, mip); if (hasAlpha && src.Format == PixelFormat.L8) src.Format = PixelFormat.A8; } if (gamma != 1.0f) { // Apply gamma correction // Do not overwrite original image but do gamma correction in temporary buffer IntPtr buffer = Marshal.AllocHGlobal(PixelUtil.GetMemorySize(src.Width, src.Height, src.Depth, src.Format)); try { PixelBox corrected = new PixelBox(src.Width, src.Height, src.Depth, src.Format, buffer); PixelUtil.BulkPixelConversion(src, corrected); Image.ApplyGamma(corrected.Data, gamma, corrected.ConsecutiveSize, PixelUtil.GetNumElemBits(src.Format)); // Destination: entire texture. BlitFromMemory does the scaling to // a power of two for us when needed GetBuffer(i, mip).BlitFromMemory(corrected); } finally { Marshal.FreeHGlobal(buffer); } } else { // Destination: entire texture. BlitFromMemory does the scaling to // a power of two for us when needed GetBuffer(i, mip).BlitFromMemory(src); } } } // Update size (the final size, not including temp space) size = this.NumFaces * PixelUtil.GetMemorySize(width, height, depth, format); isLoaded = true; }
public override bool IsHardwareFilteringSupported( TextureType ttype, PixelFormat format, TextureUsage usage, bool preciseFormatOnly ) #endif { if ( format == PixelFormat.Unknown ) { return false; } // Check natively format PixelFormat nativeFormat = GetNativeFormat( ttype, format, usage ); if ( preciseFormatOnly && format != nativeFormat ) { return false; } // Assume non-floating point is supported always if ( !PixelUtil.IsFloatingPoint( nativeFormat ) ) { return true; } // Hack: there are no elegant GL API to detects texture filtering supported, // just hard code for cards based on vendor specifications. // TODO: Add cards that 16 bits floating point flitering supported by // hardware below String[] sFloat16SupportedCards = { // GeForce 8 Series "*GeForce*8800*", // GeForce 7 Series "*GeForce*7950*", "*GeForce*7900*", "*GeForce*7800*", "*GeForce*7600*", "*GeForce*7500*", "*GeForce*7300*", // GeForce 6 Series "*GeForce*6800*", "*GeForce*6700*", "*GeForce*6600*", "*GeForce*6500*", "*GeForce*6200*", "" // Empty string means end of list }; // TODO: Add cards that 32 bits floating point flitering supported by // hardware below String[] sFloat32SupportedCards = { // GeForce 8 Series "*GeForce*8800*", "" // Empty string means end of list }; PixelComponentType pct = PixelUtil.GetComponentType( nativeFormat ); String[] supportedCards; switch ( pct ) { case PixelComponentType.Float16: supportedCards = sFloat16SupportedCards; break; case PixelComponentType.Float32: supportedCards = sFloat32SupportedCards; break; default: return false; } String pcRenderer = Gl.glGetString( Gl.GL_RENDERER ); // TAO 2.0 //String pcRenderer = Marshal.PtrToStringAnsi( Gl.glGetString( Gl.GL_RENDERER ) ); foreach ( String str in supportedCards ) { if ( str == pcRenderer ) { return true; } } return false; }
/// <summary> /// Creates a new blank cube texture. /// </summary> /// <param name="width">Width of a single face of the texture in pixels.</param> /// <param name="height">Height of a single face of the texture in pixels.</param> /// <param name="format">Format of the pixels.</param> /// <param name="usage">Describes planned texture use.</param> /// <param name="numSamples">If higher than 1, texture containing multiple samples per pixel is created.</param> /// <param name="hasMipmaps">Should the texture allocate memory for the entire mip-map chain or only the top level. /// </param> /// <param name="gammaCorrection">If true the texture data is assumed to have be gamma corrected and will be /// converted back to linear space when sampled on GPU, and converted to gamma space /// before being written by the GPU.</param> public TextureCube(PixelFormat format, int width, int height, TextureUsage usage = TextureUsage.Default, int numSamples = 1, bool hasMipmaps = false, bool gammaCorrection = false) { Internal_CreateInstance(this, format, width, height, usage, numSamples, hasMipmaps, gammaCorrection); }
private static extern void Internal_CreateInstance(TextureCube instance, PixelFormat format, int width, int height, TextureUsage usage, int numSamples, bool hasMipmaps, bool gammaCorrection);
/// <summary> /// Creates a GL texture manually. /// </summary> /// <param name="name"></param> /// <param name="type"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="numMipMaps"></param> /// <param name="format"></param> /// <param name="usage"></param> /// <returns></returns> public override Texture CreateManual(string name, TextureType type, int width, int height, int numMipMaps, Axiom.Media.PixelFormat format, TextureUsage usage) { GLTexture texture = new GLTexture(name, type, width, height, numMipMaps, format, usage); texture.Enable32Bit(is32Bit); return texture; }
internal void CreateTexture(int _width, int _height, TextureResizeMode _resizeMode, TextureUsage _usage, PixelFormat _format) { ICall_createTexture_WidthSize(mInstance.Ptr, _width, _height, _resizeMode, _usage, _format); }
public Texture CreateManual(string name, TextureType type, int width, int height, int numMipmaps, PixelFormat format, TextureUsage usage) { return CreateManual(name, type, width, height, 1, numMipmaps, format, usage); }
public bool CheckDeviceFormat(DeviceType deviceType, SurfaceFormat adapterFormat, TextureUsage usage, QueryUsages queryUsages, ResourceType resourceType, SurfaceFormat checkFormat) { throw new NotImplementedException(); }
/// <see cref="Axiom.Core.TextureManager.IsHardwareFilteringSupported(TextureType, PixelFormat, TextureUsage, bool)"/> #if NET_40 public override bool IsHardwareFilteringSupported( TextureType ttype, PixelFormat format, TextureUsage usage, bool preciseFormatOnly = false )
private bool CheckTextureFilteringSupported(TextureType ttype, PixelFormat format, TextureUsage usage) { // Gets D3D format var d3Dpf = D3DHelper.ConvertEnum(format); if (d3Dpf == Format.Unknown) return false; foreach (var currDevice in _deviceManager) { var currDevicePrimaryWindow = currDevice.PrimaryWindow; var pSurface = currDevicePrimaryWindow.RenderSurface; // Get surface desc var srfDesc = pSurface.Description; // Calculate usage var d3Dusage = Usage.QueryFilter; if ((usage & TextureUsage.RenderTarget) != 0) d3Dusage |= Usage.RenderTarget; if ((usage & TextureUsage.Dynamic) != 0) d3Dusage |= Usage.Dynamic; // Detect resource type ResourceType rtype; switch(ttype) { case TextureType.OneD: case TextureType.TwoD: rtype = ResourceType.Texture; break; case TextureType.ThreeD: rtype = ResourceType.VolumeTexture; break; case TextureType.CubeMap: rtype = ResourceType.CubeTexture; break; default: return false; } var hr = _pD3D.CheckDeviceFormat( currDevice.AdapterNumber, currDevice.DeviceType, srfDesc.Format, d3Dusage, rtype, d3Dpf); if (!hr) return false; } return true; }
public bool IsFormatSupported(TextureType ttype, PixelFormat format, TextureUsage usage) { return GetNativeFormat(ttype, format, usage) == format; }
public bool IsEquivalentFormatSupported(TextureType ttype, PixelFormat format, TextureUsage usage) { PixelFormat supportedFormat = GetNativeFormat(ttype, format, usage); // Assume that same or greater number of bits means quality not degraded return PixelUtil.GetNumElemBits(supportedFormat) >= PixelUtil.GetNumElemBits(format); }
public virtual PixelFormat GetNativeFormat(TextureType ttype, PixelFormat format, TextureUsage usage) { // Just throw an error, for non-overriders throw new NotImplementedException(); }
/// <summary> /// </summary> /// <param name="ttype"> </param> /// <param name="format"> </param> /// <param name="usage"> </param> /// <returns> </returns> public override Media.PixelFormat GetNativeFormat( TextureType ttype, Media.PixelFormat format, TextureUsage usage ) { // Adjust requested parameters to capabilities RenderSystemCapabilities caps = Root.Instance.RenderSystem.HardwareCapabilities; #warning check TextureCompressionVTC == RSC_TEXTURE_COMPRESSION_PVRTC // Check compressed texture support // if a compressed format not supported, revert to A8R8G8B8 if ( PixelUtil.IsCompressed( format ) && !caps.HasCapability( Capabilities.TextureCompressionDXT ) && !caps.HasCapability( Capabilities.TextureCompressionVTC ) ) { return Media.PixelFormat.A8R8G8B8; } // if floating point textures not supported, revert to A8R8G8B8 if ( PixelUtil.IsFloatingPoint( format ) && !caps.HasCapability( Capabilities.TextureFloat ) ) { return Media.PixelFormat.A8R8G8B8; } // Check if this is a valid rendertarget format if ( ( usage & TextureUsage.RenderTarget ) != 0 ) { /// Get closest supported alternative /// If format is supported it's returned return GLESRTTManager.Instance.GetSupportedAlternative( format ); } // Supported return format; }
private static extern void ICall_createTexture_WidthSize(IntPtr widget_ptr, int _width, int _height, TextureResizeMode _resizeMode, TextureUsage _usage, PixelFormat _format);
/// <summary> /// Method for creating a new blank texture. /// </summary> /// <param name="name"></param> /// <param name="texType"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="numMipMaps"></param> /// <param name="format"></param> /// <param name="usage"></param> /// <returns></returns> public Texture CreateManual(string name, TextureType texType, int width, int height, int depth, int numMipmaps, PixelFormat format, TextureUsage usage) { Texture ret = (Texture)Create(name, true); ret.TextureType = texType; ret.Width = width; ret.Height = height; ret.Depth = depth; ret.NumMipMaps = (numMipmaps == -1) ? defaultNumMipMaps : numMipmaps; ret.Format = format; ret.Usage = usage; ret.Enable32Bit(is32Bit); ret.CreateInternalResources(); return ret; }
public Texture CreateManual( string name, string group, TextureType type, int width, int height, int depth, int numMipmaps, PixelFormat format, TextureUsage usage, IManualResourceLoader loader, bool hwGammaCorrection, int fsaa ) { return CreateManual( name, group, type, width, height, depth, numMipmaps, format, usage, loader, hwGammaCorrection, fsaa, string.Empty ); }
/// <see cref="IsHardwareFilteringSupported(TextureType, PixelFormat, TextureUsage, bool)"/> public bool IsHardwareFilteringSupported( TextureType ttype, PixelFormat format, TextureUsage usage ) { return IsHardwareFilteringSupported( ttype, format, usage, false ); }
private static extern void ICall_createTexture(IntPtr widget_ptr, TextureResizeMode _resizeMode, TextureUsage _usage, PixelFormat _format);
public Texture CreateManual( string name, string group, TextureType type, int width, int height, int depth, int numMipmaps, PixelFormat format, TextureUsage usage, IManualResourceLoader loader ) { return CreateManual( name, group, type, width, height, depth, numMipmaps, format, usage, loader, false, 0, string.Empty ); }
public abstract bool IsHardwareFilteringSupported( TextureType ttype, PixelFormat format, TextureUsage usage, bool preciseFormatOnly );
/// <summary> /// Create a manual texture with specified width, height and depth (not loaded from a file). /// </summary> /// <param name="name">The name to give the resulting texture</param> /// <param name="group">The name of the resource group to assign the texture to</param> /// <param name="type">The type of texture to load/create, defaults to normal 2D textures</param> /// <param name="width">The dimensions of the texture</param> /// <param name="height">The dimensions of the texture</param> /// <param name="depth">The dimensions of the texture</param> /// <param name="numMipMaps"> /// The number of pre-filtered mipmaps to generate. If left to MIP_DEFAULT then /// the TextureManager's default number of mipmaps will be used (see setDefaultNumMipmaps()). /// If set to MIP_UNLIMITED mipmaps will be generated until the lowest possible /// level, 1x1x1. /// </param> /// <param name="format"> /// The internal format you wish to request; the manager reserves /// the right to create a different format if the one you select is /// not available in this context. /// </param> /// <param name="usage"> /// The kind of usage this texture is intended for. It /// is a combination of TU_STATIC, TU_DYNAMIC, TU_WRITE_ONLY, /// TU_AUTOMIPMAP and TU_RENDERTARGET (see TextureUsage enum). You are /// strongly advised to use HBU_STATIC_WRITE_ONLY wherever possible, if you need to /// update regularly, consider HBU_DYNAMIC_WRITE_ONLY. /// </param> /// <param name="loader"> /// If you intend the contents of the manual texture to be /// regularly updated, to the extent that you don't need to recover /// the contents if the texture content is lost somehow, you can leave /// this parameter as null. However, if you intend to populate the /// texture only once, then you should implement ManualResourceLoader /// and pass a pointer to it in this parameter; this means that if the /// manual texture ever needs to be reloaded, the ManualResourceLoader /// will be called to do it. /// </param> /// <param name="hwGammaCorrection"></param> /// <param name="fsaa"></param> /// <param name="fsaaHint"></param> /// <returns></returns> public Texture CreateManual( string name, string group, TextureType type, int width, int height, int depth, int numMipMaps, PixelFormat format, TextureUsage usage, IManualResourceLoader loader, bool hwGammaCorrection, int fsaa, string fsaaHint ) { var ret = (Texture)Create( name, group, true, loader, null ); ret.TextureType = type; ret.Width = width; ret.Height = height; ret.Depth = depth; ret.MipmapCount = ( numMipMaps == -1 ) ? this._defaultMipmapCount : numMipMaps; ret.SetFormat( format ); ret.Usage = usage; ret.HardwareGammaEnabled = hwGammaCorrection; ret.SetFSAA( fsaa, fsaaHint ); ret.CreateInternalResources(); return ret; }
public override PixelFormat GetNativeFormat( TextureType ttype, PixelFormat format, TextureUsage usage ) { // Adjust requested parameters to capabilities RenderSystemCapabilities caps = Root.Instance.RenderSystem.Capabilities; // Check compressed texture support // if a compressed format not supported, revert to PF_A8R8G8B8 if ( PixelUtil.IsCompressed( format ) && !caps.HasCapability( Capabilities.TextureCompressionDXT ) ) { return PixelFormat.A8R8G8B8; } // if floating point textures not supported, revert to PF_A8R8G8B8 if ( PixelUtil.IsFloatingPoint( format ) && !caps.HasCapability( Capabilities.TextureFloat ) ) { return PixelFormat.A8R8G8B8; } // Check if this is a valid rendertarget format if ( ( usage & TextureUsage.RenderTarget ) != 0 ) { /// Get closest supported alternative /// If mFormat is supported it's returned return GLRTTManager.Instance.GetSupportedAlternative( format ); } // Supported return format; }
public override PixelFormat GetNativeFormat( TextureType ttype, PixelFormat format, TextureUsage usage ) { return PixelFormat.X8R8G8B8; }
public SpriteEd( GraphicsDevice graphicsDevice, int width, int height, int numberLevels, TextureUsage usage, SurfaceFormat format ) : base(graphicsDevice, width, height, numberLevels, usage, format) { _properties.Sprite = this; }
/// <summary> /// Create a manual texture with a depth of 1 (not loaded from a file). /// </summary> /// <param name="name">The name to give the resulting texture</param> /// <param name="group">The name of the resource group to assign the texture to</param> /// <param name="type">The type of texture to load/create, defaults to normal 2D textures</param> /// <param name="width">The dimensions of the texture</param> /// <param name="height">The dimensions of the texture</param> /// <param name="numMipmaps"> /// The number of pre-filtered mipmaps to generate. If left to MIP_DEFAULT then /// the TextureManager's default number of mipmaps will be used (see setDefaultNumMipmaps()). /// If set to MIP_UNLIMITED mipmaps will be generated until the lowest possible /// level, 1x1x1. /// </param> /// <param name="format"> /// The internal format you wish to request; the manager reserves /// the right to create a different format if the one you select is /// not available in this context. /// </param> /// <param name="usage"> /// The kind of usage this texture is intended for. It /// is a combination of TU_STATIC, TU_DYNAMIC, TU_WRITE_ONLY, /// TU_AUTOMIPMAP and TU_RENDERTARGET (see TextureUsage enum). You are /// strongly advised to use HBU_STATIC_WRITE_ONLY wherever possible, if you need to /// update regularly, consider HBU_DYNAMIC_WRITE_ONLY. /// </param> /// <returns></returns> public Texture CreateManual( string name, string group, TextureType type, int width, int height, int numMipmaps, PixelFormat format, TextureUsage usage ) { return CreateManual( name, group, type, width, height, 1, numMipmaps, format, usage, null, false, 0, String.Empty ); }