AMD CubeMapGen has reached end of life. AMD no longer supports CubeMapGen, but makes it available for download without warranty. For current tools and SDKs, please visit our Tools & SDKs page.
CubeMapGen is a tool for importing, filtering, visualizing, and exporting cubemaps.
Despite the fact that cube maps are defined on the spherical domain, standard cubemap mipchain generation techniques perform filtering independently on each cube face. The main problem with this approach is that no information is propagated across edges, thus creating undesirable discontinuities along the cube face edges. A limitation of nearly all cube mapping hardware which makes the seam problem substantially worse is the fact that the bilinear texel filtering is not able to fetch across cube faces thus producing a hard seam artifact in addition to introducing aliasing artifacts. These two compounding problems limit the usefulness of cubemapping.
Our pre-processing approach alleviates this problem using two techniques. The first, angular extent filtering, defines each tap’s filter kernel using an angular extent around the center tap as opposed to a fixed per-face pixel-based extent. The advantages of angular extent filtering are that the filtering kernels used for all taps have a constant solid angle as well as have the ability to pull texels from multiple faces. In addition to this, the filtering takes into account the solid angle subtended by each tap in the filter. Also, by varying the angular extent of the filter used to generate the base mip-level, pre-convolved reflections for a variety of materials can be precomputed.
The second technique, edge seam fixup, uses a per mip-level seam averaging and smoothing algorithm in order to effectively hide the seam artifacts. This enables the lower-resolution cubemap miplevels (even 2×2 and 4×4) to be directly used for tarnished metal shaders, matte surfaces shaders, and even for diffuse lighting. In addition to this, by providing good quality cubemaps throughout the mipchain, miplevel selection via the texCUBEbias, and texCUBELOD instructions can be used for selective blurring.
Here are some examples of the enhanced filtering and mipchain generation that CubeMapGen provides:
Visualization of low-resolution cubemap miplevels generated using the CubeMapGen tool.
Standard cube-map filtering for mip-chain generation filters each cubemap face in isolation,
and does not take into account texels from other faces. Because of this the seams between cubemap
faces are very noticeable. (2×2 miplevel)
Here you can see CubeMapGen’s angular extent filtering and edge seam fixup provides high quality
filtering for even low resolution miplevels. As you can see, the 2×2 miplevel can now be used
directly for diffuse lighting.
Here is another example of the seam artifacts resulting” from the standard cubemap miplevel
generation scheme. (4×4 miplevel)
Here is the same cubemap, but using CubeMapGen to filter and generate the mipchain.
The 4×4 miplevel can now be used directly in a burnished metal shader.
Here is an example of using a cubemap generated with CubeMapGen
along with the texCUBEbias HLSL instruction in order to provide
selective blurring of the environment map on the fly via miplevel selection.
Cubemap Filtering and MipChain Generation: Angular extent filtering and edge seam fixup provides new high quality filtering results for prefiltered environment mapping, and cubemap mipchain generation. The cubemap filtering routines are multithreaded and can take full advantage of the processing power of dual CPU computers.
Interactive Cubemap Assembly: Cubemaps can be assembled from separate face images that can be loaded into each cubemap face and interactively flipped vertically, horizontally, and diagonally in order to align the faces.
Cubemap Export: Export cubemap with mipchain to single .dds file, cube cross images for each mip level, or a collection of separate images for each cubemap face for each mip level. Also supported is a specialized DXT compressor which allows for the creation of seamless DXT compressed cubemaps by taking into account adjacent blocks across cubemap edges during compression.
- Windows 2000 or XP
- A graphics card capable of pixel shader model 2.0 for Interactive mode.
- DirectX 9.0c and
- At least 128MB of RAM