tABC_CC ABC_LoginServerOtpStatus(const Lobby &lobby, tABC_U08Buf LP1,
bool *on, long *timeout, tABC_Error *pError)
{
tABC_CC cc = ABC_CC_Ok;
json_t *pJSON_Value = NULL;
JsonPtr reply;
std::string url = ABC_SERVER_ROOT "/otp/status";
ABC_CHECK_RET(ABC_LoginServerOtpRequest(url.c_str(), lobby, LP1, &reply, pError));
pJSON_Value = json_object_get(reply.get(), ABC_SERVER_JSON_OTP_ON);
ABC_CHECK_ASSERT((pJSON_Value && json_is_boolean(pJSON_Value)), ABC_CC_JSONError, "Error otp/on JSON");
*on = json_is_true(pJSON_Value);
if (*on)
{
pJSON_Value = json_object_get(reply.get(), ABC_SERVER_JSON_OTP_TIMEOUT);
ABC_CHECK_ASSERT((pJSON_Value && json_is_integer(pJSON_Value)), ABC_CC_JSONError, "Error otp/timeout JSON");
*timeout = json_integer_value(pJSON_Value);
}
exit:
return cc;
}
std::shared_ptr<Texture> Scene::fetchTexture(JsonPtr value, TexelConversion conversion) const
{
// Note: TexelConversions are only honored by BitmapTexture.
// This is inconsistent, but conversions do not really make sense for other textures,
// unless the user expects e.g. a ConstantTexture with Vec3 argument to select the green
// channel when used in a TransparencyBsdf.
if (value.isString()) {
return _textureCache->fetchTexture(fetchResource(value), conversion);
} else if (value.isNumber()) {
return std::make_shared<ConstantTexture>(value.cast<float>());
} else if (value.isArray()) {
return std::make_shared<ConstantTexture>(value.cast<Vec3f>());
} else if (value.isObject()) {
std::string type = value.castField<std::string>("type");
if (type == "bitmap")
return _textureCache->fetchTexture(value, conversion, this);
else if (type == "ies")
return _textureCache->fetchIesTexture(value, this);
else
return instantiate<Texture>(value, *this);
} else {
value.parseError("Type mismatch: Expecting a texture here");
}
return nullptr;
}
void fromJson(JsonPtr v)
{
TraceSettings::fromJson(v);
v.getField("initial_sample_pool", initialSamplePool);
v.getField("image_pyramid", imagePyramid);
v.getField("large_step_probability", largeStepProbability);
}
void ConductorBsdf::fromJson(JsonPtr value, const Scene &scene)
{
Bsdf::fromJson(value, scene);
if (value.getField("eta", _eta) && value.getField("k", _k))
_materialName.clear();
if (value.getField("material", _materialName) && !lookupMaterial())
value.parseError(tfm::format("Unable to find material with name '%s'", _materialName));
}
void ThinSheetBsdf::fromJson(JsonPtr value, const Scene &scene)
{
Bsdf::fromJson(value, scene);
value.getField("ior", _ior);
value.getField("enable_interference", _enableInterference);
value.getField("sigma_a", _sigmaA);
if (auto thickness = value["thickness"])
_thickness = scene.fetchTexture(thickness, TexelConversion::REQUEST_AVERAGE);
}
void RoughPlasticBsdf::fromJson(JsonPtr value, const Scene &scene)
{
Bsdf::fromJson(value, scene);
value.getField("ior", _ior);
_distribution = value["distribution"];
value.getField("thickness", _thickness);
value.getField("sigma_a", _sigmaA);
if (auto roughness = value["roughness"])
_roughness = scene.fetchTexture(roughness, TexelConversion::REQUEST_AVERAGE);
}
std::shared_ptr<T> fetchObject(const std::vector<std::shared_ptr<T>> &list, const Scene &scene, JsonPtr value)
{
if (value.isString()) {
return findObject(list, value.cast<std::string>(), value);
} else if (value.isObject()) {
return instantiate<T>(value, scene);
} else {
value.parseError("Type mismatch: Expecting either an object or an object reference here");
return nullptr;
}
}
void MixedBsdf::fromJson(JsonPtr value, const Scene &scene)
{
Bsdf::fromJson(value, scene);
_bsdf0 = scene.fetchBsdf(value.getRequiredMember("bsdf0"));
_bsdf1 = scene.fetchBsdf(value.getRequiredMember("bsdf1"));
if (_bsdf0.get() == this || _bsdf1.get() == this)
value.parseError("Recursive mixed BSDF not supported");
if (auto ratio = value["ratio"])
_ratio = scene.fetchTexture(ratio, TexelConversion::REQUEST_AVERAGE);
}
ModelRef(JsonPtr value, ModelResolver &resolver)
: _xRot(0),
_yRot(0),
_zRot(0),
_uvLock(false),
_weight(1.0f)
{
value.getField("model", _modelPath);
value.getField("x", _xRot);
value.getField("y", _yRot);
value.getField("z", _zRot);
value.getField("uvlock", _uvLock);
value.getField("weight", _weight);
_builtModel = resolver.resolveModel("block/" + _modelPath);
}
void Camera::fromJson(JsonPtr value, const Scene &scene)
{
_tonemapOp = value["tonemap"];
value.getField("resolution", _res);
if (auto medium = value["medium"])
_medium = scene.fetchMedium(medium);
if (auto filter = value["reconstruction_filter"])
_filter = filter;
if (auto transform = value["transform"]) {
transform.get(_transform);
_pos = _transform.extractTranslationVec();
_lookAt = _transform.fwd() + _pos;
_up = _transform.up();
transform.getField("up", _up);
transform.getField("look_at", _lookAt);
_transform.setRight(-_transform.right());
}
precompute();
}
std::shared_ptr<T> findObject(const std::vector<std::shared_ptr<T>> &list, const std::string &name, JsonPtr value)
{
for (const std::shared_ptr<T> &t : list)
if (t->name() == name)
return t;
value.parseError(tfm::format("Unable to find an object with name '%s'", name));
return nullptr;
}
void Primitive::fromJson(JsonPtr value, const Scene &scene)
{
JsonSerializable::fromJson(value, scene);
value.getField("transform", _transform);
if (auto emission = value["emission"]) _emission = scene.fetchTexture(emission, TexelConversion::REQUEST_RGB);
if (auto power = value["power" ]) _power = scene.fetchTexture(power, TexelConversion::REQUEST_RGB);
if (auto intMedium = value["int_medium"]) _intMedium = scene.fetchMedium(intMedium);
if (auto extMedium = value["ext_medium"]) _extMedium = scene.fetchMedium(extMedium);
}
Status
loginServerUploadLogs(const Account *account)
{
const auto url = ABC_SERVER_ROOT "/account/debug";
JsonPtr json;
HttpReply reply;
DataChunk logData = debugLogLoad();
if (account)
{
JsonArray jsonArray;
auto ids = account->wallets.list();
for (const auto &id: ids)
{
std::shared_ptr<Wallet> wallet;
if (cacheWallet(wallet, nullptr, id.c_str()))
{
DataChunk watchData;
ABC_CHECK(fileLoad(watchData, watcherPath(*wallet)));
jsonArray.append(
json_string(base64Encode(watchData).c_str()));
}
}
json.reset(json_pack("{ss, ss, ss}",
ABC_SERVER_JSON_L1_FIELD, base64Encode(account->login.lobby.authId()).c_str(),
ABC_SERVER_JSON_LP1_FIELD, base64Encode(account->login.authKey()).c_str(),
"log", base64Encode(logData).c_str()));
if (jsonArray)
json_object_set(json.get(), "watchers", jsonArray.get());
}
else
{
json.reset(json_pack("{ss}", "log", base64Encode(logData).c_str()));
}
ABC_CHECK(AirbitzRequest().post(reply, url, json.encode()));
return Status();
}
void fromJson(JsonPtr v)
{
TraceSettings::fromJson(v);
v.getField("initial_sample_pool", initialSamplePool);
v.getField("iterations_per_batch", iterationsPerBatch);
v.getField("image_pyramid", imagePyramid);
v.getField("large_step_probability", largeStepProbability);
v.getField("strategy_perturbation_probability", strategyPerturbationProbability);
v.getField("gaussian_mutation", gaussianMutation);
}
std::shared_ptr<T> instantiate(JsonPtr value, const Scene &scene)
{
auto result = StringableEnum<std::function<std::shared_ptr<T>()>>(value.getRequiredMember("type")).toEnum()();
result->fromJson(value, scene);
return result;
}
void ErlangTransmittance::fromJson(JsonPtr value, const Scene &scene)
{
Transmittance::fromJson(value, scene);
value.getField("rate", _lambda);
}
