protected override void RebuildVisualization()
{
if (_presenter == null || _presenter.NumberOfDimensions < 1)
{
Debug.LogError("Presenter is either null or has not enough dimensions to represent this visualization");
return;
}
var iMesh = new IntermediateMesh();
int offset = (int)_presenter.SelectedMinItem;
int length = (int)_presenter.SelectedMaxItem - offset;
float maxValue = VisViewHelper.GetGlobalMaximum(_presenter);
float step = 1.0f / _presenter.NumberOfDimensions;
for (int dimIndex = 0; dimIndex < _presenter.NumberOfDimensions; dimIndex++)
{
for (int itemIndex = 0; itemIndex < length; itemIndex++)
{
float valueX = (float)itemIndex / length;
float valueY = VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, itemIndex + offset) / maxValue;
float valueZ = dimIndex * step + (0.5f * step);
iMesh.Vertices.Add(new Vector3(valueX * _size.x, valueY * _size.y, valueZ * _size.z));
iMesh.Normals.Add(-Vector3.forward);
iMesh.Colors.Add(_style.GetColorCategorical(dimIndex, valueX));
if (itemIndex == 0)
{
continue;
}
iMesh.Indices.Add(iMesh.Vertices.Count - 2);
iMesh.Indices.Add(iMesh.Vertices.Count - 1);
}
}
var meshFilter = GetComponent <MeshFilter>();
meshFilter.sharedMesh = iMesh.GenerateMesh("LineChart2DMesh", MeshTopology.Lines);
}
protected override void RebuildVisualization()
{
if (_presenter == null || _presenter.NumberOfDimensions < 2)
{
Debug.LogError("Presenter is either null or has not enough dimensions to represent this visualization");
return;
}
List <Vector3> points = new List <Vector3>();
int offset = (int)_presenter.SelectedMinItem;
int length = (int)_presenter.SelectedMaxItem - offset;
float max = VisViewHelper.GetGlobalMaximum(_presenter);
int dimNum = _presenter.NumberOfDimensions;
for (int itemIndex = offset; itemIndex < length; itemIndex++)
{
float x = VisViewHelper.GetItemValueAbsolute(_presenter, 1, itemIndex, true) * _size.x;
float y = VisViewHelper.GetItemValueAbsolute(_presenter, 0, itemIndex, true) * _size.y;
if (_presenter.AxisPresenters[0].IsCategorical)
{
y = ((float)itemIndex / (float)length) * _size.y;
}
points.Add(new Vector3(x, y, 0));
Debug.Log(points[points.Count - 1]);
}
Debug.Log("points " + points.Count);
Mesh mesh = CreateGeometry(points.ToArray(), _segments, false, true, _style, _usedCategorical, _dimIndex);
mesh.name = "RotationalMesh";
var meshFilter = GetComponent <MeshFilter>();
meshFilter.sharedMesh = mesh;
if (this.gameObject.transform.Find("innerSide") != null)
{
GameObject objToDestroy = this.gameObject.transform.Find("innerSide").gameObject;
Destroy(objToDestroy);
#if UNITY_EDITOR
DestroyImmediate(objToDestroy);
#endif
}
GameObject innerSide = new GameObject("innerSide");
innerSide.transform.SetParent(this.gameObject.transform);
innerSide.transform.localPosition = Vector3.zero;
innerSide.layer = this.gameObject.layer;
innerSide.transform.localRotation = Quaternion.Euler(0, 0, 0);
var mfis = innerSide.AddComponent <MeshFilter>();
var mris = innerSide.AddComponent <MeshRenderer>();
mfis.sharedMesh = CreateGeometry(points.ToArray(), _segments, false, false, _style, _usedCategorical, _dimIndex);
mris.material = GetComponent <MeshRenderer>().material;
}
protected override void RebuildVisualization()
{
if (_presenter == null || _presenter.NumberOfDimensions < 1)
{
Debug.LogError("Presenter is either null or has not enough dimensions to represent this visualization");
return;
}
var vertices = new List <Vector3>();
var normals = new List <Vector3>();
var colors = new List <Color>();
var indices = new List <int>();
int offset = (int)_presenter.SelectedMinItem;
int length = (int)_presenter.SelectedMaxItem - offset;
float maxValue = VisViewHelper.GetGlobalMaximum(_presenter);
for (int dimIndex = 0; dimIndex < _presenter.NumberOfDimensions; dimIndex++)
{
for (int itemIndex = 0; itemIndex < length; itemIndex++)
{
float valueX = (float)itemIndex / length;
float valueY = VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, itemIndex + offset) / maxValue;
vertices.Add(new Vector3(valueX * _size.x, valueY * _size.y, 0.0f));
normals.Add(-Vector3.forward);
colors.Add(_style.GetColorCategorical(dimIndex, valueX));
if (itemIndex == 0)
{
continue;
}
indices.Add(vertices.Count - 2);
indices.Add(vertices.Count - 1);
}
}
var mesh = new Mesh();
mesh.name = "LineChart2DMesh";
mesh.vertices = vertices.ToArray();
mesh.normals = normals.ToArray();
mesh.colors = colors.ToArray();
mesh.SetIndices(indices.ToArray(), MeshTopology.Lines, 0);
var meshFilter = GetComponent <MeshFilter>();
meshFilter.sharedMesh = mesh;
}
protected override void RebuildVisualization()
{
if (_presenter == null || _presenter.NumberOfDimensions < 3)
{
Debug.LogError("Presenter is either null or has not enough dimensions to represent this visualization");
return;
}
var iMesh = new IntermediateMesh();
int offset = _presenter.SelectedMinItem;
int length = _presenter.SelectedItemsCount;
float posXStep = _size.x / length;
float posZStep = _size.z / _presenter.NumberOfDimensions;
float maxValue = VisViewHelper.GetGlobalMaximum(_presenter);
float uStep = 1.0f / length;
float vStep = 1.0f / _presenter.NumberOfDimensions;
for (int dimIndex = 0; dimIndex < _presenter.NumberOfDimensions; dimIndex++)
{
for (int itemIndex = 0; itemIndex < length; itemIndex++)
{
float value = VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, itemIndex + offset) / maxValue;
var pos = new Vector3(posXStep * itemIndex, value, posZStep * dimIndex);
iMesh.Vertices.Add(new Vector3(pos.x * _size.x, pos.y * _size.y, pos.z * _size.z));
iMesh.Colors.Add(_style.GetColorContinous(uStep * itemIndex, vStep * dimIndex));
if (itemIndex < 1 || dimIndex < 1)
{
continue;
}
iMesh.Indices.Add(dimIndex * length + itemIndex);
iMesh.Indices.Add((dimIndex - 1) * length + itemIndex - 1);
iMesh.Indices.Add(dimIndex * length + itemIndex - 1);
iMesh.Indices.Add(dimIndex * length + itemIndex);
iMesh.Indices.Add((dimIndex - 1) * length + itemIndex);
iMesh.Indices.Add((dimIndex - 1) * length + itemIndex - 1);
}
}
var mesh = iMesh.GenerateMesh("HeightmapMesh", MeshTopology.Triangles);
mesh.RecalculateNormals();
var meshFilter = GetComponent <MeshFilter>();
Destroy(meshFilter.sharedMesh);
meshFilter.sharedMesh = mesh;
}
protected override void RebuildAxes()
{
if (_axisViews == null || _fromEditor)
{
SetupInitialAxisViews();
}
AxisTick[] ticks;
if (_presenter is MultiDimDataPresenter mdp)
{
ticks = _presenter.AxisPresenters[0].GenerateFromDimension(mdp.CaptionDimension, _presenter.SelectedMinItem, _presenter.SelectedMaxItem);
}
else
{
ticks = _presenter.AxisPresenters[0].GenerateFromDiscreteRange(_presenter.SelectedMinItem, _presenter.SelectedMaxItem);
}
_axisViews[0].RebuildAxis(ticks);
ticks = _presenter.AxisPresenters[1].GenerateFromMinMaxValue(0.0f, VisViewHelper.GetGlobalMaximum(_presenter));
_axisViews[1].RebuildAxis(ticks);
}
protected override void RebuildVisualization()
{
if (_presenter == null || _presenter.NumberOfDimensions < 1)
{
Debug.LogError("Presenter is either null or has not enough dimensions to represent this visualization");
return;
}
var vertices = new List <Vector3>();
var colors = new List <Color>();
var indices = new List <int>();
int offset = (int)_presenter.SelectedMinItem;
int length = (int)_presenter.SelectedMaxItem - offset;
float maxValue = VisViewHelper.GetGlobalMaximum(_presenter);
float radius = 0.5f * _size.x;
float divisor = 0;
//TODO find better way to determine divisor (what 100% is)
for (int dimIndex = 0; dimIndex < _presenter.NumberOfDimensions; dimIndex++)
{
divisor += VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, _valueIndex + offset) / maxValue;
}
MultiDimDataPresenter presenter = (MultiDimDataPresenter)_presenter;
Debug.Log(presenter.CaptionDimension.GetStringValue(ValueIndex));
float startAngle = 0;
for (int dimIndex = 0; dimIndex < _presenter.NumberOfDimensions; dimIndex++)
{
float height = -(VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, _3DIndex + offset) / maxValue) * _size.z;
vertices.Add(new Vector3(0, 0, height));
int zeroTop = vertices.Count - 1;
float sumOfDim = VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, _valueIndex + offset) / maxValue;
float part = sumOfDim / divisor;
colors.Add(_style.GetColorCategorical(dimIndex, part));
float angle = part * Mathf.PI * 2;
float endAngle = startAngle + angle;
List <Vector3> partMeshTop = Circles.CreatePartMesh(startAngle, endAngle, radius, _segments);
for (int i = 0; i < partMeshTop.Count; i++)
{
partMeshTop[i] = new Vector3(partMeshTop[i].x, partMeshTop[i].y, height);
}
for (int vertex = 1; vertex < partMeshTop.Count; vertex++)
{
colors.Add(_style.GetColorCategorical(dimIndex, part));
indices.Add(vertices.Count - 1);
indices.Add(vertices.Count + vertex);
indices.Add(vertices.Count - 1 + vertex);
}
colors.Add(_style.GetColorCategorical(dimIndex, part));
vertices.AddRange(partMeshTop);
vertices.Add(Vector3.zero);
int zeroBottom = vertices.Count - 1;
colors.Add(_style.GetColorCategorical(dimIndex, part));
List <Vector3> partMeshBottom = Circles.CreatePartMesh(startAngle, endAngle, radius, _segments);
for (int vertex = 1; vertex < partMeshBottom.Count; vertex++)
{
colors.Add(_style.GetColorCategorical(dimIndex, part));
indices.Add(vertices.Count - 1);
indices.Add(vertices.Count - 1 + vertex);
indices.Add(vertices.Count + vertex);
}
colors.Add(_style.GetColorCategorical(dimIndex, part));
vertices.AddRange(partMeshBottom);
//adding side quads
int[] tris = new int[] { zeroTop, zeroTop + 1, zeroBottom + 1, zeroTop, zeroBottom + 1, zeroBottom, zeroTop, vertices.Count - 1, zeroBottom - 1, zeroTop, zeroBottom, vertices.Count - 1 };
indices.AddRange(tris);
//adding rounds
List <int> round = Circles.CreateRound(vertices.Count - partMeshBottom.Count - partMeshTop.Count - 1, partMeshTop.Count - 1, 1);
indices.AddRange(round);
startAngle = endAngle;
}
var mesh = new Mesh();
mesh.name = "PieChart3DMesh";
mesh.vertices = vertices.ToArray();
mesh.colors = colors.ToArray();
mesh.SetIndices(indices.ToArray(), MeshTopology.Triangles, 0);
mesh.RecalculateNormals();
var meshFilter = GetComponent <MeshFilter>();
meshFilter.sharedMesh = mesh;
}
protected override void RebuildVisualization()
{
if (_presenter == null || _presenter.NumberOfDimensions < 3)
{
Debug.LogError("Presenter is either null or has not enough dimensions to represent this visualization");
return;
}
if (_dataItemMesh == null)
{
Debug.LogError("No DataMesh was set for this visualization.");
return;
}
var iMesh = new IntermediateMesh();
// temporary save the mesh data from the template for faster access
var tVertices = _dataItemMesh.vertices;
var tNromals = _dataItemMesh.normals;
var tUVs = _dataItemMesh.uv;
var tIndices = _dataItemMesh.triangles;
int offset = _presenter.SelectedMinItem;
int length = _presenter.SelectedItemsCount;
float maxValue = VisViewHelper.GetGlobalMaximum(_presenter);
float posXStep = _size.x / length;
float posXOffset = posXStep * 0.5f;
float posZStep = _size.z / _presenter.NumberOfDimensions;
float posZOffset = posZStep * 0.5f;
float uStep = 1.0f / length;
float uOffset = uStep * 0.5f;
float vStep = 1.0f / _presenter.NumberOfDimensions;
float vOffset = vStep * 0.5f;
//TODO: UV coords of mesh based on height to add grid lines
for (int dimIndex = 0; dimIndex < _presenter.NumberOfDimensions; dimIndex++)
{
for (int itemIndex = 0; itemIndex < length; itemIndex++)
{
float value = VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, itemIndex + offset) / maxValue;
var pos = new Vector3(posXOffset + posXStep * itemIndex, 0, posZOffset + posZStep * dimIndex);
var scale = new Vector3(posXStep * _barThickness.x, value * _size.y, posZStep * _barThickness.y);
var startIndex = iMesh.Vertices.Count;
foreach (var v in tVertices)
{
var vPos = new Vector3(pos.x + v.x * scale.x, pos.y + v.y * scale.y, pos.z + v.z * scale.z);
iMesh.Vertices.Add(vPos);
iMesh.Colors.Add(_style.GetColorContinous(_presenter.IsItemHighlighted(itemIndex), uOffset + uStep * itemIndex, vOffset + vStep * dimIndex, vPos.y));
}
iMesh.Normals.AddRange(tNromals);
iMesh.TexCoords.AddRange(tUVs);
foreach (var index in tIndices)
{
iMesh.Indices.Add(startIndex + index);
}
}
}
var mesh = iMesh.GenerateMesh("BarChart3DMesh", MeshTopology.Triangles);
var meshFilter = GetComponent <MeshFilter>();
meshFilter.sharedMesh = mesh;
// TODO Move this into separate class
var meshCollider = GetComponent <MeshCollider>();
if (meshCollider != null)
{
meshCollider.sharedMesh = mesh;
}
}
protected override void RebuildVisualization()
{
if (_presenter == null || _presenter.NumberOfDimensions < 1)
{
Debug.LogError("Presenter is either null or has not enough dimensions to represent this visualization");
return;
}
var vertices = new List <Vector3>();
var normals = new List <Vector3>();
var colors = new List <Color>();
var indices = new List <int>();
int offset = (int)_presenter.SelectedMinItem;
int length = (int)_presenter.SelectedMaxItem - offset;
float maxValue = VisViewHelper.GetGlobalMaximum(_presenter);
float radius = 0.5f * _size.x;
float divisor = 0;
//TODO find better way to determine divisor (what 100% is)
for (int dimIndex = 0; dimIndex < _presenter.NumberOfDimensions; dimIndex++)
{
divisor += VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, _valueIndex + offset) / maxValue;
}
MultiDimDataPresenter presenter = (MultiDimDataPresenter)_presenter;
float startAngle = 0;
for (int dimIndex = 0; dimIndex < _presenter.NumberOfDimensions; dimIndex++)
{
vertices.Add(Vector3.zero);
normals.Add(-Vector3.forward);
float sumOfDim = VisViewHelper.GetItemValueAbsolute(_presenter, dimIndex, _valueIndex + offset) / maxValue;
float part = sumOfDim / divisor;
colors.Add(_style.GetColorCategorical(dimIndex, part));
float angle = part * Mathf.PI * 2;
float endAngle = startAngle + angle;
List <Vector3> partMesh = Circles.CreatePartMesh(startAngle, endAngle, radius, _segments);
for (int vertex = 1; vertex < partMesh.Count; vertex++)
{
colors.Add(_style.GetColorCategorical(dimIndex, part));
normals.Add(-Vector3.forward);
indices.Add(vertices.Count - 1);
indices.Add(vertices.Count + vertex);
indices.Add(vertices.Count - 1 + vertex);
}
colors.Add(_style.GetColorCategorical(dimIndex, part));
normals.Add(-Vector3.forward);
startAngle = endAngle;
vertices.AddRange(partMesh);
}
var mesh = new Mesh();
mesh.name = "PieChart2DMesh";
mesh.vertices = vertices.ToArray();
mesh.normals = normals.ToArray();
mesh.colors = colors.ToArray();
mesh.SetIndices(indices.ToArray(), MeshTopology.Triangles, 0);
var meshFilter = GetComponent <MeshFilter>();
meshFilter.sharedMesh = mesh;
}
