/// <summary>
/// Writes time-tagged <see cref="NearFarScalar"/> values as an array in [Time, Clock, Cone, Magnitude] order.
/// Times are epoch seconds since an epoch that is determined from the first date to be written.
/// The epoch property is written as well.
/// </summary>
/// <param name="output">The stream to which to write the array.</param>
/// <param name="propertyName">The name of the property to write.</param>
/// <param name="dates">The dates at which the value is specified.</param>
/// <param name="values">The corresponding value for each date.</param>
/// <param name="startIndex">The index of the first element to use in the <paramref name="values"/> collection.</param>
/// <param name="length">The number of elements to use from the <paramref name="values"/> collection.</param>
public static void WriteNearFarScalar(CesiumOutputStream output, string propertyName, IList <JulianDate> dates, IList <NearFarScalar> values, int startIndex, int length)
{
if (dates.Count != values.Count)
{
throw new ArgumentException(CesiumLocalization.MismatchedNumberOfDatesAndValues, "values");
}
JulianDate epoch = GetAndWriteEpoch(output, dates, startIndex, length);
output.WritePropertyName(propertyName);
output.WriteStartSequence();
int last = startIndex + length;
for (int i = startIndex; i < last; ++i)
{
output.WriteValue(epoch.SecondsDifference(dates[i]));
NearFarScalar value = values[i];
output.WriteValue(value.NearDistance);
output.WriteValue(value.NearValue);
output.WriteValue(value.FarDistance);
output.WriteValue(value.FarValue);
output.WriteLineBreak();
}
output.WriteEndSequence();
}
/// <summary>
/// Writes a <see cref="NearFarScalar"/> value as an array in Clock, Cone, Magnitude order.
/// </summary>
/// <param name="output">The stream to which to write the value.</param>
/// <param name="value">The value to write.</param>
public static void WriteNearFarScalar(CesiumOutputStream output, NearFarScalar value)
{
output.WriteStartSequence();
output.WriteValue(value.NearDistance);
output.WriteValue(value.NearValue);
output.WriteValue(value.FarDistance);
output.WriteValue(value.FarValue);
output.WriteEndSequence();
}
public void TestScaleByDistanceProperty()
{
var expectedScaleByDistance = new NearFarScalar(100.5, 1.5, 200.5, 2.5);
using (Packet)
using (var billboard = Packet.OpenBillboardProperty())
using (var interval = billboard.OpenInterval())
{
interval.WriteScaleByDistanceProperty(expectedScaleByDistance);
}
AssertExpectedJson(PacketCesiumWriter.BillboardPropertyName, new Dictionary <string, object>
{
{ BillboardCesiumWriter.ScaleByDistancePropertyName, expectedScaleByDistance },
});
}
public void TestTranslucencyByDistanceProperty()
{
var expectedTranslucencyByDistance = new NearFarScalar(100.0, 1.0, 200.0, 2.0);
using (Packet)
using (var label = Packet.OpenLabelProperty())
using (var interval = label.OpenInterval())
{
interval.WriteTranslucencyByDistanceProperty(expectedTranslucencyByDistance);
}
AssertExpectedJson(PacketCesiumWriter.LabelPropertyName, new Dictionary <string, object>
{
{ LabelCesiumWriter.TranslucencyByDistancePropertyName, expectedTranslucencyByDistance },
});
}
private static string FormatValue([NotNull] object value)
{
if (value is bool)
{
// in C#, booleans format with a capital first letter
return(value.ToString().ToLowerInvariant());
}
if (value is double)
{
double d = (double)value;
return(d.ToString(CultureInfo.InvariantCulture));
}
if (value is string)
{
return(string.Format("\"{0}\"", value));
}
if (value is Color)
{
Color color = (Color)value;
return(CreateExpectedJson(new Dictionary <string, object>
{
{ "rgba", new List <object> {
color.R, color.G, color.B, color.A
} },
}));
}
if (value is NearFarScalar)
{
NearFarScalar nearFarScalar = (NearFarScalar)value;
return(CreateExpectedJson(new Dictionary <string, object>
{
{ "nearFarScalar", new List <object> {
nearFarScalar.NearDistance, nearFarScalar.NearValue, nearFarScalar.FarDistance, nearFarScalar.FarValue
} },
}));
}
if (value is Rectangular)
{
Rectangular rectangular = (Rectangular)value;
return(CreateExpectedJson(new Dictionary <string, object>
{
{ "cartesian2", new List <object> {
rectangular.X, rectangular.Y
} },
}));
}
if (value is Cartesian)
{
Cartesian cartesian = (Cartesian)value;
return(CreateExpectedJson(new Dictionary <string, object>
{
{ "cartesian", new List <object> {
cartesian.X, cartesian.Y, cartesian.Z
} },
}));
}
if (value is Cartographic)
{
Cartographic cartographic = (Cartographic)value;
return(CreateExpectedJson(new Dictionary <string, object>
{
{ "cartographicRadians", new List <object> {
cartographic.Longitude, cartographic.Latitude, cartographic.Height
} },
}));
}
if (value is UnitQuaternion)
{
UnitQuaternion unitQuaternion = (UnitQuaternion)value;
return(CreateExpectedJson(new Dictionary <string, object>
{
{ "unitQuaternion", new List <object> {
unitQuaternion.X, unitQuaternion.Y, unitQuaternion.Z, unitQuaternion.W
} },
}));
}
var dictionary = value as IDictionary <string, object>;
if (dictionary != null)
{
return(CreateExpectedJson(dictionary));
}
var list = value as IEnumerable <object>;
if (list != null)
{
var builder = new StringBuilder();
builder.Append('[');
foreach (object o in list)
{
builder.Append(FormatValue(o))
.Append(',');
}
builder[builder.Length - 1] = ']';
return(builder.ToString());
}
return(value.ToString());
}
/// <summary>
/// Writes a <see cref="NearFarScalar"/> value as an array in Clock, Cone, Magnitude order.
/// </summary>
/// <param name="output">The stream to which to write the value.</param>
/// <param name="value">The value to write.</param>
public static void WriteNearFarScalar(CesiumOutputStream output, NearFarScalar value)
{
output.WriteStartSequence();
output.WriteValue(value.NearDistance);
output.WriteValue(value.NearValue);
output.WriteValue(value.FarDistance);
output.WriteValue(value.FarValue);
output.WriteEndSequence();
}
