![\"\"](\"http:\/\/the-witness.net\/news\/wp-content\/uploads\/2010\/09\/near_nocoverage.png\")
<\/a><\/p>\n<\/p>\n
but as we moved away, the leafs started to fade and thin out:<\/p>\n
until they almost disappeared:<\/p>\n I had never encountered this problem before, neither had I heard much about it, but after a few google searches I found out that artists are often frustrated by it and usually work around the issue using various<\/a> hacks<\/a>. These are some of the proposed solutions that are usually suggested:<\/p>\n In order to address the problem it's important to understand why the geometry fades out in the distance. That is because when computing alpha mipmaps using the standard algorithms, each mipmap has a different alpha test coverage. That is, the proportion of pixels that pass the alpha test changes, in most cases going down and causing the texture to become more transparent.<\/p>\n A simple solution to the problem is to find a scale factor that preserves the original alpha test coverage as best as possible. We define the coverage of the first mipmap as follows:<\/p>\n where However, finding this This is much easier to solve, because An implementation of this algorithm is publicly available in NVTT<\/a>. The relevant code can be found in the following methods of the FloatImage class:<\/p>\n And here's a simple example of how this feature can be used through NVTT's public API:<\/p>\n As seen in the following screenshot, this solves the problem entirely:<\/p>\n even when the trees are far away from the camera:<\/p>\n<\/a><\/p>\n<\/a><\/p>\n\n
\nThese solutions may work around the problem in one way or another, but none of them is entirely correct and in some cases add a significant overhead.<\/p>\ncoverage = Sum(a_i > A_r) \/ N<\/code><\/p>\nA_r<\/code> is the alpha test value used in your application, a_i<\/code> are the alpha values of the mipmap, and N<\/code> is the number of texels in the mipmap. Then, for the following mipmaps you want to find a scale factor that causes the resulting coverage to stay the same:<\/p>\nSum(scale * a_i > A_r) \/ N == coverage<\/code><\/p>\nscale<\/code> directly is tricky because it's a discrete problem, in general, there's no exact solution, and the range of scale<\/code> is unbounded. Instead, what you can do is to find a new alpha reference value a_r<\/code> that produces the desired coverage:<\/p>\nSum(a_i > a_r) \/ N = coverage<\/code><\/p>\na_r<\/code> is bounded between 0 and 1. So, it's possible to use a simple bisection search to find the best solution. Once you know a_r<\/code> the scale is simply:<\/p>\nscale = A_r \/ a_r<\/code><\/p>\nfloat FloatImage::alphaTestCoverage<\/a>(float alphaRef, int alphaChannel) const;
\nvoid FloatImage::scaleAlphaToCoverage<\/a>(float desiredCoverage, float alphaRef, int alphaChannel);
\n<\/code><\/p>\n\r\n\/\/ Output first mipmap.\r\ncontext.compress(image, compressionOptions, outputOptions);\r\n\r\n\/\/ Estimate original coverage.\r\nconst float coverage = image.alphaTestCoverage(A_r);\r\n\r\n\/\/ Build mipmaps and scale alpha to preserve original coverage.\r\nwhile (image.buildNextMipmap(nvtt::MipmapFilter_Kaiser))\r\n{\r\n image.scaleAlphaToCoverage(coverage, A_r);\r\n context.compress(tmpImage, compressionOptions, outputOptions);\r\n}\r\n<\/pre>\n<\/a><\/p>\n