170 lines
6.4 KiB
Python
170 lines
6.4 KiB
Python
"""
|
|
Copyright (C) 2023 Adobe.
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
# file: props/sbsar_output.py
|
|
# brief: Substance Property Groups
|
|
# author Adobe - 3D & Immersive
|
|
# copyright 2023 Adobe Inc. All rights reserved.
|
|
|
|
|
|
import bpy
|
|
|
|
from ..thread_ops import SUBSTANCE_Threads
|
|
from ..sbsar.async_ops import _render_sbsar
|
|
from ..utils import SUBSTANCE_Utils
|
|
from ..common import (
|
|
IMAGE_FORMAT_DICT,
|
|
IMAGE_BITDEPTH_DICT
|
|
)
|
|
|
|
|
|
class SUBSTANCE_PG_SbsarOutputChannelUse(bpy.types.PropertyGroup):
|
|
value: bpy.props.StringProperty(name="value")
|
|
|
|
|
|
def on_output_update(self, context):
|
|
if not self.shader_callback_enabled:
|
|
return
|
|
|
|
_sbsar = context.scene.loaded_sbsars[context.scene.sbsar_index]
|
|
_graph = SUBSTANCE_Utils.get_selected_graph(context)
|
|
|
|
SUBSTANCE_Threads.alt_thread_run(_render_sbsar, (context, _sbsar, int(_graph.index)))
|
|
|
|
|
|
def get_colorspace_dict(self, context):
|
|
return SUBSTANCE_Utils.get_colorspaces()
|
|
|
|
|
|
def get_bitdepths(self, context):
|
|
return IMAGE_BITDEPTH_DICT[self.shader_format]
|
|
|
|
|
|
class SUBSTANCE_PG_SbsarOutput(bpy.types.PropertyGroup):
|
|
id: bpy.props.StringProperty(name="id")
|
|
index: bpy.props.IntProperty(name="index")
|
|
name: bpy.props.StringProperty(name="name")
|
|
graphID: bpy.props.StringProperty(name="graphID")
|
|
format: bpy.props.IntProperty(name="format")
|
|
mipmaps: bpy.props.IntProperty(name="mipmaps")
|
|
identifier: bpy.props.StringProperty(name="identifier")
|
|
label: bpy.props.StringProperty(name="label")
|
|
guiDescription: bpy.props.StringProperty(name="guiDescription")
|
|
group: bpy.props.StringProperty(name="group")
|
|
guiVisibleIf: bpy.props.StringProperty(name="guiVisibleIf")
|
|
userTag: bpy.props.StringProperty(name="userTag")
|
|
type: bpy.props.StringProperty(name="type")
|
|
guiType: bpy.props.StringProperty(name="guiType")
|
|
defaultChannelUse: bpy.props.StringProperty(name="defaultChannelUse")
|
|
enabled: bpy.props.BoolProperty(name="enabled")
|
|
channelUseSpecified: bpy.props.BoolProperty(name="channelUseSpecified")
|
|
channelUse: bpy.props.CollectionProperty(type=SUBSTANCE_PG_SbsarOutputChannelUse)
|
|
|
|
shader_callback_enabled: bpy.props.BoolProperty(name="shader_callback_enabled", default=False)
|
|
shader_enabled: bpy.props.BoolProperty(
|
|
name="shader_enabled",
|
|
default=False,
|
|
update=on_output_update)
|
|
shader_colorspace: bpy.props.EnumProperty(
|
|
name="shader_colorspace",
|
|
description="The available colorspaces to be applied to this map", # noqa
|
|
items=get_colorspace_dict,
|
|
update=on_output_update)
|
|
shader_format: bpy.props.EnumProperty(
|
|
name="shader_format",
|
|
description="The available colorspaces to be applied to this map", # noqa
|
|
items=IMAGE_FORMAT_DICT,
|
|
update=on_output_update)
|
|
shader_bitdepth: bpy.props.EnumProperty(
|
|
name="shader_bitdepth",
|
|
description="The available colorspaces to be applied to this map", # noqa
|
|
items=get_bitdepths,
|
|
update=on_output_update)
|
|
|
|
filepath: bpy.props.StringProperty(name="filepath", default="") # noqa
|
|
filename: bpy.props.StringProperty(name="filename", default="") # noqa
|
|
|
|
def init(self, output):
|
|
self.id = str(output.id)
|
|
self.index = output.index
|
|
self.name = output.defaultChannelUse if output.defaultChannelUse != "UNKNOWN" else output.identifier
|
|
self.graphID = str(output.graphID)
|
|
self.format = output.format
|
|
self.mipmaps = output.mipmaps
|
|
self.identifier = output.identifier
|
|
self.label = output.label
|
|
self.guiDescription = output.guiDescription
|
|
self.group = output.group
|
|
self.guiVisibleIf = output.guiVisibleIf
|
|
self.userTag = output.userTag
|
|
self.type = output.type
|
|
self.guiType = output.guiType
|
|
self.defaultChannelUse = output.defaultChannelUse
|
|
self.enabled = output.enabled
|
|
self.channelUseSpecified = output.channelUseSpecified
|
|
|
|
for _use in output.channelUse:
|
|
_new_use = self.channelUse.add()
|
|
_new_use.value = _use
|
|
|
|
def init_shader(self, shader, default_output):
|
|
if self.name not in shader.outputs:
|
|
self.shader_enabled = default_output["enabled"]
|
|
self.shader_format = default_output["format"]
|
|
self.shader_bitdepth = default_output["bitdepth"]
|
|
else:
|
|
for _output in shader.outputs:
|
|
if _output.id == self.name:
|
|
self.shader_enabled = _output.enabled
|
|
self.shader_format = _output.format
|
|
self.shader_bitdepth = _output.bitdepth
|
|
self.shader_callback_enabled = True
|
|
|
|
def init_output(self, default_output):
|
|
self.shader_callback_enabled = False
|
|
self.shader_enabled = default_output.shader_enabled
|
|
self.shader_format = default_output.shader_format
|
|
self.shader_bitdepth = default_output.shader_bitdepth
|
|
self.shader_callback_enabled = True
|
|
|
|
def get(self):
|
|
_obj = {
|
|
"id": int(self.id),
|
|
"graphID": int(self.graphID),
|
|
"format": self.format,
|
|
"mipmaps": self.mipmaps,
|
|
"identifier": self.identifier,
|
|
"label": self.label,
|
|
"guiDescription": self.guiDescription,
|
|
"group": self.group,
|
|
"guiVisibleIf": self.guiVisibleIf,
|
|
"userTag": self.userTag,
|
|
"type": self.type,
|
|
"guiType": self.guiType,
|
|
"defaultChannelUse": self.defaultChannelUse,
|
|
"enabled": self.enabled,
|
|
"channelUseSpecified": self.channelUseSpecified,
|
|
"channelUse": [],
|
|
"shader_enabled": self.shader_enabled,
|
|
"shader_colorspace": self.shader_colorspace,
|
|
"shader_format": self.shader_format,
|
|
"shader_bitdepth": self.shader_bitdepth
|
|
}
|
|
|
|
for _use in self.channelUse:
|
|
_obj["channelUse"].append(_use.value)
|
|
return _obj
|