static void Main(string[] args)
{
var stocks = MarketDataParser.LoadStocks();
foreach (var stock_samples in stocks)
{
foreach (var sample in stock_samples)
{
Console.WriteLine(sample);
break;
}
}
}
void NewCreateMidMeshes()
{
stockmidList = MarketDataParser.LoadStocksMid();
int maxSamples = stockmidList.Count;
particles = new Particle[maxSamples];
for (int i = 0; i < particles.Length; i++)
{
particles[i].size = defaultParticleSize;
particles[i].color = defaultParticleColor;
}
int stocksToRender = System.Math.Min(stockmidList[0].Count, cubesPerMesh);
print("stockCount=" + stocksToRender + ", cubersPerMesh=" + cubesPerMesh);
int NMeshes = 100;
// goMeshes = new GameObject[NMeshes]; // maxSamples//[stocksToRender];
meshes = new Mesh[NMeshes];// stocksToRender];
// GaussianRandom gaussianRandom = new GaussianRandom();
List <Color> mesh_colors = new List <Color> {
Color.red, Color.green, Color.blue, Color.yellow
};
int color_choices = mesh_colors.Count;
Counts = new int[stocksToRender];
var colors = new Color[24 * cubesPerMesh];
int vertex_group = 10 * 24;
for (int c = 0; c < colors.Length / vertex_group; ++c)
{
var a_color = new Color(Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f));
for (int k = 0; k < vertex_group; ++k)
{
colors[vertex_group * c + k] = a_color;
}
}
print("Meshes created");
}
void CreateMidMeshes()
{
stockmidList = MarketDataParser.LoadStocksMid();
int maxSamples = stockmidList.Count;
log("createMidMeshes", "entry");
int stocksToRender = System.Math.Min(stockmidList[0].Count, cubesPerMesh);
print("stockCount=" + stocksToRender + ", cubersPerMesh=" + cubesPerMesh);
int NMeshes = 100;
if (maxSamples > NMeshes)
{
maxSamples = NMeshes;
}
goMeshes = new GameObject[NMeshes]; // maxSamples//[stocksToRender];
meshes = new Mesh[NMeshes]; // stocksToRender];
// GaussianRandom gaussianRandom = new GaussianRandom();
List <Color> mesh_colors = new List <Color> {
Color.red, Color.green, Color.blue, Color.yellow
};
int color_choices = mesh_colors.Count;
Counts = new int[stocksToRender];
for (int t = 0; t < maxSamples; t++) //cubesPerMesh &&
//
{
log("createMidMeshes", "item:" + t);
GameObject go = new GameObject("Mesh " + t);//GameObject.CreatePrimitive(PrimitiveType.Cube); //
go.transform.parent = transform;
MeshFilter mf = go.AddComponent <MeshFilter>();
Mesh mesh = new Mesh();
// mesh.MarkDynamic(); // don't think it changes often anymore if we change the mesh to be across stocks
mf.mesh = mesh;
Renderer rend = go.AddComponent <MeshRenderer>();
rend.material = material;
rend.material.color = mesh_colors[t % color_choices];
var vertices = new Vector3[24 * cubesPerMesh];
var triangles = new int[36 * cubesPerMesh];
var normals = new Vector3[24 * cubesPerMesh];
var colors = new Color[24 * cubesPerMesh];
int vertex_group = 10 * 24;
for (int c = 0; c < colors.Length / vertex_group; ++c)
{
var a_color = new Color(Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f));
for (int k = 0; k < vertex_group; ++k)
{
colors[vertex_group * c + k] = a_color;
}
}
var uv = new Vector2[24 * cubesPerMesh];
float x_time = 0, y_return = 0;
// TODO: cubesPerMesh might be smaller than the sample count
//for (int t = 0; t < cubesPerMesh && t < maxSamples; t++) {
for (int iStock = 0; iStock < stocksToRender; iStock++)
{
// x=> screen x
// y=> screen y
// z=> depth
//x = (float)(gaussianRandom.NextGaussian() * spaceRange);
//z = (float)(gaussianRandom.NextGaussian() * spaceRange);
//y = (float)(0.1*x + 0.2*z + gaussianRandom.NextGaussian() * 0.5 * spaceRange );
x_time += spaceRange;
print("Adding x_time=" + x_time
+ ", y_price=" + y_return
+ ", z_stock" + iStock);
MeshCube.AddCube(ref vertices, ref triangles, ref normals, ref uv, iStock,
new Vector3(x_time, 0, iStock * spaceRange * 10), defaultParticleSize / 2);
}
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.normals = normals;
mesh.colors = colors;
mesh.uv = uv;
mesh.RecalculateBounds();
mesh.Optimize();
for (int k = 0; k < 5; k++)
{
print("k=" + k);
print("vertices: " + mesh.vertices[k]);
print("triangles: " + mesh.triangles[k]);
print("normals: " + mesh.normals[k]);
print("uv: " + mesh.uv[k]);
print("colors: " + mesh.colors[k]);
}
goMeshes[t] = go;
meshes[t] = mesh;
}
log("createMidMeshes", "exit");
print("Meshes created");
}
void CreateStockListMeshes()
{
stockLists = MarketDataParser.LoadStocks();
int maxSamples = 0;
foreach (var list in stockLists)
{
if (maxSamples < list.Count)
{
maxSamples = list.Count;
}
}
particles = new Particle[maxSamples];
for (int i = 0; i < particles.Length; i++)
{
particles[i].size = defaultParticleSize;
particles[i].color = defaultParticleColor;
}
int stocksToRender = stockLists.Count;
print("stockCount=" + stockLists.Count + ", cubersPerMesh=" + cubesPerMesh);
goMeshes = new GameObject[stockLists.Count];
meshes = new Mesh[stockLists.Count];
GaussianRandom gaussianRandom = new GaussianRandom();
List <Color> mesh_colors = new List <Color> {
Color.red, Color.green, Color.blue, Color.yellow
};
int color_choices = mesh_colors.Count;
Counts = new int[stockLists.Count];
for (int i = 0; i < stockLists.Count; i++)
{
GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube); //new GameObject("Mesh " + i);
go.transform.parent = transform;
MeshFilter mf = go.AddComponent <MeshFilter>();
Mesh mesh = new Mesh();
mesh.MarkDynamic();
mf.mesh = mesh;
Renderer rend = go.AddComponent <MeshRenderer>();
rend.material = material;
rend.material.color = mesh_colors[i % color_choices];
var vertices = new Vector3[24 * cubesPerMesh];
var triangles = new int[36 * cubesPerMesh];
var normals = new Vector3[24 * cubesPerMesh];
var colors = new Color[24 * cubesPerMesh];
int vertex_group = 10 * 24;
var uv = new Vector2[24 * cubesPerMesh];
for (int c = 0; c < colors.Length / vertex_group; ++c)
{
var a_color = new Color(Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f));
for (int k = 0; k < vertex_group; ++k)
{
colors[vertex_group * c + k] = a_color;
}
}
float x_time = 0, y_return = 0;
// TODO: cubesPerMesh might be smaller than the sample count
var samples = stockLists[i];
Counts[i] = samples.Count;
for (int j = 0; j < cubesPerMesh && j < samples.Count; j++)
{
// x=> screen x
// y=> screen y
// z=> depth
//x = (float)(gaussianRandom.NextGaussian() * spaceRange);
//z = (float)(gaussianRandom.NextGaussian() * spaceRange);
//y = (float)(0.1*x + 0.2*z + gaussianRandom.NextGaussian() * 0.5 * spaceRange );
x_time += spaceRange;
float init = samples[0].open;
float open = samples[j].open;
y_return = (open - init) * 10000 / init; // in bps
print("Adding x_time=" + x_time
+ ", y_price=" + y_return
+ ", z_stock" + i);
MeshCube.AddCube(ref vertices, ref triangles, ref normals, ref uv, j,
new Vector3(x_time, 0, i * spaceRange * 10), defaultParticleSize / 2);
}
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.normals = normals;
mesh.colors = colors;
mesh.uv = uv;
mesh.RecalculateBounds();
mesh.Optimize();
for (int k = 0; k < 5; k++)
{
print("k=" + k);
print("vertices: " + mesh.vertices[k]);
print("triangles: " + mesh.triangles[k]);
print("normals: " + mesh.normals[k]);
print("uv: " + mesh.uv[k]);
print("colors: " + mesh.colors[k]);
}
goMeshes[i] = go;
meshes[i] = mesh;
}
print("Meshes created");
}
void CreateMeshes()
{
MarketDataParser.Load3ds();
List <MydataType> all3DS = MarketDataParser.runningList;
numOfStocks = MarketDataParser.NStocks;
int stocksToRender = System.Math.Min(MarketDataParser.NStocks, numOfStocks);
print("stockCount=" + stocksToRender + ", cubersPerMesh=" + numOfStocks);
log("newcreatemid", "cubsPerMesh=" + numOfStocks);
//Tuple<int, int, int, int> sizes = shape.getSizes();
int[] sizes = shape.getSize();
log("CreateMeshes", "V:" + sizes[MeshShape.NVertices] + " N:" + sizes[MeshShape.NNormals]
+ " U:" + sizes[MeshShape.NUVs] + " T:" + sizes[MeshShape.NTriangles] + "," + sizes[0] + sizes[1] + sizes[3] + sizes[3]);
var colors = new Color32[sizes[MeshShape.NVertices] * numOfStocks];
int vertex_group = sizes[MeshShape.NVertices];
List <Color> allColor = MarketDataParser.runningColorList;
for (int k = 0; k < numOfStocks; ++k)
{
for (int j = 0; j < vertex_group; j++)
{
colors[k * vertex_group + j] = allColor[k];
}
}
go = new GameObject("Mesh 1");//GameObject.CreatePrimitive(PrimitiveType.Cube); //
go.transform.parent = transform;
MeshFilter mf = go.AddComponent <MeshFilter>();
mesh = go.GetComponent <MeshFilter>().mesh;
Renderer rend = go.AddComponent <MeshRenderer>();
log("NewCreate", "before shader find");
rend.material = material;
log("NewCreate", "post shader find");
mesh.vertices = new Vector3[sizes[MeshShape.NVertices] * numOfStocks];
mesh.normals = new Vector3[sizes[MeshShape.NNormals] * numOfStocks];
mesh.uv = new Vector2[sizes[MeshShape.NUVs] * numOfStocks];
mesh.triangles = new int[sizes[MeshShape.NTriangles] * numOfStocks];
log("Sizes", "V:" + mesh.vertices.Length + "N:" + mesh.normals.Length + "U:" + mesh.uv.Length + "T:" + mesh.triangles.Length);
mesh.MarkDynamic();
var vertices = mesh.vertices;
var triangles = mesh.triangles;
var normals = mesh.normals;
var uv = mesh.uv;
for (int stocki = 0; stocki < numOfStocks; stocki++)
{
Vector3 newLocation = new Vector3(
// No sizing here, all sizing controlled by matlab codes
all3DS[stocki].x * 1,
all3DS[stocki].y * 1,
all3DS[stocki].z * 1);
Vector3 worldPt = transform.TransformPoint(newLocation);
shape.AddShape(ref vertices, ref triangles, ref normals, ref uv, stocki, //which
newLocation, //worldPt,// GetVertexWorldPosition(newLocation, transform),
defaultParticleSize * all3DS[stocki].w);
//log("create", "done with " + stocki);
}
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.normals = normals;
mesh.uv = uv;
mesh.colors32 = colors;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
;
print("Meshes created");
}
