| 0,0 → 1,213 |
|---|
| #!/usr/bin/env python |
| # |
| # Copyright 2014 Intel Corporation |
| # |
| # Permission is hereby granted, free of charge, to any person obtaining a |
| # copy of this software and associated documentation files (the |
| # "Software"), to deal in the Software without restriction, including |
| # without limitation the rights to use, copy, modify, merge, publish, |
| # distribute, sub license, and/or sell copies of the Software, and to |
| # permit persons to whom the Software is furnished to do so, subject to |
| # the following conditions: |
| # |
| # The above copyright notice and this permission notice (including the |
| # next paragraph) shall be included in all copies or substantial portions |
| # of the Software. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
| # IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR |
| # ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| |
| import format_parser as parser |
| import sys |
| |
| def get_gl_base_format(fmat): |
| if fmat.name == 'MESA_FORMAT_NONE': |
| return 'GL_NONE' |
| elif fmat.name in ['MESA_FORMAT_YCBCR', 'MESA_FORMAT_YCBCR_REV']: |
| return 'GL_YCBCR_MESA' |
| elif fmat.has_channel('r'): |
| if fmat.has_channel('g'): |
| if fmat.has_channel('b'): |
| if fmat.has_channel('a'): |
| return 'GL_RGBA' |
| else: |
| return 'GL_RGB' |
| else: |
| return 'GL_RG' |
| else: |
| return 'GL_RED' |
| elif fmat.has_channel('l'): |
| if fmat.has_channel('a'): |
| return 'GL_LUMINANCE_ALPHA' |
| else: |
| return 'GL_LUMINANCE' |
| elif fmat.has_channel('a') and fmat.num_channels() == 1: |
| return 'GL_ALPHA' |
| elif fmat.has_channel('z'): |
| if fmat.has_channel('s'): |
| return 'GL_DEPTH_STENCIL' |
| else: |
| return 'GL_DEPTH_COMPONENT' |
| elif fmat.has_channel('s'): |
| return 'GL_STENCIL_INDEX' |
| elif fmat.has_channel('i') and fmat.num_channels() == 1: |
| return 'GL_INTENSITY' |
| else: |
| sys.exit("error, could not determine base format for {0}, check swizzle".format(fmat.name)); |
| |
| def get_gl_data_type(fmat): |
| if fmat.is_compressed(): |
| if 'FLOAT' in fmat.name: |
| return 'GL_FLOAT' |
| elif 'SIGNED' in fmat.name or 'SNORM' in fmat.name: |
| return 'GL_SIGNED_NORMALIZED' |
| else: |
| return 'GL_UNSIGNED_NORMALIZED' |
| elif fmat.name in ['MESA_FORMAT_YCBCR', 'MESA_FORMAT_YCBCR_REV']: |
| return 'GL_UNSIGNED_NORMALIZED' |
| |
| channel = None |
| for chan in fmat.channels: |
| if chan.type == 'x' and len(fmat.channels) > 1: |
| continue # We can do better |
| elif chan.name == 's' and fmat.has_channel('z'): |
| continue # We'll use the type from the depth instead |
| |
| channel = chan |
| break; |
| |
| if channel.type == parser.UNSIGNED: |
| if channel.norm: |
| return 'GL_UNSIGNED_NORMALIZED' |
| else: |
| return 'GL_UNSIGNED_INT' |
| elif channel.type == parser.SIGNED: |
| if channel.norm: |
| return 'GL_SIGNED_NORMALIZED' |
| else: |
| return 'GL_INT' |
| elif channel.type == parser.FLOAT: |
| return 'GL_FLOAT' |
| elif channel.type == parser.VOID: |
| return 'GL_NONE' |
| else: |
| assert False |
| |
| def get_mesa_layout(fmat): |
| if fmat.layout == 'array': |
| return 'MESA_FORMAT_LAYOUT_ARRAY' |
| elif fmat.layout == 'packed': |
| return 'MESA_FORMAT_LAYOUT_PACKED' |
| else: |
| return 'MESA_FORMAT_LAYOUT_OTHER' |
| |
| def get_channel_bits(fmat, chan_name): |
| if fmat.is_compressed(): |
| # These values are pretty-much bogus, but OpenGL requires that we |
| # return an "approximate" number of bits. |
| if fmat.layout == 's3tc': |
| return 4 if fmat.has_channel(chan_name) else 0 |
| elif fmat.layout == 'fxt1': |
| if chan_name in 'rgb': |
| return 4 |
| elif chan_name == 'a': |
| return 1 if fmat.has_channel('a') else 0 |
| else: |
| return 0 |
| elif fmat.layout == 'rgtc': |
| return 8 if fmat.has_channel(chan_name) else 0 |
| elif fmat.layout in ('etc1', 'etc2'): |
| if fmat.name.endswith('_ALPHA1') and chan_name == 'a': |
| return 1 |
| |
| bits = 11 if fmat.name.endswith('11_EAC') else 8 |
| return bits if fmat.has_channel(chan_name) else 0 |
| elif fmat.layout == 'bptc': |
| bits = 16 if fmat.name.endswith('_FLOAT') else 8 |
| return bits if fmat.has_channel(chan_name) else 0 |
| else: |
| assert False |
| else: |
| # Uncompressed textures |
| for chan in fmat.channels: |
| if chan.name == chan_name: |
| return chan.size |
| return 0 |
| |
| formats = parser.parse(sys.argv[1]) |
| |
| print ''' |
| /* |
| * Mesa 3-D graphics library |
| * |
| * Copyright (c) 2014 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included |
| * in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| * OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| /* |
| * This file is AUTOGENERATED by format_info.py. Do not edit it |
| * manually or commit it into version control. |
| */ |
| |
| static struct gl_format_info format_info[MESA_FORMAT_COUNT] = |
| { |
| ''' |
| |
| for fmat in formats: |
| print ' {' |
| print ' {0},'.format(fmat.name) |
| print ' "{0}",'.format(fmat.name) |
| print ' {0},'.format(get_mesa_layout(fmat)) |
| print ' {0},'.format(get_gl_base_format(fmat)) |
| print ' {0},'.format(get_gl_data_type(fmat)) |
| |
| bits = [ get_channel_bits(fmat, name) for name in ['r', 'g', 'b', 'a']] |
| print ' {0},'.format(', '.join(map(str, bits))) |
| bits = [ get_channel_bits(fmat, name) for name in ['l', 'i', 'z', 's']] |
| print ' {0},'.format(', '.join(map(str, bits))) |
| |
| print ' {0}, {1}, {2},'.format(fmat.block_width, fmat.block_height, |
| int(fmat.block_size() / 8)) |
| |
| print ' {{ {0} }},'.format(', '.join(map(str, fmat.swizzle))) |
| if fmat.is_array(): |
| chan = fmat.array_element() |
| norm = chan.norm or chan.type == parser.FLOAT |
| print ' MESA_ARRAY_FORMAT({0}),'.format(', '.join([ |
| str(chan.size / 8), |
| str(int(chan.sign)), |
| str(int(chan.type == parser.FLOAT)), |
| str(int(norm)), |
| str(len(fmat.channels)), |
| str(fmat.swizzle[0]), |
| str(fmat.swizzle[1]), |
| str(fmat.swizzle[2]), |
| str(fmat.swizzle[3]), |
| ])) |
| else: |
| print ' 0,' |
| print ' },' |
| |
| print '};' |