void AnimationNode::blend_animation(const StringName &p_animation, float p_time, float p_delta, bool p_seeked, float p_blend) {
ERR_FAIL_COND(!state);
ERR_FAIL_COND(!state->player->has_animation(p_animation));
Ref<Animation> animation = state->player->get_animation(p_animation);
if (animation.is_null()) {
AnimationNodeBlendTree *btree = Object::cast_to<AnimationNodeBlendTree>(parent);
if (btree) {
String name = btree->get_node_name(Ref<AnimationNodeAnimation>(this));
make_invalid(vformat(RTR("In node '%s', invalid animation: '%s'."), name, p_animation));
} else {
make_invalid(vformat(RTR("Invalid animation: '%s'."), p_animation));
}
return;
}
ERR_FAIL_COND(!animation.is_valid());
AnimationState anim_state;
anim_state.blend = p_blend;
anim_state.track_blends = &blends;
anim_state.delta = p_delta;
anim_state.time = p_time;
anim_state.animation = animation;
anim_state.seeked = p_seeked;
state->animation_states.push_back(anim_state);
}
void CreateDialog::set_base_type(const String &p_base) {
base_type = p_base;
if (is_replace_mode)
set_title(vformat(TTR("Change %s Type"), p_base));
else
set_title(vformat(TTR("Create New %s"), p_base));
_update_search();
}
void DependencyEditor::edit(const String &p_path) {
editing = p_path;
set_title(TTR("Dependencies For:") + " " + p_path.get_file());
_update_list();
popup_centered_ratio();
if (EditorNode::get_singleton()->is_scene_open(p_path)) {
EditorNode::get_singleton()->show_warning(vformat(TTR("Scene '%s' is currently being edited.\nChanges will not take effect unless reloaded."), p_path.get_file()));
} else if (ResourceCache::has(p_path)) {
EditorNode::get_singleton()->show_warning(vformat(TTR("Resource '%s' is in use.\nChanges will take effect when reloaded."), p_path.get_file()));
}
}
std::string Debug::format(std::string fmt, ...) {
va_list vl;
va_start(vl, fmt);
std::string txt = vformat(fmt, vl);
va_end(vl);
return txt;
}
void LogManager::format(std::string& outString, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
vformat(outString, fmt, args);
va_end(args);
}
char *format(char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
char *r = vformat(fmt, ap);
va_end(ap);
return r;
}
/*
Break all connections of currently selected signal.
Can undo-redo as a single action.
*/
void ConnectionsDock::_disconnect_all() {
TreeItem *item = tree->get_selected();
if (!_is_item_signal(*item))
return;
TreeItem *child = item->get_children();
String signalName = item->get_metadata(0).operator Dictionary()["name"];
undo_redo->create_action(vformat(TTR("Disconnect all from signal: '%s'"), signalName));
while (child) {
Connection c = child->get_metadata(0);
undo_redo->add_do_method(selectedNode, "disconnect", c.signal, c.target, c.method);
undo_redo->add_undo_method(selectedNode, "connect", c.signal, c.target, c.method, c.binds, c.flags);
child = child->get_next();
}
undo_redo->add_do_method(this, "update_tree");
undo_redo->add_undo_method(this, "update_tree");
undo_redo->add_do_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
undo_redo->add_undo_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
undo_redo->commit_action();
}
//------------------------------------------------------------------------------
void
DebugText( uint color, const char* fmt, ... )
{
if ( !CDebugText::HasInst() )
{
return;
}
string strBuffer;
va_list args;
va_start(args, fmt);
//_vsnprintf( strBuffer, 512, fmt, args );
//strBuffer[511] = '\0';
vformat(strBuffer, fmt, args);
va_end(args);
while ( strBuffer.find('\n') != string::npos )
{
string szCurLine = strBuffer.substr(0, strBuffer.find('\n'));
strBuffer = strBuffer.substr(strBuffer.find('\n') + 1, strBuffer.size());
CDebugText::GetInst()->DrawDebugText(szCurLine, color);
}
if ( strBuffer.size() != 0 )
{
CDebugText::GetInst()->DrawDebugText(strBuffer, color);
}
}
void format(string &s, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vformat(s, fmt, ap);
va_end(ap);
}
void TextOutput::vprintf(const char* formatString, va_list argPtr) {
std::string str = vformat(formatString, argPtr);
std::string clean;
convertNewlines(str, clean);
wordWrapIndentAppend(clean);
}
static void pr_ret (const char *fn, unsigned line, const char *fmt, ...)
{
va_list args;
task_s *t;
if (!Tau_debug_func) return;
lock();
t = get_task();
indent(t->tk_depth);
putlog('a' + (t - Task_pool));
putlog(' ');
prfn(fn, line);
va_start(args, fmt);
vformat(fmt, args);
va_end(args);
log();
if (t->tk_depth) {
--t->tk_depth;
} else {
printk(PR_LEVEL "stack underflow at %s\n", fn);
}
unlock();
}
float AnimationNode::blend_input(int p_input, float p_time, bool p_seek, float p_blend, FilterAction p_filter, bool p_optimize) {
ERR_FAIL_INDEX_V(p_input, inputs.size(), 0);
ERR_FAIL_COND_V(!state, 0);
AnimationNodeBlendTree *blend_tree = Object::cast_to<AnimationNodeBlendTree>(parent);
ERR_FAIL_COND_V(!blend_tree, 0);
StringName node_name = connections[p_input];
if (!blend_tree->has_node(node_name)) {
String name = blend_tree->get_node_name(Ref<AnimationNode>(this));
make_invalid(vformat(RTR("Nothing connected to input '%s' of node '%s'."), get_input_name(p_input), name));
return 0;
}
Ref<AnimationNode> node = blend_tree->get_node(node_name);
//inputs.write[p_input].last_pass = state->last_pass;
float activity = 0;
float ret = _blend_node(node_name, blend_tree->get_node_connection_array(node_name), NULL, node, p_time, p_seek, p_blend, p_filter, p_optimize, &activity);
Vector<AnimationTree::Activity> *activity_ptr = state->tree->input_activity_map.getptr(base_path);
if (activity_ptr && p_input < activity_ptr->size()) {
activity_ptr->write[p_input].last_pass = state->last_pass;
activity_ptr->write[p_input].activity = activity;
}
return ret;
}
void BitSet::throwIndexOutOfRange(const TCHAR *method, size_t index, _In_z_ _Printf_format_string_ TCHAR const * const format, ...) const {
va_list argptr;
va_start(argptr, format);
const String msg = vformat(format, argptr);
va_end(argptr);
throwInvalidArgumentException(method, _T("%s:%s"), msg.cstr(), indexOutOfRangeString(index).cstr());
}
static void throwAssertionException(_In_z_ _Printf_format_string_ const TCHAR *format, ...) {
va_list argptr;
va_start(argptr, format);
const String msg = vformat(format,argptr);
va_end(argptr);
throwBigRealException(_T("assertIsValidBigReal:%s"), msg.cstr());
}
void MeshLibraryEditor::_menu_cbk(int p_option) {
option=p_option;
switch(p_option) {
case MENU_OPTION_ADD_ITEM: {
theme->create_item(theme->get_last_unused_item_id());
} break;
case MENU_OPTION_REMOVE_ITEM: {
String p = editor->get_property_editor()->get_selected_path();
if (p.begins_with("/MeshLibrary/item") && p.get_slice_count("/")>=3) {
to_erase = p.get_slice("/",3).to_int();
cd->set_text(vformat(TTR("Remove item %d?"),to_erase));
cd->popup_centered(Size2(300,60));
}
} break;
case MENU_OPTION_IMPORT_FROM_SCENE: {
file->popup_centered_ratio();
} break;
case MENU_OPTION_UPDATE_FROM_SCENE: {
cd->set_text("Update from existing scene?:\n"+String(theme->get_meta("_editor_source_scene")));
cd->popup_centered(Size2(500,60));
} break;
}
}
std::string Format(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
std::string buf = vformat(fmt, ap);
va_end(ap);
return buf;
}
String RenameDialog::_substitute(const String &subject, const Node *node, int count) {
String result = subject.replace("${COUNTER}", vformat("%0" + itos(spn_count_padding->get_value()) + "d", count));
if (node) {
result = result.replace("${NAME}", node->get_name());
result = result.replace("${TYPE}", node->get_class());
}
int current = EditorNode::get_singleton()->get_editor_data().get_edited_scene();
result = result.replace("${SCENE}", EditorNode::get_singleton()->get_editor_data().get_scene_title(current));
Node *root_node = SceneTree::get_singleton()->get_edited_scene_root();
if (root_node) {
result = result.replace("${ROOT}", root_node->get_name());
}
Node *parent_node = node->get_parent();
if (parent_node) {
if (node == root_node) {
// Can not substitute parent of root.
result = result.replace("${PARENT}", "");
} else {
result = result.replace("${PARENT}", parent_node->get_name());
}
}
return result;
}
static void format (const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vformat(fmt, args);
va_end(args);
}
std::string format(const char* fmt,...) {
va_list argList;
va_start(argList,fmt);
std::string result = vformat(fmt, argList);
va_end(argList);
return result;
}
std::string format(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
auto formatted_message = vformat(fmt, args);
va_end(args);
return formatted_message;
}
/// Equivalent to a sprintf on the string.
int ostringstream::format (const char* fmt, ...)
{
va_list args;
va_start (args, fmt);
const int rv = vformat (fmt, args);
va_end (args);
return (rv);
}
int queue_file::format(const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
int ret = vformat(fmt, ap);
va_end(ap);
return ret;
}
bool HttpServletResponse::format(const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
bool ret = vformat(fmt, ap);
va_end(ap);
return ret;
}
FMT_FUNC void system_error::init(
int err_code, string_view format_str, format_args args) {
error_code_ = err_code;
memory_buffer buffer;
format_system_error(buffer, err_code, vformat(format_str, args));
std::runtime_error &base = *this;
base = std::runtime_error(to_string(buffer));
}
bool smtp_client::format(const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
bool ret = vformat(fmt, ap);
va_end(ap);
return ret;
}
String String::format(int bufsize, const wchar_t *format, ...)
{
va_list ap;
va_start(ap, format);
String ret = vformat(bufsize, format, ap);
va_end(ap);
return ret;
}
CString
CStringUtil::format(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
CString result = vformat(fmt, args);
va_end(args);
return result;
}
Ascii
Ascii::format(const Chr8* sFormat, ...)
{
va_list args;
va_start(args, sFormat);
Ascii sRet = vformat(sFormat, args);
va_end(args);
return sRet;
}
void ProjectExportDialog::_delete_preset() {
Ref<EditorExportPreset> current = EditorExport::get_singleton()->get_export_preset(presets->get_current());
if (current.is_null())
return;
delete_confirm->set_text(vformat(TTR("Delete preset '%s'?"), current->get_name()));
delete_confirm->popup_centered_minsize();
}
void log(unsigned short l, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
string m;
vformat(m, fmt, ap);
log_string(l, m.c_str());
va_end(ap);
}
