bakelab_map.py

import bpy
from bpy.types import (
            Operator, 
            PropertyGroup, 
            Panel
        )
from bpy.props import (
            IntProperty,
            EnumProperty,
            BoolProperty,
            FloatProperty,
            StringProperty,
            PointerProperty,
            CollectionProperty
        )

class BakeLabMap(PropertyGroup):
    enabled : BoolProperty(name = '', default = True)
    type : EnumProperty(
            name = 'Type',
            items =  (
                    ('Albedo',      'Albedo',''),
                    ('Normal',      'Normal',''),
                    ('Glossy',      'Glossy',''),
                    ('Roughness',   'Roughness',''),
                    ('Emission',    'Emission',''),
                    ('Diffuse',     'Diffuse',''),
                    ('Subsurface',  'Subsurface',''),
                    ('Transmission','Transmission',''),
                    ('Shadow',      'Shadow',''),
                    ('Environment', 'Environment',''),
                    ('UV',          'UV',''),
                    None,
                    ('Combined',    'Combined',''),
                    ('CustomPass',  'Custom Pass',''),
                    ('AO',          'Ambient Occlusion',''),
                    ('Displacement','Displacement','')
            ),
            default = 'Albedo'
        )
    pass_name   : StringProperty(name = 'Property name', default = 'Color,Base Color,Albedo,Paint Color')
    deep_search : BoolProperty(
        name = 'Deep Search',
        description = 'Search inside of node groups',
        default = True
    )
    # ignore_view_transform: BoolProperty(
    #     name='Ignore View Transform',
    #     description='Set view transform to "Standart" for the duration of the bake',
    #     default=True
    # )
    # custom_source_node: StringProperty(name='Custom source node', default='', description ='Leave empty for default value')
    
    img_name : StringProperty(name = 'Image name', default = '*')
    width  : IntProperty( 
                name = 'Width', 
                default = 1024 ,
                min = 1, soft_max = 16384
            )
    height : IntProperty(
                name = 'Height',
                default = 1024,
                min = 1, soft_max = 16384
            )
    target_width  : IntProperty(name = 'Target Width')
    target_height : IntProperty(name = 'Target Height')
    image_scale : FloatProperty(
                name = 'Image Scale',
                default = 1,
                min = 0
            )
    aa_override : IntProperty(
                name = 'Anti-alias Override',
                description = 'Use individual anti-aliasing (0 to use global value)',
                default = 0,
                min = 0, soft_max = 8
            )
    final_aa : IntProperty(name = 'Final Anti-alias')

    
    float_depth: BoolProperty(name = '32 bit float', default = False)
    color_space : EnumProperty(
                name = 'Color Space',
                description = 'Color Space',
                items =  (('sRGB','sRGB',''),
                        ('Non-Color','Non-Color','')),
                default = 'sRGB'
            )
    output_colorspace : EnumProperty(
                name = 'Output Color Space',
                description = 'Output color space',
                items =  (
                    ('Default', 'Default', 'Depending on source img color space'),
                    ('Filmic Log', 'Filmic Log', ''),
                    ('Linear', 'Linear', ''),
                    ('Linear ACES', 'Linear ACES', ''),
                    ('Linear ACEScg', 'Linear ACEScg', ''),
                    ('Non-Color', 'Non-Color', ''),
                    ('Raw', 'Raw', ''),
                    ('sRGB', 'sRGB', ''),
                    ('XYZ', 'XYZ', '')
                ),
                default = 'Default'
            )
    file_format : EnumProperty(
                name = 'Format',
                items =  (
                    ('PNG',  'PNG', ''),
                    ('JPEG', 'JPEG', ''),
                    ('OPEN_EXR',  'OpenEXR', ''),
                    ('BMP',  'BMP', '')
                )
            )
    png_channels : EnumProperty(
                name = 'Color',
                items =  (('BW','BW',''),
                        ('RGB','RGB',''),
                        ('RGBA','RGBA','')),
                default = 'RGB'
            )
    png_depth : EnumProperty(
                name = 'Depth',
                description = 'Color Depth',
                items =  (('8','8 byte',''),
                        ('16','16 byte','')),
                default = '8'
            )
    png_compression : IntProperty(
                name = 'Compression', 
                default = 15,
                description = 'Compression',
                min = 0, max = 100
            )
    jpg_channels : EnumProperty(
                name = 'Color',
                items =  (('BW','BW',''),
                        ('RGB','RGB','')),
                default = 'RGB'
            )
    bmp_channels : EnumProperty(
                name = 'Color',
                items =  (('BW','BW',''),
                        ('RGB','RGB','')),
                default = 'RGB'
            )
    jpg_quality : IntProperty(
                name = 'Quality',  
                default = 90,
                description = 'Quality',
                min = 0, max = 100
            )
    exr_channels : EnumProperty(
                name = 'Color',
                items =  (('RGB','RGB',''),
                        ('RGBA','RGBA','')),
                default = 'RGB'
            )
    exr_depth : EnumProperty(
                name = 'Color Depth',
                description = 'Bits depth per channel',
                items =  (('16', 'Half (16)',''),
                        ('32',   'Full (32)','')),
                default = '32'
            )
    exr_codec_32 : EnumProperty(
                name = 'Codec',
                items =  (
                    ('NONE', 'None',           ''),
                    ('PXR24','Pxr24 (lossy)',  ''),
                    ('ZIP',  'ZIP (lossless)', ''),
                    ('PIZ',  'PIZ (lossless)', ''),
                    ('RLE',  'RLE (lossless)', ''),
                    ('ZIPS', 'ZIPS (lossless)',''),
                    ('DWAA', 'DWAA (lossy)',   '')
                ),
                default = 'ZIP'
            )
    exr_codec_16 : EnumProperty(
                name = 'Codec',
                items =  (
                    ('NONE', 'None',           ''),
                    ('PXR24','Pxr24 (lossy)',  ''),
                    ('ZIP',  'ZIP (lossless)', ''),
                    ('PIZ',  'PIZ (lossless)', ''),
                    ('RLE',  'RLE (lossless)', ''),
                    ('ZIPS', 'ZIPS (lossless)',''),
                    ('B44',  'B44 (lossy)',   ''),
                    ('B44A', 'B44A (lossy)',   ''),
                    ('DWAA', 'DWAA (lossy)',   '')
                ),
                default = 'ZIP'
            )
    samples : IntProperty(
                name = 'Samples',default = 6,
                description = 'Amount of Samples',
                min = 1, soft_max = 1024
            )
    
    normal_space : EnumProperty(
                name = 'Normal Space',
                items =  (
                    ('TANGENT','Tangent Space',''),
                    ('OBJECT', 'Object Space','')
                )
            )
                    
    bake_direct            : BoolProperty(name = 'Direct',       default = False)
    bake_indirect          : BoolProperty(name = 'Indirect',     default = False)
    bake_color             : BoolProperty(name = 'Color',        default = True)
    
    combined_direct            : BoolProperty(name = 'Direct',       default = True)
    combined_indirect          : BoolProperty(name = 'Indirect',     default = True)
    
    combined_diffuse           : BoolProperty(name = 'Diffuse',      default = True)
    combined_glossy            : BoolProperty(name = 'Glossy',       default = True)
    combined_transmission      : BoolProperty(name = 'Transmission', default = True)
    #combined_subsurface        : BoolProperty(name = 'Subsurface',   default = True)
    #combined_ambient_occlusion : BoolProperty(name = 'AO',           default = True)
    combined_emit              : BoolProperty(name = 'Emit',         default = True)
################################################################
################################################################

class BakeLabAddMapItem(bpy.types.Operator):
    """Add a new bake map"""
    bl_idname = "bakelab.newmapitem"
    bl_label = "Add bake map"
    bl_options = {'REGISTER','UNDO'}
    
    type: EnumProperty(
            name = 'Type',
            items =  (
                    ('Albedo',      'Albedo',''),
                    ('Normal',      'Normal',''),
                    ('Glossy',      'Glossy',''),
                    ('Roughness',   'Roughness',''),
                    ('Emission',    'Emission',''),
                    ('Diffuse',     'Diffuse',''),
                    ('Subsurface',  'Subsurface',''),
                    ('Transmission','Transmission',''),
                    ('Shadow',      'Shadow',''),
                    ('Environment', 'Environment',''),
                    ('UV',          'UV',''),
                    None,
                    ('Combined',    'Combined',''),
                    ('CustomPass',  'Custom Pass',''),
                    ('AO',          'Ambient Occlusion',''),
                    ('Displacement','Displacement','')
            ),
            default = 'Albedo'
        )
    # None,
    # ('c_Albedo', 'Cartoons Albedo', ''),
    # ('c_ORM', 'Cartoons ORM', ''),
    # ('c_Normal-true', 'Cartoons True Normals', '')
    width: IntProperty(name = 'Width',default = 1024,
                                    min = 1, soft_max = 16384)
    height: IntProperty(name = 'Height',default = 1024,
                                    min = 1, soft_max = 16384)
    image_scale: FloatProperty(name = 'Image Scale',default = 1,
                                    min = 0)
    
    float_depth: BoolProperty(name = '32 bit float', default = False)            
    file_format : EnumProperty(
                name = 'Format',
                items =  (
                    ('PNG',  'PNG', ''),
                    ('JPEG', 'JPEG', ''),
                    ('OPEN_EXR',  'OpenEXR', ''),
                    ('BMP',  'BMP', '')
                )
            )

    png_channels : EnumProperty(
                name = 'Color',
                items =  (('BW','BW',''),
                        ('RGB','RGB',''),
                        ('RGBA','RGBA','')),
                default = 'RGB'
            )
    png_depth : EnumProperty(
                name = 'Depth',
                description = 'Color Depth',
                items =  (('8','8 byte',''),
                        ('16','16 byte','')),
                default = '8'
            )
    output_colorspace: EnumProperty(
        name='Output Color Space',
        description='Output color space',
        items=(
            ('Default', 'Default', 'Depending on source img color space'),
            ('Filmic Log', 'Filmic Log', ''),
            ('Linear', 'Linear', ''),
            ('Linear ACES', 'Linear ACES', ''),
            ('Linear ACEScg', 'Linear ACEScg', ''),
            ('Non-Color', 'Non-Color', ''),
            ('Raw', 'Raw', ''),
            ('sRGB', 'sRGB', ''),
            ('XYZ', 'XYZ', '')
        ),
        default='Default'
    )
    # custom_source_node: StringProperty(name='Custom source node', default='',
    #                                    description='Leave empty for default value')
    # ignore_view_transform: BoolProperty(
    #     name='Ignore View Transform',
    #     description='Set view transform to "Standart" for the duration of the bake',
    #     default=True
    # )
    png_compression : IntProperty(
                name = 'Compression', 
                default = 15,
                description = 'Compression',
                min = 0, max = 100
            )
    jpg_channels : EnumProperty(
                name = 'Color',
                items =  (('BW','BW',''),
                        ('RGB','RGB','')),
                default = 'RGB'
            )
    jpg_quality : IntProperty(
                name = 'Quality',  
                default = 90,
                description = 'Quality',
                min = 0, max = 100
            )
    exr_channels : EnumProperty(
                name = 'Color',
                items =  (('RGB','RGB',''),
                        ('RGBA','RGBA','')),
                default = 'RGB'
            )
    exr_depth : EnumProperty(
                name = 'Color Depth',
                description = 'Bits depth per channel',
                items =  (('16', 'Half (16)',''),
                        ('32',   'Full (32)','')),
                default = '32'
            )
    exr_codec_32 : EnumProperty(
                name = 'Codec',
                items =  (
                    ('NONE', 'None',           ''),
                    ('PXR24','Pxr24 (lossy)',  ''),
                    ('ZIP',  'ZIP (lossless)', ''),
                    ('PIZ',  'PIZ (lossless)', ''),
                    ('RLE',  'RLE (lossless)', ''),
                    ('ZIPS', 'ZIPS (lossless)',''),
                    ('DWAA', 'DWAA (lossy)',   '')
                ),
                default = 'ZIP'
            )
    exr_codec_16 : EnumProperty(
                name = 'Codec',
                items =  (
                    ('NONE', 'None',           ''),
                    ('PXR24','Pxr24 (lossy)',  ''),
                    ('ZIP',  'ZIP (lossless)', ''),
                    ('PIZ',  'PIZ (lossless)', ''),
                    ('RLE',  'RLE (lossless)', ''),
                    ('ZIPS', 'ZIPS (lossless)',''),
                    ('B44',  'B44 (lossy)',   ''),
                    ('B44A', 'B44A (lossy)',   ''),
                    ('DWAA', 'DWAA (lossy)',   '')
                ),
                default = 'ZIP'
            )
                    
    def calcItemSettings(self,context,item):
        if self.type == 'c_Albedo':
            item.img_name = '*_orm'
            item.samples  = 4
            item.png_compression = 0
            deep_search = False
        if self.type == 'c_ORM':
            item.img_name = '*_orm'
            item.samples  = 4
            item.color_space = 'Non-Color'
            item.png_compression = 0
            item.deep_search = False
        if self.type == 'c_Normal-true':
            item.img_name = '*_n'
            item.samples = 16
            item.color_space = 'Non-Color'
            item.aa_override = 1  # Because cycles has buildin anti-aliasing for normals
            item.deep_search = False
            item.png_compression = 0
        if self.type == 'Albedo':
            item.img_name = '*_t'
            item.samples  = 4
        if self.type == 'Combined':
            item.img_name = '*_c'
            item.samples  = 64
        if self.type == 'Normal':
            item.img_name = '*_n'
            item.samples  = 16
            item.color_space = 'Non-Color'
            item.aa_override = 1 #Because cycles has buildin anti-aliasing for normals
        if self.type == 'Displacement':
            item.img_name = '*_h'
            item.samples  = 4
            item.color_space = 'Non-Color'
        if self.type == 'AO':
            item.img_name = '*_ao'
            item.samples  = 64
            item.color_space = 'Non-Color'
        if self.type == 'Shadow':
            item.img_name = '*_sh'
            item.samples  = 32
        if self.type == 'Glossy':
            item.img_name = '*_s'
            item.samples  = 8
        if self.type == 'Roughness':
            item.img_name = '*_r'
            item.samples  = 4
            item.color_space = 'Non-Color'
        if self.type == 'Diffuse':
            item.img_name = '*_d'
            item.samples  = 8
        if self.type == 'Emission':
            item.img_name = '*_e'
            item.samples  = 4
        if self.type == 'Transmission':
            item.img_name = '*_a'
            item.samples  = 8
        if self.type == 'UV':
            item.img_name = '*_uv'
            item.samples  = 1
        if self.type == 'Environment':
            item.img_name = '*_env'
            item.samples  = 16
        if self.type == 'Subsurface':
            item.img_name = '*_sss'
            item.samples  = 64
        if self.type == 'CustomPass':
            item.img_name = '*_pass'
            item.samples  = 4
            item.color_space = 'Non-Color'
    
    def draw(self,context):
        layout = self.layout
        props = context.scene.BakeLabProps
        layout.use_property_split = True
        layout.use_property_decorate = False
        
        layout.prop(self, "type")
        if props.image_size == 'FIXED':
            col = layout.column(align = True)
            col.prop(self, "width")
            col.prop(self, "height")
        elif props.image_size == 'ADAPTIVE':
            layout.prop(self, "image_scale")
            
        layout.prop(self, "float_depth")
        if props.save_or_pack == 'SAVE':
            row = layout.row()
            row.prop(self, "file_format")
            
            col = layout.column()
            if self.file_format == "PNG":
                row = col.row()
                row.prop(self, "png_channels", expand = True)
                row = col.row()
                row.prop(self, "png_depth", expand = True)
                col.prop(self, "png_compression")
            if self.file_format == "JPEG":
                row = col.row()
                row.prop(self, "jpg_channels", expand = True)
                col.prop(self, "jpg_quality")
            if self.file_format == "OPEN_EXR":
                row = col.row()
                row.prop(self, "exr_channels", expand = True)
                row = col.row()
                row.prop(self, "exr_depth", expand = True)
                if self.exr_depth == '32':
                    col.prop(self, "exr_codec_32")
                if self.exr_depth == '16':
                    col.prop(self, "exr_codec_16")
            if self.file_format == "BMP":
                row = col.row()
        
    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_dialog(self)
    
    def execute(self,context):
        context.area.tag_redraw()
        item = context.scene.BakeLabMaps.add()
        
        item.type        = self.type
        item.width       = self.width
        item.height      = self.height
        item.image_scale = self.image_scale
        item.output_colorspace = self.output_colorspace
        # item.custom_source_node = self.custom_source_node
        # item.ignore_view_transform = self.ignore_view_transform
        
        item.float_depth      = self.float_depth
        item.file_format      = self.file_format
        item.png_channels     = self.png_channels
        item.png_depth        = self.png_depth
        item.png_compression  = self.png_compression
        item.jpg_channels     = self.jpg_channels
        item.jpg_quality      = self.jpg_quality
        item.exr_channels     = self.exr_channels
        item.exr_depth        = self.exr_depth
        item.exr_codec_32     = self.exr_codec_32
        item.exr_codec_16     = self.exr_codec_16
        
        self.calcItemSettings(context, item)
        context.scene.BakeLabMapIndex = len(context.scene.BakeLabMaps)-1
        return {'FINISHED'}
        
class BakeLabRemoveMapItem(bpy.types.Operator):
    """Remove selected bake map"""
    bl_idname = "bakelab.removemapitem"
    bl_label = "remove bake map"
    bl_options = {'REGISTER','UNDO'}
    
    @classmethod
    def poll(cls,context):
        return context.scene.BakeLabMaps
    
    def execute(self,context):
        context.area.tag_redraw()
        context.scene.BakeLabMaps.remove(context.scene.BakeLabMapIndex)
        context.scene.BakeLabMapIndex = max(context.scene.BakeLabMapIndex - 1,0)
        context.scene.BakeLabMapIndex = min(context.scene.BakeLabMapIndex, len(context.scene.BakeLabMaps))
        return {'FINISHED'}
    
class BakeLabShowPassPresets(Operator):
    """Show Presets"""
    bl_idname = "bakelab.show_pass_presets"
    bl_label = "BakeLab Show Pass Presets"
    pass_presets : EnumProperty(
            name   = 'Pass Presets',
            items  =  (
                ('Color,Base Color,Albedo,Paint Color',  'Color/Albedo',''),
                ('Metallic',                             'Metallic',''),
                ('Specular,Glossiness,Glossy',           'Specular',''),
                ('Roughness',                            'Roughness',''),
                ('Anisotropic',                          'Anisotropic',''),
                ('Sheen',                                'Sheen',''),
                ('Clearcoat',                            'Clearcoat',''),
                ('Transmission',                         'Transmission ',''),
                ('Alpha',                                'Alpha ','')
            )
        )
    
    def execute(self,context):
        context.area.tag_redraw()
        scene = context.scene
        if scene.BakeLabMapIndex>=0 and scene.BakeLabMaps:
            item = scene.BakeLabMaps[scene.BakeLabMapIndex]
            if item:
                item.pass_name = self.pass_presets
        return {'FINISHED'}

################################################################

class BakeLabMapListUI(bpy.types.UIList):
    bl_idname = "BAKELAB_MAP_UL_list"
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        if self.layout_type in {'DEFAULT', 'COMPACT'}:
            if item.type == 'CustomPass':
                layout.label(text = item.pass_name, icon = 'NONE')
            else:
                layout.label(text = item.type, icon = 'NONE')
        elif self.layout_type in {'GRID'}:
            layout.alignment = 'CENTER'
            layout.label(text = "", icon = 'TEXTURE')
        layout.prop(item, 'enabled')