private FEMTriangleFunction(ParticleModel pm, int i0, int i1, int i2, float area, float youngsModulusX,
float youngsModulusY, float youngsModulusShear, float poissonRatioXY, float poissonRatioYX, Matrix4x4 invRestMat)
{
this.pm = pm;
this.i0 = i0;
this.i1 = i1;
this.i2 = i2;
particles = new int[] { i0, i1, i2 };
this.youngsModulusX = youngsModulusX;
this.youngsModulusY = youngsModulusY;
this.youngsModulusShear = youngsModulusShear;
this.poissonRatioXY = poissonRatioXY;
this.poissonRatioYX = poissonRatioYX;
this.area = area;
this.invRestMat = invRestMat;
}
private ParticleModel CreateParticleModel()
{
ParticleModel currentParticle;
if (AllParticlesActive())
{
GameObject particleGameobject = Instantiate(particle);
currentParticle = new ParticleModel(Random.onUnitSphere * velocity, particleGameobject, particles.Count);
particles.Add(currentParticle);
}
else
{
currentParticle = GetHiddenParticle();
}
currentParticle.particle.transform.position = transform.position;
currentParticle.velocity = Random.onUnitSphere * velocity;
currentParticle.particle.SetActive(true);
return(currentParticle);
}
private void SpawnEntityParticles(int count)
{
for (int i = 0; i < count; i++)
{
ParticleEntity p;
AddChild(p = new Graphics.ParticleEntity
{
MainGraphic = (MetaModel)ParticleModel.Clone(),
VisibilityLocalBounding = Vector3.Zero,
TimeElapsed = 0.0f,
Direction = Direction,
Acceleration = Acceleration,
InitialTranslation = ParticleStay ? CombinedWorldMatrix : Matrix.Identity,
OrientationRelation = ParticleStay ? OrientationRelation.Absolute : OrientationRelation.Relative,
});
p.RandomNumbers = new float[] { (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(),
(float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble() };
((MetaModel)p.MainGraphic).Opacity = 0;
}
}
protected override void DoInitialize()
{
{
IBufferable model = new ParticleModel();
var shaderCodes = new ShaderCode[2];
shaderCodes[0] = new ShaderCode(File.ReadAllText(@"shaders\ParticleSimulatorRenderer\particleSimulator.vert"), ShaderType.VertexShader);
shaderCodes[1] = new ShaderCode(File.ReadAllText(@"shaders\ParticleSimulatorRenderer\particleSimulator.frag"), ShaderType.FragmentShader);
var map = new AttributeMap();
map.Add("position", ParticleModel.strPosition);
var particleRenderer = new ParticleRenderer(model, shaderCodes, map, new DepthTestState(false), new BlendState(BlendingSourceFactor.One, BlendingDestinationFactor.One));
particleRenderer.Initialize();
this.particleRenderer = particleRenderer;
}
{
var particleComputeRenderer = new ParticleComputeRenderer(
this.particleRenderer.PositionBuffer,
this.particleRenderer.VelocityBuffer);
particleComputeRenderer.Initialize();
this.particleComputeRenderer = particleComputeRenderer;
}
}
private void SpawnGraphicParticles(int count)
{
for (int i = 0; i < count; i++)
{
Particle p;
MetaModel m = (MetaModel)ParticleModel.Clone();
particles.Add(p = new Particle
{
MainGraphic = m,
Acceleration = Acceleration,
Direction = Direction,
TimeElapsed = 0,
InitialTranslation = ParticleStay ? CombinedWorldMatrix : Matrix.Identity,
InitialModelMatrix = m.World
});
m.OrientationRelation = ModelOrientationRelation.Absolute;
m.Opacity = 0;
p.RandomNumbers = new float[] { (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(),
(float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble() };
AddGraphic(m);
}
}
public static DistanceFunction create(ParticleModel pm, int i0, int i1)
{
if (i0 == i1)
{
throw new Exception("Can't define Distance function on same particle");
}
Vector3 v0 = pm.positions[i0];
Vector3 v1 = pm.positions[i1];
float invM0 = pm.inverseMasses[i0];
float invM1 = pm.inverseMasses[i1];
float distance = Vector3.Magnitude(new Vector3(v0.x - v1.x, v0.y - v1.y, v0.z - v1.z));
if (i0 < i1)
{
return(new DistanceFunction(i0, i1, invM0, invM1, distance));
}
else
{
return(new DistanceFunction(i1, i0, invM1, invM0, distance));
}
}
/// <summary>Create FEMFunction for a triangle (finite element method)</summary>
/// <param name="pm">The actual ParticleModel</param>
/// <param name="i0">Index of 0 particle of triangle</param>
/// <param name="i1">Index of 1 particle of triangle</param>
/// <param name="i2">Index of 2 particle of triangle</param>
public static FEMTriangleFunction create(ParticleModel pm, int i0, int i1, int i2, float youngsModulusX,
float youngsModulusY, float youngsModulusShear, float poissonRatioXY, float poissonRatioYX)
{
Vector3 p0 = pm.positions[i0];
Vector3 p1 = pm.positions[i1];
Vector3 p2 = pm.positions[i2];
Vector3 normal = Vector3.Cross(p1 - p0, p2 - p0);
Vector3 axis01 = (p2 - p0).normalized;
Vector3 axis02 = Vector3.Cross(normal, axis01).normalized;
// Transform vectors to new cooridinate system
Vector2 t0 = new Vector2(Vector3.Dot(p0, axis01), Vector3.Dot(p0, axis02));
Vector2 t1 = new Vector2(Vector3.Dot(p1, axis01), Vector3.Dot(p1, axis02));
Vector2 t2 = new Vector2(Vector3.Dot(p2, axis01), Vector3.Dot(p2, axis02));
Matrix4x4 m = new Matrix4x4();
m[0, 0] = t0.y - t2.y;
m[1, 0] = t0.x - t2.x;
m[0, 1] = t1.y - t2.y;
m[1, 1] = t1.x - t2.x;
m[2, 2] = 1;
m[3, 3] = 1;
float det = m.determinant;
if (Math.Abs(det) > EPS)
{
Matrix4x4 invRestMat = m.inverse;
// Calculate area
float area = Math.Abs(normal.magnitude) * 0.5f;
Debug.Log("Triangle (" + p0 + ", " + p1 + ", " + p2 + ")");
Debug.Log("Has area " + area + "\n");
return(new FEMTriangleFunction(pm, i0, i1, i2, area, youngsModulusX, youngsModulusY, youngsModulusShear, poissonRatioXY, poissonRatioYX, invRestMat));
}
// determinant ~= 0
return(null);
}
public ParticleController(ParticleView particleView, ParticleModel particleModel)
{
ParticleView = particleView;
ParticleModel = particleModel;
ParticleView.ControllerChannelInitialisation(this);
}
public JsonResult List()
{
var mongo = new MongoHelper();
// 获取所有类别
var filter = Builders <BsonDocument> .Filter.Eq("Type", "Particle");
var categories = mongo.FindMany(Constant.CategoryCollectionName, filter).ToList();
var docs = new List <BsonDocument>();
if (ConfigHelper.EnableAuthority)
{
var user = UserHelper.GetCurrentUser();
if (user != null)
{
var filter1 = Builders <BsonDocument> .Filter.Eq("UserID", user.ID);
if (user.Name == "Administrator")
{
var filter2 = Builders <BsonDocument> .Filter.Exists("UserID");
var filter3 = Builders <BsonDocument> .Filter.Not(filter2);
filter1 = Builders <BsonDocument> .Filter.Or(filter1, filter3);
}
docs = mongo.FindMany(Constant.ParticleCollectionName, filter1).ToList();
}
}
else
{
docs = mongo.FindAll(Constant.ParticleCollectionName).ToList();
}
var list = new List <ParticleModel>();
foreach (var i in docs)
{
var categoryID = "";
var categoryName = "";
if (i.Contains("Category") && !i["Category"].IsBsonNull && !string.IsNullOrEmpty(i["Category"].ToString()))
{
var doc = categories.Where(n => n["_id"].ToString() == i["Category"].ToString()).FirstOrDefault();
if (doc != null)
{
categoryID = doc["_id"].ToString();
categoryName = doc["Name"].ToString();
}
}
var info = new ParticleModel
{
ID = i["ID"].AsObjectId.ToString(),
Name = i["Name"].AsString,
CategoryID = categoryID,
CategoryName = categoryName,
TotalPinYin = i["TotalPinYin"].ToString(),
FirstPinYin = i["FirstPinYin"].ToString(),
CreateTime = i["CreateTime"].ToUniversalTime(),
UpdateTime = i["UpdateTime"].ToUniversalTime(),
Thumbnail = i.Contains("Thumbnail") && !i["Thumbnail"].IsBsonNull ? i["Thumbnail"].ToString() : null
};
list.Add(info);
}
list = list.OrderByDescending(n => n.UpdateTime).ToList();
return(Json(new
{
Code = 200,
Msg = "Get Successfully!",
Data = list
}));
}
public Physics(ParticleModel pm)
{
UpdateForces(pm);
}
public static CommandContext Create(CommandContext parent, GameCache cache, CachedTag tag, ParticleModel particleModel)
{
var groupName = cache.StringTable.GetString(tag.Group.Name);
var context = new CommandContext(parent,
string.Format("{0:X8}.{1}", tag.Index, groupName));
Populate(context, cache, tag, particleModel);
return(context);
}
public static void Populate(CommandContext context, GameCache cache, CachedTag tag, ParticleModel particleModel)
{
context.AddCommand(new DumpRenderGeometryCommand(cache, particleModel.Geometry, "particle"));
}
public ParticleVisualisation(ParticleModel model, ClothSimulation settings) : this(model)
{
// Could store extra settings from the Unity GUI via the ClothSimulation class
}
public static CommandContext Create(CommandContext parent, HaloOnlineCacheContext info, CachedTagInstance tag, ParticleModel particleModel)
{
var groupName = info.GetString(tag.Group.Name);
var context = new CommandContext(parent,
string.Format("{0:X8}.{1}", tag.Index, groupName));
Populate(context, info, tag, particleModel);
return(context);
}
public static void Populate(CommandContext context, HaloOnlineCacheContext cacheContext, CachedTagInstance tag, ParticleModel particleModel)
{
context.AddCommand(new DumpRenderGeometryCommand(cacheContext, particleModel.Geometry, "particle"));
}
public TriangularModelMesh(ParticleModel model, ClothSimulation settings)
{
this.model = model;
GameObject meshGameObject = new GameObject("TriangularModelMesh");
MeshFilter meshFilter = meshGameObject.AddComponent <MeshFilter>();
this.mesh = meshFilter.mesh;
MeshRenderer meshRenderer = meshGameObject.AddComponent <MeshRenderer>();
Material defaultMaterial = new Material(Shader.Find("VR/SpatialMapping/Wireframe"));
meshRenderer.sharedMaterial = defaultMaterial;
this.mesh.Clear();
int subdivisions = 6;
int modelWH = this.model.getWidthHeight();
points = new Vector3[(int)Math.Pow((modelWH + (modelWH - 1)) * subdivisions, 2)];
Array.Copy(model.positions, points, model.positions.Length);
int index = model.positions.Length;
List <int> triangles = new List <int>();
List <SubLine> SubLines = new List <SubLine>();
// horizontal
for (int j = 0; j < modelWH; j++)
{
for (int i = 0; i < modelWH - 1; i++)
{
int left = j * modelWH + i;
int right = left + 1;
SubLine subLine = bezier > 0 ? new BezierSubline(left, right, index, index + subdivisions) : new SubLine(left, right, index, index + subdivisions);
index = index + subdivisions;
if (i > 0)
{
SubLine prev = SubLines[(modelWH - 1) * j + (i - 1)];
subLine.link(ref prev);
}
SubLines.Add(subLine);
}
}
// vertical
for (int j = 0; j < modelWH - 1; j++)
{
for (int i = 0; i < modelWH; i++)
{
int bottom = j * modelWH + i;
int top = bottom + modelWH;
SubLine subLine = bezier > 0 ? new BezierSubline(bottom, top, index, index + subdivisions) : new SubLine(bottom, top, index, index + subdivisions);
index = index + subdivisions;
if (j > 0)
{
SubLine prev = SubLines[modelWH * (modelWH - 1) + modelWH * (j - 1) + i];
subLine.link(ref prev);
}
SubLines.Add(subLine);
}
}
List <SubGrid> SubGrids = new List <SubGrid>();
for (int j = 0; j < modelWH - 1; j++)
{
for (int i = 0; i < modelWH - 1; i++)
{
int a = modelWH * j + i;
int b = a + 1;
int c = a + modelWH;
int d = c + 1;
SubLine bottom = SubLines[(modelWH - 1) * j + i];
SubLine top = SubLines[(modelWH - 1) * (j + 1) + i];
SubLine left = SubLines[(modelWH - 1) * modelWH + modelWH * j + i];
SubLine right = SubLines[(modelWH - 1) * modelWH + modelWH * j + i + 1];
SubGrid grid = new SubGrid(ref bottom, ref right, ref left, ref top, index, subdivisions, subdivisions);
index += subdivisions * subdivisions;
if (i > 0)
{
SubGrid prev = SubGrids[(modelWH - 1) * j + i - 1];
grid.linkHorizontal(ref prev);
}
if (j > 0)
{
SubGrid prev = SubGrids[(modelWH - 1) * (j - 1) + i];
grid.linkVertical(ref prev);
}
SubGrids.Add(grid);
// Add triangles for the grid
triangles.AddRange(grid.GenTriangles());
}
}
List <int> included = new List <int>(new HashSet <int>(triangles));
// Calculate the uvs
Vector2[] uvs = new Vector2[points.Length]; // uv maps texture to points
float du = 1.0f / modelWH;
float dv = 1.0f / modelWH;
for (int u = 0; u < modelWH; u++)
{
for (int v = 0; v < modelWH; v++)
{
uvs[u * modelWH + v] = new Vector2(u * du, v * dv);
}
}
if (showGridPoints)
{
gridPointsObjectManager = new MonoManager <SceneObject>();
GameObject unitPrefab = new GameObject();
unitPrefab.AddComponent <SceneObject>();
unitPrefab.AddComponent <MeshFilter>();
unitPrefab.AddComponent <MeshRenderer>();
gridPointsObjectManager.OverrideGameObject(unitPrefab);
Mesh mesh = Assets.Scripts.Tools.Geometry.PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Sphere);
Material material = new Material(Shader.Find("Transparent/Diffuse"));
material.color = Color.yellow;
for (int i = model.positions.Length; i < points.Length; i++)
{
var newObj = gridPointsObjectManager.New();
newObj.Init(mesh, material);
newObj.transform.position = points[i];
}
}
SubLines.ForEach(sl => {
sl.setUV(ref uvs);
});
this.subLines = SubLines.ToArray();
SubGrids.ForEach(sl => {
sl.setUV(ref uvs);
});
this.subGrids = SubGrids.ToArray();
SubLines.ForEach(sl => {
sl.setPoints(ref points);
});
SubGrids.ForEach(sl => {
sl.setPoints(ref points);
});
// Set unit mesh
this.mesh.vertices = points;
this.mesh.uv = uvs;
this.mesh.triangles = addBothSide(triangles.ToArray());
}
