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); }