public async Task <IActionResult> PutDynamicFieldModel(int id, DynamicFieldModel dynamicFieldModel)
{
if (id != dynamicFieldModel.DynamicFieldId)
{
return(BadRequest());
}
context.Entry(dynamicFieldModel).State = EntityState.Modified;
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DynamicFieldModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <DynamicFieldModel> > PostDynamicFieldModel(DynamicFieldModel dynamicFieldModel)
{
context.DynamicFields.Add(dynamicFieldModel);
await context.SaveChangesAsync();
return(CreatedAtAction("GetDynamicFieldModel", new { id = dynamicFieldModel.DynamicFieldId }, dynamicFieldModel));
}
public void EnsureSetup()
{
if (isSetup)
{
return;
}
isSetup = false;
if (this.Model == null)
{
this.Model = this.gameObject.GetComponentInParent <DynamicFieldModel> ();
}
if (this.PartSystem == null)
{
this.PartSystem = this.gameObject.GetComponent <ParticleSystem> ();
}
this.PartRenderer = this.PartSystem.GetComponent <ParticleSystemRenderer> ();
this.Model.EnsureSetup();
this.UpdateFieldParticles(isFirst: true);
Model.OnPausedChanged += (bool isNowPaused) => {
this.gameObject.SetActive(!isNowPaused);
};
}
public override Vector3 CalcVectorField(DynamicFieldModel model, int posIndex, Vector3 pos, out Color primaryColor)
{
var res = base.CalcVectorField(model, posIndex, pos, out primaryColor);
primaryColor = Color.green;
return(res);
}
public override Vector3 CalcVectorField(DynamicFieldModel model, int posIndex, Vector3 pos, out Color primaryColor)
{
Vector3 res = Vector3.zero;
primaryColor = Color.white;
foreach (var s in this.AllSpans)
{
if (s.LatestAlpha > 0.0f)
{
if (s.FieldCache == null)
{
s.FieldCache = new Vector3[model.CellCount];
for (int c = 0; c < model.CellCount; c++)
{
var cPos = model.FieldsCells.Array[c].Pos;
var cField = Vector3.zero;
for (int i = 1; i < s.Line.Points.Length; i++)
{
var fm = s.Line.Points [i - 1];
var to = s.Line.Points [i];
var fld = DynamicFieldModel.ChakraFieldAlongLineV4(cPos, fm, to, false);
cField += fld;
}
s.FieldCache [c] = cField;
}
}
primaryColor = ((s == this.SpanCrownToDanTien) ? Color.white : Color.green);
res += s.FieldCache [posIndex] * Mathf.Pow(s.LatestAlpha, 0.75f);
}
}
return(res);
}
public override Vector3 CalcVectorField(DynamicFieldModel model, int posIndex, Vector3 pos, out Color primaryColor)
{
primaryColor = Color.yellow;
//var spinePos = this.Body.SpineStart.position;// Vector3.Lerp (this.Body.SpineStart.position, this.Body.SpineEnd.position, 0.3f);
var spinePos = Vector3.Lerp(this.Body.SpineStart.position, this.Body.SpineEnd.position, 0.51f);
//return DynamicFieldModel.ChakraFieldV3 (pos, spinePos, Quaternion.identity, false);
model.ParticleFlowRate = 0.3f;
mChangedModel = model;
if (this.Breath.BreathIndex % 2 == 0)
{
model.ParticleFlowRate = 0.3f;
if ((CachedRandom == null) || (CachedRandom.Length != model.CellCount))
{
CachedRandom = new Vector3[model.CellCount];
for (int i = 0; i < model.CellCount; i++)
{
CachedRandom [i] = Random.onUnitSphere;
}
}
var delta = (pos - spinePos);
var nearestPosOnLine = spinePos;
var r = (pos - nearestPosOnLine);
var distScaler = 5.0f;
var dist = (distScaler / delta.magnitude);
var inpct = Mathf.Min(dist * 6.0f, (distScaler / r.magnitude));
var toline = r.normalized * (-inpct);
var tocenter = (delta).normalized * (-dist);
var result = (toline + tocenter) * 1.0f;
//result = Vector3.Lerp(result.normalized, CachedRandom[posIndex], 1.0f - this.Breath.UnitTimeInBreath ) * result.magnitude;
return(result);
}
else
{
model.ParticleFlowRate = 0.6f;
var delta = (pos - spinePos);
var nearestPosOnLine = spinePos;
var r = (pos - nearestPosOnLine);
var distScaler = 5.0f;
var dist = (distScaler / delta.magnitude);
var inpct = Mathf.Min(dist * 6.0f, (distScaler / r.magnitude));
var toline = r.normalized * (-inpct);
var tocenter = (delta).normalized * (-dist);
var result = (toline + tocenter) * 1.0f;
var upways = Mathf.Lerp(0.2f, 1.0f, Mathf.Abs(Vector3.Dot(delta.normalized, Vector3.up)));
result *= upways;
//result = Vector3.Lerp(result.normalized, CachedRandom[posIndex], 1.0f - this.Breath.UnitTimeInBreath ) * result.magnitude;
return(result);
}
}
public override Vector3 CalcVectorField(DynamicFieldModel model, int posIndex, Vector3 pos, out Color primaryColor)
{
Vector3 res = Vector3.zero;
primaryColor = Color.white;
foreach (var ps in this.AllSpans)
{
if (ps.LatestOverallAlpha > 0.0f)
{
if (ps.FlowFieldCache != null)
{
// ready to go
}
else
{
ps.FlowFieldCache = new Vector3[model.CellCount];
for (int c = 0; c < model.CellCount; c++)
{
var cPos = model.FieldsCells.Array [c].Pos;
var cField = Vector3.zero;
for (int i = 1; i < ps.Line.Points.Length; i++)
{
var fm = ps.Line.Points [i - 1];
var to = ps.Line.Points [i];
var fld = DynamicFieldModel.ChakraFieldAlongLineV4(cPos, fm, to, false);
cField += fld;
}
ps.FlowFieldCache [c] = cField;
}
}
res += ps.FlowFieldCache [posIndex] * ps.LatestOverallAlpha;
}
}
return(res);
}
private static Vector4 CalcFlowTangent(DynamicFieldModel model, DynamicFieldModel.DynFieldCell cell)
{
var dir = cell.Direction.normalized;// / model.UnitMagnitude;
var repeatScaler = 6.0f;
return(new Vector4(dir.x, dir.y, dir.z, cell.Direction.magnitude / model.UnitMagnitude));
//var offset = Vector3.Dot (cell.Pos, dir) * repeatScaler;
//return new Vector4 (cell.Direction.magnitude / model.UnitMagnitude, offset, 0, 0);
}
public override Vector3 CalcVectorField(DynamicFieldModel model, int posIndex, Vector3 pos, out Color primaryColor)
{
var cur = this.CurrentChakra;
if (!cur)
{
primaryColor = Color.white;
return(Vector3.zero);
}
primaryColor = cur.ChakraColor;
return(DynamicFieldModel.ChakraFieldV3(pos, cur.transform.position, cur.transform.rotation, cur.ChakraOneWay));
}
public virtual Vector3 CalcVectorField(DynamicFieldModel model, int posIndex, Vector3 pos, out Color primaryColor)
{
primaryColor = Color.yellow; // GetPrimaryColorFromMeridians (); //Color.yellow;
//var spinePos = this.Body.SpineStart.position;// Vector3.Lerp (this.Body.SpineStart.position, this.Body.SpineEnd.position, 0.3f);
var spinePos = this.transform.position;
//return DynamicFieldModel.ChakraFieldV3 (pos, spinePos, Quaternion.identity, false);
model.ParticleFlowRate = 0.5f;
if (true) //this.Breath.BreathIndex % 2 == 0) {
{
model.ParticleFlowRate = 0.5f;
if ((CachedRandom == null) || (CachedRandom.Length != model.CellCount))
{
CachedRandom = new Vector3[model.CellCount];
for (int i = 0; i < model.CellCount; i++)
{
CachedRandom [i] = Random.onUnitSphere;
}
}
var delta = (pos - spinePos);
var nearestPosOnLine = spinePos;
var r = (pos - nearestPosOnLine);
var distScaler = 10.0f;
var dist = (distScaler / delta.magnitude);
var inpct = Mathf.Min(dist * 6.0f, (distScaler / r.magnitude));
var toline = r.normalized * (-inpct);
var tocenter = (delta).normalized * (-dist);
var result = (toline + tocenter) * 1.0f;
if (this.Breath.HeartBeatUnitAlpha < 0.5f)
{
result *= -1.0f;
}
//result = Vector3.Lerp(result.normalized, CachedRandom[posIndex], 1.0f - this.Breath.UnitTimeInBreath ) * result.magnitude;
return(result);
}
}
private void ReCreateFields(IEnumerable<DynamicFieldTemplateDto> dynamicFieldTemplateDtos,
IEnumerable<DynamicFieldDto> existingDynamicFieldDtos)
{
var existingDynamicFields = existingDynamicFieldDtos ?? new List<DynamicFieldDto>();
foreach (var dynamicFieldTemplateDto in dynamicFieldTemplateDtos)
{
var field = new DynamicFieldModel
{
Configuration = dynamicFieldTemplateDto
};
field.CreateValue(value =>
{
field.IsValid = value;
IsSubmitActive = _tempFields.Count(x => x.IsValid) == _tempFields.Count;
});
var existingValue = existingDynamicFields.SingleOrDefault(x => x.Configuration.Code == dynamicFieldTemplateDto.Code);
if (existingValue!=null)
{
field.SetValue(existingValue.GetValue());
field.Id = existingValue.Id;
}
_tempFields.Add(field);
}
}
public virtual Vector3 CalcVectorField(DynamicFieldModel model, int posIndex, Vector3 pos, out Color primaryColor)
{
primaryColor = Color.white;
return(Vector3.zero);
}
public static Mesh GenerateSurfaceVolume <T>(VolumeBuffer <T> vol, Func <T, float> signTest, Vector3 relativeCameraPos, DynamicFieldModel optionalModel = null)
{
int tetCorners = 4;
Dictionary <int, int> ndxToVertex = new Dictionary <int, int> ();
List <int> triangles = new List <int> ();
List <int> quads = new List <int> ();
float[] signes = new float[tetCorners];
List <int> edgesInTetra = new List <int> ();
VolumeHeader h2 = new VolumeHeader(new Int3(2, 2, 2));
foreach (var ndx in vol.AllIndices3())
{
if ((ndx.X != 0) && (ndx.Y != 0) && (ndx.Z != 0))
{
var start = ndx.Add(new Int3(-1, -1, -1));
foreach (var ts in TetrasInCube)
{
int countPos = 0, countNeg = 0;
int signKey = 0;
for (int cornerIndex = 0; cornerIndex < ts.Length; cornerIndex++)
{
var lndx = ts[cornerIndex];
var cur = AddInvertTileOffset3(start, (h2.LinearToCubic(lndx)));
var sv = signTest(vol.Read(cur));
if (sv >= 0.0f)
{
countPos++;
signKey |= (1 << cornerIndex);
}
else
{
countNeg++;
}
signes [cornerIndex] = sv;
}
if ((countPos > 0) && (countNeg > 0))
{
edgesInTetra.Clear();
// we have something in this tetrahedra!
for (int ei = 0; ei < VolumeTetrahedraSurfacer.EdgesInTetra.Length; ei += 2)
{
var ef = VolumeTetrahedraSurfacer.EdgesInTetra [ei + 0];
var et = VolumeTetrahedraSurfacer.EdgesInTetra [ei + 1];
if (((signes [ef]) * (signes [et])) < 0.0f)
{
// we have something on this edge!
var tf = ts[ef];
var tt = ts[et];
var vf = AddInvertTileOffset3(start, h2.LinearToCubic(tf));
var vt = AddInvertTileOffset3(start, h2.LinearToCubic(tt));
int encoded = PackVoxelEdgeIdSorted(vol.Header, vf, vt);
edgesInTetra.Add(encoded);
}
}
int prevVid = -1, prevPrevVid = -1, pppv = -1;
foreach (var ee in edgesInTetra)
{
int vid;
if (ndxToVertex.ContainsKey(ee))
{
vid = ndxToVertex [ee];
}
else
{
vid = ndxToVertex.Count;
ndxToVertex.Add(ee, vid);
}
if (edgesInTetra.Count == 3)
{
triangles.Add(vid);
}
else if (edgesInTetra.Count == 4)
{
quads.Add(vid);
}
else
{
Debug.Assert(false, "Really?? c=" + edgesInTetra.Count);
}
pppv = prevPrevVid;
prevPrevVid = prevVid;
prevVid = vid;
}
}
}
}
}
List <Vector3> vertices = new List <Vector3> ();
List <Vector3> vertexSigns = new List <Vector3> ();
List <Vector4> vertexTangents = null;
if (optionalModel != null)
{
vertexTangents = new List <Vector4> ();
}
Vector3 invScale = new Vector3(1.0f / (vol.Size.X - 1), 1.0f / (vol.Size.Y - 1), 1.0f / (vol.Size.Z - 1));
foreach (var kv in ndxToVertex)
{
// setup vertices from edge data:
var packed = kv.Key;
var vid = kv.Value;
while (vertices.Count <= vid)
{
vertices.Add(Vector3.zero);
vertexSigns.Add(Vector3.zero);;
if (optionalModel != null)
{
vertexTangents.Add(Vector4.zero);
}
}
Int3 a3, b3;
UnpackVoxelEdgeId(vol.Header, packed, out a3, out b3);
var wa = signTest(vol.Read(a3));
var wb = signTest(vol.Read(b3));
var wab = Mathf.Abs(wa) / (Mathf.Abs(wa) + Mathf.Abs(wb));
var pos = Vector3.Lerp(a3.AsVector3(), b3.AsVector3(), wab); //0.5f); // TODO: weight value based on signed root
var upos = new Vector3(pos.x * invScale.x, pos.y * invScale.y, pos.z * invScale.z) - (Vector3.one * 0.5f);
vertices [vid] = upos;
vertexSigns [vid] = (a3.AsVector3() - b3.AsVector3()) * Mathf.Sign(wa - wb);
if (optionalModel != null)
{
var ta = CalcFlowTangent(optionalModel, optionalModel.FieldsCells.Read(a3));
var tb = CalcFlowTangent(optionalModel, optionalModel.FieldsCells.Read(b3));
vertexTangents [vid] = Vector4.Lerp(ta, tb, wab); // ((ta + tb) *0.5f);
}
}
for (int qi = 0; qi < quads.Count; qi += 4)
{
// ensure quad covers whole space (a and b must be furthest from each other):
var a = vertices[quads[qi + 0]];
var b = vertices[quads[qi + 1]];
var c = vertices[quads[qi + 2]];
var d = vertices[quads[qi + 3]];
// add triangle a-b-c:
triangles.Add(quads[qi + 0]);
triangles.Add(quads[qi + 1]);
triangles.Add(quads[qi + 2]);
triangles.Add(quads[qi + 1]);
triangles.Add(quads[qi + 3]);
triangles.Add(quads[qi + 2]);
}
var trisToSort = new List <SortTri> ();
for (int i = 0; i < triangles.Count; i += 3)
{
// ensure triangle is oriented correctly:
var a = vertices[triangles[i + 0]];
var b = vertices[triangles[i + 1]];
var c = vertices[triangles[i + 2]];
var n = Vector3.Cross(b - a, c - b);
if (Vector3.Dot(vertexSigns [triangles [i + 0]], n) >= 0.0f)
{
SwapListValues(triangles, i + 1, i + 2);
}
// add triangle to list
SortTri tri;
tri.I0 = triangles [i + 0];
tri.I1 = triangles [i + 1];
tri.I2 = triangles [i + 2];
tri.DistFromCam = (relativeCameraPos - ((a + b + c) * (1.0f / 3.0f))).magnitude;
trisToSort.Add(tri);
}
// sort the triangles:
if (true)
{
trisToSort.Sort((a, b) => - (a.DistFromCam.CompareTo(b.DistFromCam)));
triangles.Clear();
foreach (var t in trisToSort)
{
triangles.Add(t.I0);
triangles.Add(t.I1);
triangles.Add(t.I2);
}
}
Mesh result = new Mesh();
//Debug.Log ("Meshing info: verts=" + vertices.Count + " tris=" + triangles.Count);
result.SetVertices(vertices);
if (optionalModel != null)
{
result.SetTangents(vertexTangents);
}
result.triangles = (triangles.ToArray());
result.RecalculateNormals();
return(result);
}
