|
| 1 | +// Copyright Contributors to the OpenImageIO project. |
| 2 | +// SPDX-License-Identifier: Apache-2.0 |
| 3 | +// https://github.com/AcademySoftwareFoundation/OpenImageIO |
| 4 | + |
| 5 | +#include "py_oiio.h" |
| 6 | + |
| 7 | +namespace { |
| 8 | + |
| 9 | +OIIO_NAMESPACE_USING |
| 10 | + |
| 11 | +template<class Enum> |
| 12 | +void |
| 13 | +typedesc_property(TypeDesc& t, Enum value); |
| 14 | + |
| 15 | +template<> |
| 16 | +void |
| 17 | +typedesc_property<TypeDesc::BASETYPE>(TypeDesc& t, TypeDesc::BASETYPE value) |
| 18 | +{ |
| 19 | + t.basetype = value; |
| 20 | +} |
| 21 | + |
| 22 | +template<> |
| 23 | +void |
| 24 | +typedesc_property<TypeDesc::AGGREGATE>(TypeDesc& t, TypeDesc::AGGREGATE value) |
| 25 | +{ |
| 26 | + t.aggregate = value; |
| 27 | +} |
| 28 | + |
| 29 | +template<> |
| 30 | +void |
| 31 | +typedesc_property<TypeDesc::VECSEMANTICS>(TypeDesc& t, |
| 32 | + TypeDesc::VECSEMANTICS value) |
| 33 | +{ |
| 34 | + t.vecsemantics = value; |
| 35 | +} |
| 36 | + |
| 37 | +} // namespace |
| 38 | + |
| 39 | + |
| 40 | +namespace PyOpenImageIO { |
| 41 | + |
| 42 | +void |
| 43 | +declare_typedesc(nb::module_& m) |
| 44 | +{ |
| 45 | + using BASETYPE = TypeDesc::BASETYPE; |
| 46 | + using AGGREGATE = TypeDesc::AGGREGATE; |
| 47 | + using VECSEMANTICS = TypeDesc::VECSEMANTICS; |
| 48 | + |
| 49 | + nb::enum_<BASETYPE>(m, "BASETYPE") |
| 50 | + .value("UNKNOWN", TypeDesc::UNKNOWN) |
| 51 | + .value("NONE", TypeDesc::NONE) |
| 52 | + .value("UCHAR", TypeDesc::UCHAR) |
| 53 | + .value("UINT8", TypeDesc::UINT8) |
| 54 | + .value("CHAR", TypeDesc::CHAR) |
| 55 | + .value("INT8", TypeDesc::INT8) |
| 56 | + .value("UINT16", TypeDesc::UINT16) |
| 57 | + .value("USHORT", TypeDesc::USHORT) |
| 58 | + .value("SHORT", TypeDesc::SHORT) |
| 59 | + .value("INT16", TypeDesc::INT16) |
| 60 | + .value("UINT", TypeDesc::UINT) |
| 61 | + .value("UINT32", TypeDesc::UINT32) |
| 62 | + .value("INT", TypeDesc::INT) |
| 63 | + .value("INT32", TypeDesc::INT32) |
| 64 | + .value("ULONGLONG", TypeDesc::ULONGLONG) |
| 65 | + .value("UINT64", TypeDesc::UINT64) |
| 66 | + .value("LONGLONG", TypeDesc::LONGLONG) |
| 67 | + .value("INT64", TypeDesc::INT64) |
| 68 | + .value("HALF", TypeDesc::HALF) |
| 69 | + .value("FLOAT", TypeDesc::FLOAT) |
| 70 | + .value("DOUBLE", TypeDesc::DOUBLE) |
| 71 | + .value("STRING", TypeDesc::STRING) |
| 72 | + .value("PTR", TypeDesc::PTR) |
| 73 | + .value("LASTBASE", TypeDesc::LASTBASE) |
| 74 | + .export_values(); |
| 75 | + |
| 76 | + nb::enum_<AGGREGATE>(m, "AGGREGATE") |
| 77 | + .value("SCALAR", TypeDesc::SCALAR) |
| 78 | + .value("VEC2", TypeDesc::VEC2) |
| 79 | + .value("VEC3", TypeDesc::VEC3) |
| 80 | + .value("VEC4", TypeDesc::VEC4) |
| 81 | + .value("MATRIX33", TypeDesc::MATRIX33) |
| 82 | + .value("MATRIX44", TypeDesc::MATRIX44) |
| 83 | + .export_values(); |
| 84 | + |
| 85 | + nb::enum_<VECSEMANTICS>(m, "VECSEMANTICS") |
| 86 | + .value("NOXFORM", TypeDesc::NOXFORM) |
| 87 | + .value("NOSEMANTICS", TypeDesc::NOSEMANTICS) |
| 88 | + .value("COLOR", TypeDesc::COLOR) |
| 89 | + .value("POINT", TypeDesc::POINT) |
| 90 | + .value("VECTOR", TypeDesc::VECTOR) |
| 91 | + .value("NORMAL", TypeDesc::NORMAL) |
| 92 | + .value("TIMECODE", TypeDesc::TIMECODE) |
| 93 | + .value("KEYCODE", TypeDesc::KEYCODE) |
| 94 | + .value("RATIONAL", TypeDesc::RATIONAL) |
| 95 | + .value("BOX", TypeDesc::BOX) |
| 96 | + .export_values(); |
| 97 | + |
| 98 | + nb::class_<TypeDesc>(m, "TypeDesc") |
| 99 | + .def_prop_rw( |
| 100 | + "basetype", |
| 101 | + [](TypeDesc t) { return BASETYPE(t.basetype); }, |
| 102 | + [](TypeDesc& t, BASETYPE b) { typedesc_property(t, b); }) |
| 103 | + .def_prop_rw( |
| 104 | + "aggregate", |
| 105 | + [](TypeDesc t) { return AGGREGATE(t.aggregate); }, |
| 106 | + [](TypeDesc& t, AGGREGATE b) { typedesc_property(t, b); }) |
| 107 | + .def_prop_rw( |
| 108 | + "vecsemantics", |
| 109 | + [](TypeDesc t) { return VECSEMANTICS(t.vecsemantics); }, |
| 110 | + [](TypeDesc& t, VECSEMANTICS b) { typedesc_property(t, b); }) |
| 111 | + .def_rw("arraylen", &TypeDesc::arraylen) |
| 112 | + .def(nb::init<>()) |
| 113 | + .def(nb::init<const TypeDesc&>()) |
| 114 | + .def(nb::init<BASETYPE>()) |
| 115 | + .def(nb::init<BASETYPE, AGGREGATE>()) |
| 116 | + .def(nb::init<BASETYPE, AGGREGATE, VECSEMANTICS>()) |
| 117 | + .def(nb::init<BASETYPE, AGGREGATE, VECSEMANTICS, int>()) |
| 118 | + .def(nb::init<const char*>()) |
| 119 | + .def("c_str", [](const TypeDesc& self) { return std::string(self.c_str()); }) |
| 120 | + .def("numelements", &TypeDesc::numelements) |
| 121 | + .def("basevalues", &TypeDesc::basevalues) |
| 122 | + .def("size", &TypeDesc::size) |
| 123 | + .def("elementtype", &TypeDesc::elementtype) |
| 124 | + .def("elementsize", &TypeDesc::elementsize) |
| 125 | + .def("basesize", &TypeDesc::basesize) |
| 126 | + .def("fromstring", |
| 127 | + [](TypeDesc& t, const char* typestring) { t.fromstring(typestring); }) |
| 128 | + .def("equivalent", &TypeDesc::equivalent) |
| 129 | + .def("unarray", &TypeDesc::unarray) |
| 130 | + .def("is_vec2", &TypeDesc::is_vec2) |
| 131 | + .def("is_vec3", &TypeDesc::is_vec3) |
| 132 | + .def("is_vec4", &TypeDesc::is_vec4) |
| 133 | + .def("is_box2", &TypeDesc::is_box2) |
| 134 | + .def("is_box3", &TypeDesc::is_box3) |
| 135 | + .def_static("all_types_equal", |
| 136 | + [](const std::vector<TypeDesc>& types) { |
| 137 | + return TypeDesc::all_types_equal(types); |
| 138 | + }) |
| 139 | + .def(nb::self == nb::self) |
| 140 | + .def(nb::self != nb::self) |
| 141 | + .def("__str__", [](TypeDesc t) { return std::string(t.c_str()); }) |
| 142 | + .def("__repr__", |
| 143 | + [](TypeDesc t) { |
| 144 | + return Strutil::fmt::format("<TypeDesc '{}'>", t.c_str()); |
| 145 | + }); |
| 146 | + |
| 147 | + m.attr("UNKNOWN") = nb::cast(TypeDesc::UNKNOWN); |
| 148 | + m.attr("NONE") = nb::cast(TypeDesc::NONE); |
| 149 | + m.attr("UCHAR") = nb::cast(TypeDesc::UCHAR); |
| 150 | + m.attr("UINT8") = nb::cast(TypeDesc::UINT8); |
| 151 | + m.attr("CHAR") = nb::cast(TypeDesc::CHAR); |
| 152 | + m.attr("INT8") = nb::cast(TypeDesc::INT8); |
| 153 | + m.attr("UINT16") = nb::cast(TypeDesc::UINT16); |
| 154 | + m.attr("USHORT") = nb::cast(TypeDesc::USHORT); |
| 155 | + m.attr("SHORT") = nb::cast(TypeDesc::SHORT); |
| 156 | + m.attr("INT16") = nb::cast(TypeDesc::INT16); |
| 157 | + m.attr("UINT") = nb::cast(TypeDesc::UINT); |
| 158 | + m.attr("UINT32") = nb::cast(TypeDesc::UINT32); |
| 159 | + m.attr("INT") = nb::cast(TypeDesc::INT); |
| 160 | + m.attr("INT32") = nb::cast(TypeDesc::INT32); |
| 161 | + m.attr("ULONGLONG") = nb::cast(TypeDesc::ULONGLONG); |
| 162 | + m.attr("UINT64") = nb::cast(TypeDesc::UINT64); |
| 163 | + m.attr("LONGLONG") = nb::cast(TypeDesc::LONGLONG); |
| 164 | + m.attr("INT64") = nb::cast(TypeDesc::INT64); |
| 165 | + m.attr("HALF") = nb::cast(TypeDesc::HALF); |
| 166 | + m.attr("FLOAT") = nb::cast(TypeDesc::FLOAT); |
| 167 | + m.attr("DOUBLE") = nb::cast(TypeDesc::DOUBLE); |
| 168 | + m.attr("STRING") = nb::cast(TypeDesc::STRING); |
| 169 | + m.attr("PTR") = nb::cast(TypeDesc::PTR); |
| 170 | + m.attr("LASTBASE") = nb::cast(TypeDesc::LASTBASE); |
| 171 | + |
| 172 | + m.attr("SCALAR") = nb::cast(TypeDesc::SCALAR); |
| 173 | + m.attr("VEC2") = nb::cast(TypeDesc::VEC2); |
| 174 | + m.attr("VEC3") = nb::cast(TypeDesc::VEC3); |
| 175 | + m.attr("VEC4") = nb::cast(TypeDesc::VEC4); |
| 176 | + m.attr("MATRIX33") = nb::cast(TypeDesc::MATRIX33); |
| 177 | + m.attr("MATRIX44") = nb::cast(TypeDesc::MATRIX44); |
| 178 | + |
| 179 | + m.attr("NOXFORM") = nb::cast(TypeDesc::NOXFORM); |
| 180 | + m.attr("NOSEMANTICS") = nb::cast(TypeDesc::NOSEMANTICS); |
| 181 | + m.attr("COLOR") = nb::cast(TypeDesc::COLOR); |
| 182 | + m.attr("POINT") = nb::cast(TypeDesc::POINT); |
| 183 | + m.attr("VECTOR") = nb::cast(TypeDesc::VECTOR); |
| 184 | + m.attr("NORMAL") = nb::cast(TypeDesc::NORMAL); |
| 185 | + m.attr("TIMECODE") = nb::cast(TypeDesc::TIMECODE); |
| 186 | + m.attr("KEYCODE") = nb::cast(TypeDesc::KEYCODE); |
| 187 | + m.attr("RATIONAL") = nb::cast(TypeDesc::RATIONAL); |
| 188 | + m.attr("BOX") = nb::cast(TypeDesc::BOX); |
| 189 | + |
| 190 | + m.attr("TypeUnknown") = TypeUnknown; |
| 191 | + m.attr("TypeFloat") = TypeFloat; |
| 192 | + m.attr("TypeColor") = TypeColor; |
| 193 | + m.attr("TypePoint") = TypePoint; |
| 194 | + m.attr("TypeVector") = TypeVector; |
| 195 | + m.attr("TypeNormal") = TypeNormal; |
| 196 | + m.attr("TypeString") = TypeString; |
| 197 | + m.attr("TypeInt") = TypeInt; |
| 198 | + m.attr("TypeUInt") = TypeUInt; |
| 199 | + m.attr("TypeInt64") = TypeInt64; |
| 200 | + m.attr("TypeUInt64") = TypeUInt64; |
| 201 | + m.attr("TypeInt32") = TypeInt32; |
| 202 | + m.attr("TypeUInt32") = TypeUInt32; |
| 203 | + m.attr("TypeInt16") = TypeInt16; |
| 204 | + m.attr("TypeUInt16") = TypeUInt16; |
| 205 | + m.attr("TypeInt8") = TypeInt8; |
| 206 | + m.attr("TypeUInt8") = TypeUInt8; |
| 207 | + m.attr("TypeHalf") = TypeHalf; |
| 208 | + m.attr("TypeMatrix") = TypeMatrix; |
| 209 | + m.attr("TypeMatrix33") = TypeMatrix33; |
| 210 | + m.attr("TypeMatrix44") = TypeMatrix44; |
| 211 | + m.attr("TypeTimeCode") = TypeTimeCode; |
| 212 | + m.attr("TypeKeyCode") = TypeKeyCode; |
| 213 | + m.attr("TypeFloat2") = TypeFloat2; |
| 214 | + m.attr("TypeVector2") = TypeVector2; |
| 215 | + m.attr("TypeFloat4") = TypeFloat4; |
| 216 | + m.attr("TypeVector4") = TypeVector4; |
| 217 | + m.attr("TypeVector2i") = TypeVector2i; |
| 218 | + m.attr("TypeVector3i") = TypeVector3i; |
| 219 | + m.attr("TypeBox2") = TypeBox2; |
| 220 | + m.attr("TypeBox3") = TypeBox3; |
| 221 | + m.attr("TypeBox2i") = TypeBox2i; |
| 222 | + m.attr("TypeBox3i") = TypeBox3i; |
| 223 | + m.attr("TypeRational") = TypeRational; |
| 224 | + m.attr("TypeURational") = TypeURational; |
| 225 | + m.attr("TypePointer") = TypePointer; |
| 226 | +} |
| 227 | + |
| 228 | +} // namespace PyOpenImageIO |
0 commit comments