449 lines
15 KiB
C++
449 lines
15 KiB
C++
#include "plugin_param_interface.h"
|
|
#include "plugin_utilities.h"
|
|
#include "tparamset.h"
|
|
#include "../include/ttonecurveparam.h"
|
|
#include "../include/toonzqt/fxsettings.h"
|
|
#include "plugin_param_traits.h"
|
|
|
|
/* 公開インターフェイスからは削除 */
|
|
enum toonz_param_value_type_enum {
|
|
/* deprecated */
|
|
TOONZ_PARAM_VALUE_TYPE_CHAR = 1,
|
|
TOONZ_PARAM_VALUE_TYPE_INT = 4,
|
|
TOONZ_PARAM_VALUE_TYPE_DOUBLE = 8,
|
|
|
|
TOONZ_PARAM_VALUE_TYPE_NB,
|
|
TOONZ_PARAM_VALUE_TYPE_MAX = 0x7FFFFFFF
|
|
};
|
|
|
|
enum toonz_value_unit_enum {
|
|
TOONZ_PARAM_UNIT_NONE,
|
|
TOONZ_PARAM_UNIT_LENGTH,
|
|
TOONZ_PARAM_UNIT_ANGLE,
|
|
TOONZ_PARAM_UNIT_SCALE,
|
|
TOONZ_PARAM_UNIT_PERCENTAGE,
|
|
TOONZ_PARAM_UNIT_PERCENTAGE2,
|
|
TOONZ_PARAM_UNIT_SHEAR,
|
|
TOONZ_PARAM_UNIT_COLOR_CHANNEL,
|
|
|
|
TOONZ_PARAM_UNIT_NB,
|
|
TOONZ_PARAM_UNIT_MAX = 0x7FFFFFFF
|
|
};
|
|
|
|
static int set_value_unit(TDoubleParamP param, toonz_value_unit_enum unit);
|
|
|
|
int hint_default_value(toonz_param_handle_t param, int size_in_bytes,
|
|
const void *default_value) {
|
|
if (Param *_ = reinterpret_cast<Param *>(param)) {
|
|
TParamP param = _->param();
|
|
|
|
if (TDoubleParamP p = param) {
|
|
if (size_in_bytes != sizeof(double)) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const double *values = reinterpret_cast<const double *>(default_value);
|
|
p->setDefaultValue(values[0]);
|
|
} else if (TRangeParamP p = param) {
|
|
if (size_in_bytes != sizeof(double) * 2) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const double *values = reinterpret_cast<const double *>(default_value);
|
|
p->setDefaultValue(std::make_pair(values[0], values[1]));
|
|
} else if (TPixelParamP p = param) {
|
|
if (size_in_bytes != sizeof(double) * 4) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const double *values = reinterpret_cast<const double *>(default_value);
|
|
p->setDefaultValue(
|
|
toPixel32(TPixelD(values[0], values[1], values[2], values[3])));
|
|
} else if (TPointParamP p = param) {
|
|
if (size_in_bytes != sizeof(double) * 2) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const double *values = reinterpret_cast<const double *>(default_value);
|
|
p->setDefaultValue(TPointD(values[0], values[1]));
|
|
} else if (TIntEnumParamP p = param) {
|
|
if (size_in_bytes != sizeof(int)) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const int *values = reinterpret_cast<const int *>(default_value);
|
|
p->setDefaultValue(values[0]);
|
|
} else if (TIntParamP p = param) {
|
|
if (size_in_bytes != sizeof(int)) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const int *values = reinterpret_cast<const int *>(default_value);
|
|
p->setDefaultValue(values[0]);
|
|
} else if (TBoolParamP p = param) {
|
|
if (size_in_bytes != sizeof(int)) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const int *values = reinterpret_cast<const int *>(default_value);
|
|
p->setDefaultValue(values[0]);
|
|
} else if (TSpectrumParamP p = param) {
|
|
const double *values = reinterpret_cast<const double *>(default_value);
|
|
const int count = size_in_bytes / (sizeof(double) * 5);
|
|
std::vector<TSpectrum::ColorKey> keys(count);
|
|
for (int i = 0; i < count; i++) {
|
|
keys[i].first = values[5 * i + 0];
|
|
keys[i].second =
|
|
toPixel32(TPixelD(values[5 * i + 1], values[5 * i + 2],
|
|
values[5 * i + 3], values[5 * i + 4]));
|
|
}
|
|
p->setDefaultValue(TSpectrum(count, keys.data()));
|
|
} else if (TStringParamP p = param) {
|
|
if (size_in_bytes < 1) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const char *values = reinterpret_cast<const char *>(default_value);
|
|
p->setDefaultValue(QString::fromStdString(values).toStdWString());
|
|
} else if (TToneCurveParamP p = param) {
|
|
const double *values = reinterpret_cast<const double *>(default_value);
|
|
const int count = size_in_bytes / (sizeof(double) * 2);
|
|
QList<TPointD> list;
|
|
for (int i = 0; i < count; ++i) {
|
|
list.push_back(TPointD(values[2 * i + 0], values[2 * i + 1]));
|
|
}
|
|
p->setDefaultValue(list);
|
|
} else {
|
|
return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
} else {
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
return TOONZ_OK;
|
|
}
|
|
|
|
int hint_value_range(toonz_param_handle_t param, const void *minvalue,
|
|
const void *maxvalue) {
|
|
if (Param *_ = reinterpret_cast<Param *>(param)) {
|
|
TParamP param = _->param();
|
|
|
|
if (TDoubleParamP p = param) {
|
|
p->setValueRange(*reinterpret_cast<const double *>(minvalue),
|
|
*reinterpret_cast<const double *>(maxvalue));
|
|
} else if (TRangeParamP p = param) {
|
|
const double minv = *reinterpret_cast<const double *>(minvalue);
|
|
const double maxv = *reinterpret_cast<const double *>(maxvalue);
|
|
p->getMin()->setValueRange(minv, maxv);
|
|
p->getMax()->setValueRange(minv, maxv);
|
|
} else if (TPointParamP p = param) {
|
|
const double minv = *reinterpret_cast<const double *>(minvalue);
|
|
const double maxv = *reinterpret_cast<const double *>(maxvalue);
|
|
p->getX()->setValueRange(minv, maxv);
|
|
p->getY()->setValueRange(minv, maxv);
|
|
} else if (TIntParamP p = param) {
|
|
p->setValueRange(*reinterpret_cast<const int *>(minvalue),
|
|
*reinterpret_cast<const int *>(maxvalue));
|
|
} else {
|
|
return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
} else {
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
return TOONZ_OK;
|
|
}
|
|
|
|
int hint_unit(toonz_param_handle_t param, int unit) {
|
|
if (Param *_ = reinterpret_cast<Param *>(param)) {
|
|
TParamP param = _->param();
|
|
|
|
if (TDoubleParamP p = param) {
|
|
return set_value_unit(p, toonz_value_unit_enum(unit));
|
|
} else if (TRangeParamP p = param) {
|
|
if (const int retval =
|
|
set_value_unit(p->getMin(), toonz_value_unit_enum(unit))) {
|
|
return retval;
|
|
}
|
|
return set_value_unit(p->getMax(), toonz_value_unit_enum(unit));
|
|
} else if (TPointParamP p = param) {
|
|
if (const int retval =
|
|
set_value_unit(p->getX(), toonz_value_unit_enum(unit))) {
|
|
return retval;
|
|
}
|
|
return set_value_unit(p->getY(), toonz_value_unit_enum(unit));
|
|
} else {
|
|
return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
} else {
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
}
|
|
|
|
int hint_item(toonz_param_handle_t param, int item, const char *caption) {
|
|
if (Param *_ = reinterpret_cast<Param *>(param)) {
|
|
TParamP param = _->param();
|
|
|
|
if (TIntEnumParamP p = param) {
|
|
p->addItem(item, caption);
|
|
} else {
|
|
return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
} else {
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
return TOONZ_OK;
|
|
}
|
|
|
|
int set_description(toonz_param_handle_t param, const char *description) {
|
|
if (Param *_ = reinterpret_cast<Param *>(param)) {
|
|
TParamP param = _->param();
|
|
param->setDescription(description);
|
|
} else {
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
return TOONZ_OK;
|
|
}
|
|
|
|
static int set_value_unit(TDoubleParamP param, toonz_value_unit_enum unit) {
|
|
switch (unit) {
|
|
case TOONZ_PARAM_UNIT_NONE:
|
|
break;
|
|
case TOONZ_PARAM_UNIT_LENGTH:
|
|
param->setMeasureName("fxLength");
|
|
break;
|
|
case TOONZ_PARAM_UNIT_ANGLE:
|
|
param->setMeasureName("angle");
|
|
break;
|
|
case TOONZ_PARAM_UNIT_SCALE:
|
|
param->setMeasureName("scale");
|
|
break;
|
|
case TOONZ_PARAM_UNIT_PERCENTAGE:
|
|
param->setMeasureName("percentage");
|
|
break;
|
|
case TOONZ_PARAM_UNIT_PERCENTAGE2:
|
|
param->setMeasureName("percentage2");
|
|
break;
|
|
case TOONZ_PARAM_UNIT_SHEAR:
|
|
param->setMeasureName("shear");
|
|
break;
|
|
case TOONZ_PARAM_UNIT_COLOR_CHANNEL:
|
|
param->setMeasureName("colorChannel");
|
|
break;
|
|
default:
|
|
printf("invalid param unit");
|
|
return TOONZ_ERROR_INVALID_VALUE;
|
|
}
|
|
|
|
return TOONZ_OK;
|
|
}
|
|
|
|
int get_value_type(toonz_param_handle_t param, int *pvalue_type) {
|
|
if (!pvalue_type) {
|
|
return TOONZ_ERROR_NULL;
|
|
}
|
|
|
|
if (Param *_ = reinterpret_cast<Param *>(param)) {
|
|
TParamP param = _->param();
|
|
|
|
if (TDoubleParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;
|
|
} else if (TRangeParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;
|
|
} else if (TPixelParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;
|
|
} else if (TPointParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;
|
|
} else if (TIntEnumParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_INT;
|
|
} else if (TIntParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_INT;
|
|
} else if (TBoolParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_INT;
|
|
} else if (TSpectrumParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;
|
|
} else if (TStringParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_CHAR;
|
|
} else if (TToneCurveParamP p = param) {
|
|
*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;
|
|
} else {
|
|
return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
} else {
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
return TOONZ_OK;
|
|
}
|
|
|
|
int get_type(toonz_param_handle_t param, double frame, int *ptype,
|
|
int *pcount) {
|
|
/* size はほとんどの型で自明なので返さなくてもいいよね? */
|
|
if (!ptype || !pcount) return TOONZ_ERROR_NULL;
|
|
|
|
if (Param *p = reinterpret_cast<Param *>(param)) {
|
|
toonz_param_type_enum e = toonz_param_type_enum(p->desc()->traits_tag);
|
|
if (e >= TOONZ_PARAM_TYPE_NB) return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
size_t v;
|
|
if (parameter_type_check(p->param().getPointer(), p->desc(), v)) {
|
|
*ptype = p->desc()->traits_tag;
|
|
if (e == TOONZ_PARAM_TYPE_STRING) {
|
|
TStringParam *r =
|
|
reinterpret_cast<TStringParam *>(p->param().getPointer());
|
|
const std::string str =
|
|
QString::fromStdWString(r->getValue()).toStdString();
|
|
*pcount = str.length() + 1;
|
|
} else if (e == TOONZ_PARAM_TYPE_TONECURVE) {
|
|
TToneCurveParam *r =
|
|
reinterpret_cast<TToneCurveParam *>(p->param().getPointer());
|
|
auto lst = r->getValue(frame);
|
|
*pcount = lst.size();
|
|
} else {
|
|
*pcount = 1; // static_cast< int >(v);
|
|
}
|
|
return TOONZ_OK;
|
|
} else
|
|
return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
int get_value(toonz_param_handle_t param, double frame, int *psize_in_bytes,
|
|
void *pvalue) {
|
|
if (!psize_in_bytes) {
|
|
return TOONZ_ERROR_NULL;
|
|
}
|
|
|
|
if (!pvalue) {
|
|
int type = 0;
|
|
return get_type(param, frame, &type, psize_in_bytes);
|
|
}
|
|
|
|
if (Param *p = reinterpret_cast<Param *>(param)) {
|
|
toonz_param_type_enum e = toonz_param_type_enum(p->desc()->traits_tag);
|
|
if (e >= TOONZ_PARAM_TYPE_NB) return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
size_t v;
|
|
int icounts = *psize_in_bytes;
|
|
if (parameter_read_value(p->param().getPointer(), p->desc(), pvalue, frame,
|
|
icounts, v)) {
|
|
*psize_in_bytes = v;
|
|
return TOONZ_OK;
|
|
} else
|
|
return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
int get_string_value(toonz_param_handle_t param, int *wholesize, int rcvbufsize,
|
|
char *pvalue) {
|
|
if (!pvalue) return TOONZ_ERROR_NULL;
|
|
if (Param *p = reinterpret_cast<Param *>(param)) {
|
|
const toonz_param_desc_t *desc = p->desc();
|
|
toonz_param_type_enum e = toonz_param_type_enum(desc->traits_tag);
|
|
size_t vsz;
|
|
TParam *pp = p->param().getPointer();
|
|
if (param_type_check_<tpbind_str_t>(pp, desc, vsz)) {
|
|
size_t isize = rcvbufsize;
|
|
size_t osize = 0;
|
|
if (param_read_value_<tpbind_str_t>(pp, desc, pvalue, 0, isize, osize)) {
|
|
if (wholesize) *wholesize = static_cast<int>(osize);
|
|
return TOONZ_OK;
|
|
}
|
|
}
|
|
}
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
int get_spectrum_value(toonz_param_handle_t param, double frame, double x,
|
|
toonz_param_spectrum_t *pvalue) {
|
|
if (!pvalue) return TOONZ_ERROR_NULL;
|
|
if (Param *p = reinterpret_cast<Param *>(param)) {
|
|
const toonz_param_desc_t *desc = p->desc();
|
|
toonz_param_type_enum e = toonz_param_type_enum(desc->traits_tag);
|
|
size_t vsz;
|
|
TParam *pp = p->param().getPointer();
|
|
if (param_type_check_<tpbind_spc_t>(pp, desc, vsz)) {
|
|
size_t isize = 1;
|
|
size_t osize = 0;
|
|
pvalue->w = x;
|
|
if (param_read_value_<tpbind_spc_t>(pp, desc, pvalue, frame, isize,
|
|
osize)) {
|
|
return TOONZ_OK;
|
|
}
|
|
}
|
|
}
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
int set_value(toonz_param_handle_t param, double frame, int size_in_bytes,
|
|
const void *pvalue) {
|
|
if (Param *_ = reinterpret_cast<Param *>(param)) {
|
|
TParamP param = _->param();
|
|
|
|
if (TDoubleParamP p = param) {
|
|
if (size_in_bytes != sizeof(double)) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
p->setValue(frame, *reinterpret_cast<const double *>(pvalue));
|
|
} else if (TRangeParamP p = param) {
|
|
if (size_in_bytes != sizeof(double) * 2) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const double *const pvalues = reinterpret_cast<const double *>(pvalue);
|
|
p->setValue(frame, std::make_pair(pvalues[0], pvalues[1]));
|
|
} else if (TPixelParamP p = param) {
|
|
if (size_in_bytes != sizeof(double) * 4) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const double *const pvalues = reinterpret_cast<const double *>(pvalue);
|
|
p->setValueD(frame,
|
|
TPixelD(pvalues[0], pvalues[1], pvalues[2], pvalues[3]));
|
|
} else if (TPointParamP p = param) {
|
|
if (size_in_bytes != sizeof(double) * 2) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const double *const pvalues = reinterpret_cast<const double *>(pvalue);
|
|
p->setValue(frame, TPointD(pvalues[0], pvalues[1]));
|
|
} else if (TIntEnumParamP p = param) {
|
|
if (size_in_bytes != sizeof(int)) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
p->setValue(*reinterpret_cast<const int *>(pvalue));
|
|
} else if (TIntParamP p = param) {
|
|
if (size_in_bytes != sizeof(int)) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
p->setValue(*reinterpret_cast<const int *>(pvalue));
|
|
} else if (TBoolParamP p = param) {
|
|
if (size_in_bytes != sizeof(int)) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
p->setValue(*reinterpret_cast<const int *>(pvalue) != 0);
|
|
} else if (TSpectrumParamP p = param) {
|
|
const double *values = reinterpret_cast<const double *>(pvalue);
|
|
const int count = size_in_bytes / (sizeof(double) * 5);
|
|
std::vector<TSpectrum::ColorKey> keys(count);
|
|
for (int i = 0; i < count; i++) {
|
|
keys[i].first = values[5 * i + 0];
|
|
keys[i].second =
|
|
toPixel32(TPixelD(values[5 * i + 1], values[5 * i + 2],
|
|
values[5 * i + 3], values[5 * i + 4]));
|
|
}
|
|
p->setValue(frame, TSpectrum(count, keys.data()));
|
|
} else if (TStringParamP p = param) {
|
|
if (size_in_bytes < 1) {
|
|
return TOONZ_ERROR_INVALID_SIZE;
|
|
}
|
|
const char *values = reinterpret_cast<const char *>(pvalue);
|
|
p->setValue(QString::fromStdString(values).toStdWString());
|
|
} else if (TToneCurveParamP p = param) {
|
|
const double *values = reinterpret_cast<const double *>(pvalue);
|
|
const int count = size_in_bytes / (sizeof(double) * 2);
|
|
QList<TPointD> list;
|
|
for (int i = 0; i < count; ++i) {
|
|
list.push_back(TPointD(values[2 * i + 0], values[2 * i + 1]));
|
|
}
|
|
p->setValue(frame, list);
|
|
} else {
|
|
return TOONZ_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
} else {
|
|
return TOONZ_ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
return TOONZ_OK;
|
|
}
|