rapidjson::Value SceneConvertor::_GameObject_to_JSON( const GameObject* gameObject,	rapidjson::Document::AllocatorType& al )
{
	Value json;
	json.SetObject();

	Value stringNode;
	stringNode.SetString( gameObject->GetName().ToChar(),														al );
	
	json.AddMember( "name",			stringNode,																	al );
	json.AddMember( "enabled",		gameObject->IsEnabled(),													al );

	if (_useAll)
	{
		json.AddMember( "savable",	gameObject->IsSavable(),													al );
	}

	Value objectNode;
	objectNode.SetObject();

	for (uint i = 0; i < gameObject->GetComponentCount(); ++i)
	{
		I_Component* comp = gameObject->GetComponentAt(i);

		if ( comp->WhatIs() == E_Component::Transform )
			objectNode.AddMember( "Transform",	_Transform_to_JSON( static_cast<Transform*>( comp ), al ),		al );
	
		if ( comp->WhatIs() == E_Component::MeshDrawing )
			objectNode.AddMember( "MeshDrawing", _MeshDrawing_to_JSON( static_cast<MeshDrawing*>( comp ), al ),	al );
		
		if ( comp->WhatIs() == E_Component::Camera )
			objectNode.AddMember( "Camera",		_Camera_to_JSON( static_cast<Camera*>( comp ), al ),			al );

		if ( comp->WhatIs() == E_Component::Light )
			objectNode.AddMember( "Light",		_Light_to_JSON( static_cast<Light*>( comp ), al ),				al );

		if ( comp->WhatIs() == E_Component::Script )
			objectNode.AddMember( "Script",		_Script_to_JSON( static_cast<Script*>( comp ), al ),			al );
	}
	json.AddMember( "components",	objectNode,																	al );


	Value arrayNode;
	arrayNode.SetArray();
	for (uint i = 0; i < gameObject->GetChildNodeCount(); ++i)
	{
		GameObject* child = gameObject->GetChildNodeAt(i);
		if ( _useAll || child->IsSavable() )
		{
			arrayNode.PushBack( _GameObject_to_JSON(child, al),													al );
		}
	}
	json.AddMember( "childNodes",	arrayNode,																	al );


	return json;
}
rapidjson::Value SceneConvertor::_Transform_to_JSON( const Transform* transform, rapidjson::Document::AllocatorType& al )
{
	Value json;
	json.SetObject();

	json.AddMember( "positionWorld", _Vec3_to_JSON(transform->GetPositionWorld(), al),			al);
	json.AddMember( "rotationWorld", _Vec3_to_JSON(transform->GetEulerRotationWorld(), al),		al);
	json.AddMember( "scaleWorld",	 _Vec3_to_JSON(transform->GetScaleWorld(), al),				al);

	return json;
}
rapidjson::Value SceneConvertor::_Vec3_to_JSON( const Vector3& value, rapidjson::Document::AllocatorType& al )
{
	Value json;
	json.SetObject();

	json.AddMember( "x", value.x(), al );
	json.AddMember( "y", value.y(), al );
	json.AddMember( "z", value.z(), al );

	return json;
}
Пример #4
0
void SG2VGJSON::addPath(const string& name, const vector<SGSegment>& path,
                        int rank)
{
  Value jpath;
  jpath.SetObject();
  addString(jpath, "name", name);
  Value mappings;
  mappings.SetArray();
  int inputPathLength = 0;
  int outputPathLength = 0;
  for (int i = 0; i < path.size(); ++i)
  {
    sg_int_t sgSeqID = path[i].getSide().getBase().getSeqID();
    
    if (path[i].getLength() != _sg->getSequence(sgSeqID)->getLength())
    {
      stringstream ss;
      ss << "Sanity check fail for Mapping " << i << " of path " << name
         << ": Segment size " << path[i].getLength() << " does not span "
         << "all of node " << (sgSeqID + 1) << " which has length "
         << _sg->getSequence(sgSeqID)->getLength();
      throw runtime_error(ss.str());
    }
    inputPathLength += path[i].getLength();
    
    Value position;
    position.SetObject();
    // node id's are 1-based in VG!
    addInt(position, "node_id", sgSeqID + 1);
    // Offsets are along the strand of the node that is being visited.
    // We always use the whole node.
    addInt(position, "offset", 0);
    
    addBool(position, "is_reverse", !path[i].getSide().getForward());
    
    outputPathLength += _sg->getSequence(sgSeqID)->getLength();    
    Value mapping;
    mapping.SetObject();
    mapping.AddMember("position", position, allocator());
    addInt(mapping, "rank", rank + i + 1);
    mappings.PushBack(mapping, allocator());
  }
  if (inputPathLength != outputPathLength)
  {
    stringstream ss;
    ss << "Sanity check fail for path " << name << ": input length ("
       << inputPathLength << ") != output length (" << outputPathLength << ")";
    throw runtime_error(ss.str());
  }
  jpath.AddMember("mapping", mappings, allocator());
  paths().PushBack(jpath, allocator());
}
rapidjson::Value SceneConvertor::_Script_to_JSON( const Script* script,	rapidjson::Document::AllocatorType& al )
{
	Value json;
	json.SetObject();

	Value stringNode;
	stringNode.SetString( script->GetName().ToChar(),				al );
	
	json.AddMember( "name",				stringNode,					al );
	json.AddMember( "enabled",			script->IsEnabled(),		al );

	return json;
}
Пример #6
0
 void accept_binary_message(binary_message const& msg,Value& val,Document& doc,vector<shared_ptr<const string> >& buffers)
 {
     val.SetObject();
     Value boolVal;
     boolVal.SetBool(true);
     val.AddMember(kBIN_PLACE_HOLDER, boolVal, doc.GetAllocator());
     Value numVal;
     numVal.SetInt((int)buffers.size());
     val.AddMember("num", numVal, doc.GetAllocator());
     //FIXME can not avoid binary copy here.
     shared_ptr<string> write_buffer = make_shared<string>();
     write_buffer->reserve(msg.get_binary()->size()+1);
     char frame_char = packet::frame_message;
     write_buffer->append(&frame_char,1);
     write_buffer->append(*(msg.get_binary()));
     buffers.push_back(write_buffer);
 }
Пример #7
0
void SG2VGJSON::addString(Value& value, const string& name, const string& v)
{
  Value stringValue;
  stringValue.SetString(v.c_str(), v.length(), allocator());
  Value nameValue;
  nameValue.SetString(name.c_str(), name.length(), allocator());
  value.AddMember(nameValue, stringValue, allocator());
}
Пример #8
0
void SG2VGJSON::addInt(Value& value, const string& name, int v)
{
  Value intValue;
  intValue.SetInt(v);
  Value nameValue;
  nameValue.SetString(name.c_str(), name.length(), allocator());
  value.AddMember(nameValue, intValue, allocator());
}
Пример #9
0
void SG2VGJSON::addBool(Value& value, const string& name, bool v)
{
  Value boolValue;
  boolValue.SetBool(v);
  Value nameValue;
  nameValue.SetString(name.c_str(), name.length(), allocator());
  value.AddMember(nameValue, boolValue, allocator());
}
Пример #10
0
Value addControl(Document& root, const char* type, int x, int y, int w, int h, int id){
    Document::AllocatorType& a = root.GetAllocator();
    
    Value ctl;
    ctl.SetObject();
    ctl.AddMember("type", StringRef(type), a);
    ctl.AddMember("id", id, a);
    
    Value frame;
    frame.SetObject();
    frame.AddMember("x", x, a);
    frame.AddMember("y", y, a);
    frame.AddMember("w", w, a);
    frame.AddMember("h", h, a);
    ctl.AddMember("frame", frame, a);
    
    return ctl;
}
Пример #11
0
bool ZatData::WriteDataJson()
{
  void* file;
  if (!(file = XBMC->OpenFileForWrite(data_file.c_str(), true)))
  {
    XBMC->Log(LOG_ERROR, "Save data.json failed.");
    return false;
  }

  Document d;
  d.SetObject();

  Value a(kArrayType);
  Document::AllocatorType& allocator = d.GetAllocator();
  for (auto const& item : recordingsData)
  {
    if (!item.second->stillValid)
    {
      continue;
    }

    Value r;
    r.SetObject();
    Value recordingId;
    recordingId.SetString(item.second->recordingId.c_str(),
        item.second->recordingId.length(), allocator);
    r.AddMember("recordingId", recordingId, allocator);
    r.AddMember("playCount", item.second->playCount, allocator);
    r.AddMember("lastPlayedPosition", item.second->lastPlayedPosition,
        allocator);
    a.PushBack(r, allocator);
  }
  d.AddMember("recordings", a, allocator);

  StringBuffer buffer;
  Writer<StringBuffer> writer(buffer);
  d.Accept(writer);
  const char* output = buffer.GetString();
  XBMC->WriteFile(file, output, strlen(output));
  XBMC->CloseFile(file);
  return true;
}
Пример #12
0
 void accept_object_message(object_message const& msg,Value& val,Document& doc,vector<shared_ptr<const string> >& buffers)
 {
     val.SetObject();
     for (map<string,message::ptr>::const_iterator it = msg.get_map().begin(); it!= msg.get_map().end(); ++it) {
         Value nameVal;
         nameVal.SetString(it->first.data(), (SizeType)it->first.length(), doc.GetAllocator());
         Value valueVal;
         accept_message(*(it->second), valueVal, doc,buffers);
         val.AddMember(nameVal, valueVal, doc.GetAllocator());
     }
 }
rapidjson::Value SceneConvertor::_Camera_to_JSON( const Camera* camera, rapidjson::Document::AllocatorType& al )
{
	Value json;
	json.SetObject();

	json.AddMember( "enabled",		camera->IsEnabled(),								al );

	Value stringNode;
	stringNode.SetString( EnumConvertor::e2s_CameraType[ camera->GetType() ].ToChar(),		al );
	
	json.AddMember( "type",			stringNode,											al );
	json.AddMember( "fovYAngle",	camera->GetFovYAngle(),								al );
	json.AddMember( "nearClipping",	camera->GetNearClipping(),							al );
	json.AddMember( "farClipping",	camera->GetFarClipping(),							al );
	json.AddMember( "aspectRatio",	camera->GetAspectRatio(),							al );
	json.AddMember( "orthoSize",	_Vec2_to_JSON(camera->GetOrthoSize(), al),			al );

	//jsonAux.SetArray();	
	//for (uint i = 0; i < camera->GetImageEffectsCount(); ++i)
	//{
	//	jsonAux.PushBack( _ImageEffectToJSON( camera->GetImageEffectAt(i) ), al );
	//}
	//json.AddMember("imageEffects", jsonAux, allocator);

	return json;
}
rapidjson::Value SceneConvertor::_Light_to_JSON( const Light* light, rapidjson::Document::AllocatorType& al )
{
	Value json;
	json.SetObject();

	json.AddMember( "enabled",			light->IsEnabled(),								al );

	Value stringNode;
	stringNode.SetString( EnumConvertor::e2s_LightType[ light->GetType() ].ToChar(),		al );
	
	json.AddMember( "type",				stringNode,										al );
	json.AddMember( "color",			_Vec3_to_JSON(light->GetColor(), al),			al );
	json.AddMember( "intensity",		light->GetIntensity(),							al );
	json.AddMember( "range",			light->GetRange(),								al );
	json.AddMember( "spotAngle",		light->GetSpotAngle(),							al );
	json.AddMember( "castShadows",		light->IsCastingShadows(),						al );

	return json;
}
Пример #15
0
/**
 * Specialisation of Options::SetImpl to store strings.
 * This specialisation is necessary because the value must be copied.
 * rapidjson requires that (a.) it explicitly be copied, or that (b.) it will
 * retain a reference that is guaranteed to be valid for longer than itself.
 * @param key The key to the value.
 * @param val The value to be stored.
 */
void Options::Set(const char *key, const char *val) {
    Document *d = static_cast<Document*>(m_doc);
    Value *fi = static_cast<Value*>(m_family_inst);

    if (!fi) { //Family doesn't exist, so create it
        Value family_key(m_family.c_str(), d->GetAllocator());
        Value family_val(Type::kObjectType);
        Value entry_key(key, d->GetAllocator());
        Value entry_val(val, d->GetAllocator());

        family_val.AddMember(entry_key, entry_val, d->GetAllocator());
        d->AddMember(family_key, family_val, d->GetAllocator());
        m_family_inst = &(*d)[m_family.c_str()];
    } else { //We have the family
        Value *existing = LGetValue(fi, key);
        if (existing) { //The entry was already there, so just update value
            existing->SetString(val, d->GetAllocator());
        } else { //Create the new entry
            Value entry_key(key, d->GetAllocator());
            Value entry_val(val, d->GetAllocator());
            fi->AddMember(entry_key, entry_val, d->GetAllocator());
        }
    }
}
rapidjson::Value SceneConvertor::_MeshDrawing_to_JSON( const MeshDrawing* meshDrawing, rapidjson::Document::AllocatorType& al )
{
	Value json;
	json.SetObject();

	json.AddMember( "enabled",			meshDrawing->IsEnabled(),					al );
	json.AddMember( "castShadows",		meshDrawing->IsCastingShadows(),			al );
	json.AddMember( "receiveShadows",	meshDrawing->IsReceivingShadows(),			al );

	Value nullNode;
	nullNode.SetNull();

	Value stringNode;

	if (meshDrawing->GetMesh() != NULL)
	{
		stringNode.SetString( meshDrawing->GetMesh()->GetName().ToChar(),			al );
		json.AddMember( "mesh",			stringNode,									al );
	}
	else
	{
		json.AddMember( "mesh",			nullNode,									al );
	}

	if (meshDrawing->GetMaterial() != NULL)
	{
		stringNode.SetString( meshDrawing->GetMaterial()->GetName().ToChar(),		al );
		json.AddMember( "material",		stringNode,									al );
	}
	else
	{
		json.AddMember( "material",		nullNode,									al );
	}

	return json;
}
rapidjson::Document	SettingsConvertor::Convert()
{
    using namespace rapidjson;

    Document json;
    json.SetObject();
    Document::AllocatorType& al = json.GetAllocator();

#if (ME3D_BUILD == ME3D_BUILD_EDITOR)
    json.AddMember( "FILE_TYPE",		"EDITOR_CONFIG",					al );

    json.AddMember( "editorWidth",		EditorApp::Settings::width,			al );
    json.AddMember( "editorHeight",		EditorApp::Settings::height,		al );
    json.AddMember( "editorPosX",		EditorApp::Settings::posX,			al );
    json.AddMember( "editorPosY",		EditorApp::Settings::posY,			al );

    Value objectNode;
    Value stringNode;

    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Hierarchy ];

        objectNode.AddMember( "visible",		wProp.visible,				al );

        json.AddMember( "window_hierarchy",		objectNode,					al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Resources ];

        objectNode.AddMember( "visible",		wProp.visible,				al );

        json.AddMember( "window_resources",		objectNode,					al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Console ];

        objectNode.AddMember( "visible",		wProp.visible,				al );

        json.AddMember( "window_console",		objectNode,					al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Properties ];

        objectNode.AddMember( "visible",		wProp.visible,				al );

        json.AddMember( "window_properties",	objectNode,					al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Game ];

        objectNode.AddMember( "visible",	wProp.visible,					al );

        json.AddMember( "window_game",		objectNode,						al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Scene_1 ];

        objectNode.AddMember( "visible",		wProp.visible,				al );
        stringNode.SetString( wProp.renderer.ToChar(),						al );
        objectNode.AddMember( "renderer",		stringNode,					al );
        objectNode.AddMember( "camera",			wProp.camera,				al );

        json.AddMember( "window_scene_1",		objectNode,					al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Scene_2 ];

        objectNode.AddMember( "visible",		wProp.visible,				al );
        stringNode.SetString( wProp.renderer.ToChar(),						al );
        objectNode.AddMember( "renderer",		stringNode,					al );
        objectNode.AddMember( "camera",			wProp.camera,				al );

        json.AddMember( "window_scene_2",		objectNode,					al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Scene_3 ];

        objectNode.AddMember( "visible",		wProp.visible,				al );
        stringNode.SetString( wProp.renderer.ToChar(),						al );
        objectNode.AddMember( "renderer",		stringNode,					al );
        objectNode.AddMember( "camera",			wProp.camera,				al );

        json.AddMember( "window_scene_3",		objectNode,					al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Scene_4 ];

        objectNode.AddMember( "visible",		wProp.visible,				al );
        stringNode.SetString( wProp.renderer.ToChar(),						al );
        objectNode.AddMember( "renderer",		stringNode,					al );
        objectNode.AddMember( "camera",			wProp.camera,				al );

        json.AddMember( "window_scene_4",		objectNode,					al );
    }
    {
        objectNode.SetObject();
        EditorApp::WindowProperty wProp = EditorApp::Settings::windows[ Windows::Preview ];

        objectNode.AddMember( "visible",		wProp.visible,				al );

        json.AddMember( "window_preview",		objectNode,					al );
    }


    stringNode.SetString( EditorApp::Settings::startScene.ToChar(),			al );
    json.AddMember( "startScene",			stringNode,						al );
#endif

    return json;
}
Пример #18
0
int main()
{
    // Start the logger up first so all other code can be logged
    InitializeLogger();

    // Log the time for the executing the function
    log_time(INFO);

    Value value;
    Document doc;

    // Create map with various values of different types
    value["integer"] = 32;
    value["string"] = "test string\nsecond line";
    value["double"] = 5.532e-5;
    value["dateTime"].SetDateTime(time(NULL));

    Value binary;
    char* binData = (char*)"\x0a\x0b\x0c\x0d\xff\x00\xee\xdd";
    binary.SetBinary( (unsigned char*)binData, 8);
    value.AddMember( "binary", binary );

    Value array;
    array.SetSize(4);
    array[0] = 5;
    array[1] = 10;
    array[2] = 15;
    array[3] = 20;
    value["array"] = array;

    // Write data to stdout
    cout << "Json data to stdout: " << endl;
    JsonWriter jsonWriter(stdoutStream);
    jsonWriter << value;
    cout << endl;

    // Write data to a string
    WriteStringStream strStream;
    JsonWriter jsonStrWriter(strStream);
    jsonStrWriter << value;

    const char *json = strStream.GetBuffer();
    int jsonLength = strStream.Length();
    cout << "Json data in string:" << endl << json << endl;

    // Use string data and parse in place.
    // This will modify the string and reference value strings directly from the input string.
    InSituStringStream sstream((char*)json, jsonLength);
    JsonReader jsonreader(sstream);
    jsonreader >> doc;
    if (jsonreader.HasParseError())
    {
        cout << "Parse Error: " << jsonreader.GetParseErrorStr();
        cout << "; at position " << jsonreader.GetErrorOffset() << endl;
    }
    else
    {
        // Display value using internal converter - close to Json format but not exact
        cout << "Value traversal after reading: " << endl;
        cout << doc.GetValue() << endl;
    }

    return 0;
}