private void UpdateBuffer()
{
uint packSize = AnnotationVariable.DataType.GetPackSizeScalar();
if (AnnotationVariable.IsMatrix && Values[0] is SerializableColor)
{
for (int i = 0; i < Values.Count; ++i)
{
uint stepOffset = packSize * AnnotationVariable.Rows;
stepOffset = stepOffset.RoundUpMultiple16();
AnnotationVariable.CopyColorToBuffer((SerializableColor)Values.ElementAt(i), stepOffset, packSize * (uint)i);
}
}
else
{
uint startOffset = 0;
for (int column = 0; column < AnnotationVariable.Columns; ++column)
{
for (int row = 0; row < AnnotationVariable.Rows; ++row)
{
if (Values[row * column + column] != null)
{
AnnotationVariable.CopyToBuffer(PropertyHelpers.ConvertToCorrectType(AnnotationVariable.DataType, Values[row * (int)AnnotationVariable.Columns + column]), startOffset);
}
startOffset += packSize;
}
startOffset = startOffset.RoundUpMultiple16();
}
}
ITempHelper helper = ((App)Application.Current).ActiveViewport;
AnnotationVariable.AnnotationGroup.MarshalBuffer(helper.ViewportHost, helper.IsStandardShaderActive);
}
public static UIElement CreateSlider(object source, string path, AnnotationVariable var, object storedValue)
{
Slider slider = new Slider();
slider.Minimum = (var.DataType.IsIntegral()) ? var.GetMinimumInteger() : var.GetMinimumDouble();
slider.Maximum = (var.DataType.IsIntegral()) ? var.GetMaximumInteger() : var.GetMaximumDouble();
slider.TickFrequency = (var.DataType.IsIntegral()) ? var.GetStepInteger() : var.GetStepDouble();
slider.IsSnapToTickEnabled = true;
slider.HorizontalContentAlignment = HorizontalAlignment.Stretch;
slider.HorizontalAlignment = HorizontalAlignment.Stretch;
slider.Width = 250;
Binding binding = new Binding();
binding.Source = source;
binding.Mode = BindingMode.TwoWay;
binding.Path = new PropertyPath(path);
BindingOperations.SetBinding(slider, RangeBase.ValueProperty, binding);
if (storedValue == null)
{
slider.Value = Math.Max(Math.Min(0.0, slider.Maximum), slider.Minimum);
}
else
{
slider.Value = (double)storedValue;
}
return(slider);
}
public static UIElement CreateSpinner(object source, string path, AnnotationVariable var, object storedValue)
{
if (var.DataType.IsIntegral())
{
IntegerUpDown spinner = new IntegerUpDown();
spinner.Increment = var.GetStepInteger();
spinner.Minimum = var.GetMinimumInteger();
spinner.Maximum = var.GetMaximumInteger();
Binding binding = new Binding();
binding.Source = source;
binding.Mode = BindingMode.TwoWay;
binding.Path = new PropertyPath(path);
BindingOperations.SetBinding(spinner, IntegerUpDown.ValueProperty, binding);
if (storedValue == null)
{
spinner.Value = Math.Max(Math.Min(0, spinner.Maximum.Value), spinner.Minimum.Value);
}
else
{
spinner.Value = (int)storedValue;
}
spinner.HorizontalContentAlignment = HorizontalAlignment.Stretch;
spinner.HorizontalAlignment = HorizontalAlignment.Stretch;
return(spinner);
}
else
{
DoubleUpDown spinner = new DoubleUpDown();
spinner.Increment = var.GetStepDouble();
spinner.Minimum = var.GetMinimumDouble();
spinner.Maximum = var.GetMaximumDouble();
Binding binding = new Binding();
binding.Source = source;
binding.Mode = BindingMode.TwoWay;
binding.Path = new PropertyPath(path);
BindingOperations.SetBinding(spinner, DoubleUpDown.ValueProperty, binding);
if (storedValue == null)
{
spinner.Value = Math.Max(Math.Min(0, spinner.Maximum.Value), spinner.Minimum.Value);
}
else
{
spinner.Value = (double)storedValue;
}
spinner.HorizontalContentAlignment = HorizontalAlignment.Stretch;
spinner.HorizontalAlignment = HorizontalAlignment.Stretch;
return(spinner);
}
}
public static double GetStepDouble(this AnnotationVariable var)
{
string uistep = "";
double step = 0.1;
if (var.Annotations?.TryGetValue("UIStep", out uistep) ?? false)
{
double.TryParse(uistep, NumberStyles.Any, CultureInfo.InvariantCulture, out step);
}
return(step);
}
public static int GetStepInteger(this AnnotationVariable var)
{
string uistep = "";
int step = 1;
if (var.Annotations?.TryGetValue("UIStep", out uistep) ?? false)
{
int.TryParse(uistep, out step);
}
return(step);
}
public static double GetMaximumDouble(this AnnotationVariable var)
{
double maximum = double.MaxValue;
string max = "";
if (var.Annotations?.TryGetValue("UIMax", out max) ?? false)
{
double.TryParse(max, NumberStyles.Any, CultureInfo.InvariantCulture, out maximum);
}
if (var.IsSNorm || var.IsUNorm)
{
maximum = Math.Min(maximum, 1.0);
}
return(maximum);
}
public static int GetMaximumInteger(this AnnotationVariable var)
{
int maximum = int.MaxValue;
string max = "";
if (var.Annotations?.TryGetValue("UIMax", out max) ?? false)
{
int.TryParse(max, out maximum);
}
if (var.IsSNorm || var.IsUNorm)
{
maximum = Math.Min(maximum, 1);
}
return(maximum);
}
public static void EndVar()
{
if (_varValid)
{
if (_activeGroup.AnnotationVariables.Count > 0 && !_activeVar.IsTexture &&
(
(_activeGroup.AnnotationVariables.Last().DataType.IsMinimum() && !_activeVar.DataType.IsMinimum()) ||
(!_activeGroup.AnnotationVariables.Last().DataType.IsMinimum() && _activeVar.DataType.IsMinimum())))
{
_curOffset = _curOffset.RoundUpMultiple16();
}
_activeGroup.AnnotationVariables.Add(_activeVar);
if (!_activeVar.IsTexture)
{
uint size = 0;
if (_activeVar.IsScalar)
{
size = _activeVar.DataType.GetPackSizeScalar();
}
else if (_activeVar.IsVector)
{
size = _activeVar.DataType.GetPackSizeScalar() * _activeVar.Columns;
}
else if (_activeVar.IsMatrix)
{
size = (_activeVar.Columns - 1) * 16 + (_activeVar.DataType.GetPackSizeScalar() * _activeVar.Rows);
}
if (_activeVar.Dimension > 0)
{
size = size.RoundUpMultiple16();
size *= (uint)_activeVar.Dimension;
}
uint nextMultiple = _curOffset.RoundUpMultiple16();
if (_curOffset + size > nextMultiple && _curOffset > 0)
{
_curOffset = nextMultiple;
}
_activeVar.Offset = _curOffset;
_activeVar.Size = size;
_curOffset += size;
}
}
_activeVar = null;
}
public static double GetMinimumDouble(this AnnotationVariable var)
{
double minimum = double.MinValue;
string min = "";
if (var.Annotations?.TryGetValue("UIMin", out min) ?? false)
{
double.TryParse(min, NumberStyles.Any, CultureInfo.InvariantCulture, out minimum);
}
if (var.IsSNorm)
{
minimum = Math.Max(minimum, -1.0);
}
else if (var.IsUNorm || var.DataType.IsUnsigned())
{
minimum = Math.Max(minimum, 0.0);
}
return(minimum);
}
public static int GetMinimumInteger(this AnnotationVariable var)
{
int minimum = int.MinValue;
string min = "";
if (var.Annotations?.TryGetValue("UIMin", out min) ?? false)
{
int.TryParse(min, out minimum);
}
if (var.IsSNorm)
{
minimum = Math.Max(minimum, -1);
}
else if (var.IsUNorm || var.DataType.IsUnsigned())
{
minimum = Math.Max(minimum, 0);
}
return(minimum);
}
public ImagePicker(AnnotationVariable annotationVar)
{
InitializeComponent();
((ImagePickerViewModel)DataContext).AnnotationVariable = annotationVar;
}
public DropdownVecMatProperty(AnnotationVariable annotationVar)
{
InitializeComponent();
((DropdownVecMatPropertyViewModel)DataContext).AnnotationVariable = annotationVar;
}
public static void BeginVar()
{
_activeVar = new AnnotationVariable();
_varValid = true;
}
public static void DestroyGroup()
{
_activeVar = null;
_activeGroup = null;
}
