public override void Read(AssetReader reader)
{
base.Read(reader);
RenderMode = IsModeShort(reader.Version) ? (ParticleSystemRenderMode)reader.ReadUInt16() : (ParticleSystemRenderMode)reader.ReadInt32();
if (IsSortModeFirst(reader.Version))
{
SortMode = (ParticleSystemSortMode)reader.ReadUInt16();
}
if (IsReadMinParticleSize(reader.Version))
{
MinParticleSize = reader.ReadSingle();
}
MaxParticleSize = reader.ReadSingle();
CameraVelocityScale = reader.ReadSingle();
VelocityScale = reader.ReadSingle();
LengthScale = reader.ReadSingle();
SortingFudge = reader.ReadSingle();
if (IsReadNormalDirection(reader.Version))
{
NormalDirection = reader.ReadSingle();
}
if (IsReadShadowBias(reader.Version))
{
ShadowBias = reader.ReadSingle();
}
if (!IsSortModeFirst(reader.Version))
{
SortMode = (ParticleSystemSortMode)reader.ReadInt32();
}
if (IsReadRenderAlignment(reader.Version))
{
RenderAlignment = (ParticleSystemRenderSpace)reader.ReadInt32();
Pivot.Read(reader);
}
else
{
RenderAlignment = RenderMode == ParticleSystemRenderMode.Mesh ? ParticleSystemRenderSpace.Local : ParticleSystemRenderSpace.View;
}
if (IsReadFlip(reader.Version))
{
Flip.Read(reader);
}
if (IsReadUseCustomVertexStreams(reader.Version))
{
UseCustomVertexStreams = reader.ReadBoolean();
if (IsReadEnableGPUInstancing(reader.Version))
{
EnableGPUInstancing = reader.ReadBoolean();
}
if (IsReadApplyActiveColorSpace(reader.Version))
{
ApplyActiveColorSpace = reader.ReadBoolean();
}
if (IsReadAllowRoll(reader.Version))
{
AllowRoll = reader.ReadBoolean();
}
reader.AlignStream(AlignType.Align4);
}
if (IsReadVertexStreamMask(reader.Version))
{
int vertexStreamMask = reader.ReadInt32();
List <byte> vertexStreams = new List <byte>(8);
for (byte i = 0; i < 8; i++)
{
if ((vertexStreamMask & (1 << i)) != 0)
{
vertexStreams.Add(i);
}
}
m_vertexStreams = vertexStreams.ToArray();
}
if (IsReadVertexStreams(reader.Version))
{
m_vertexStreams = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
Mesh.Read(reader);
if (IsReadMeshes(reader.Version))
{
Mesh1.Read(reader);
Mesh2.Read(reader);
Mesh3.Read(reader);
}
if (IsReadMaskInteraction(reader.Version))
{
MaskInteraction = (SpriteMaskInteraction)reader.ReadInt32();
}
}
public void Membrane_Triangle_InPlaneSpringOnOneSide()
{
var k3d = new Toolkit();
var logger = new MessageLogger();
double L = 1.0;
var points = new List <Point3> {
new Point3(0, 0.5 * L, 0), new Point3(0, -0.5 * L, 0), new Point3(L, 0, 0)
};
var mesh = new Mesh3();
foreach (var point in points)
{
mesh.AddVertex(point);
}
mesh.AddFace(new Face3(0, 1, 2));
var material = k3d.Material.IsotropicMaterial("", "", 200000, 100000, 100000, 0, 0, 0, 0, 0);
var crosec = k3d.CroSec.ShellConst(0.01, 0, material);
var shells = k3d.Part.MeshToShell(new List <Mesh3> {
mesh
}, null, new List <CroSec> {
crosec
}, false, logger, out var out_nodes);
// create supports
var supportConditions_1 = new List <bool>()
{
true, true, true, true, true, true
};
var supports = new List <Support>
{
k3d.Support.Support(points[0], supportConditions_1),
k3d.Support.Support(points[1], supportConditions_1),
};
// create a Point-load
double fx = 100.0;
var loads = new List <Load>
{
k3d.Load.PointLoad(points[2], new Vector3(fx, 0, 0), new Vector3()),
};
double cx = 2.0;
var joints = new List <Joint>()
{
new JointLine(new List <string> {
""
},
new PolyLine3(new List <Point3> {
points[1], points[0]
}),
-Vector3.XAxis, Vector3.ZAxis, Math.PI * 0.5, new double?[] { null, cx })
};
// create the model
var model = k3d.Model.AssembleModel(shells, supports, loads,
out var info, out var mass, out var cog, out var message, out var warning, joints);
// var model = k3d.Model.AssembleModel(shells, supports, loads,
// out var info, out var mass, out var cog, out var message, out var warning);
ThIAnalyze.solve(model, out var outMaxDisp, out var outG, out var outComp, out var warning_msg, out model);
var h = (model.elems[0].crosec as CroSec_Shell).getHeight();
var E = model.elems[0].crosec.material.E();
// var c_inv_tot = 2 * L / (E * h);
var c_inv_tot = 2 * L / (E * h) + 1 / cx / L;
var dispTarget = Math.Abs(fx) / L * c_inv_tot;
var dispCalc = outMaxDisp[0];
Assert.AreEqual(dispCalc, dispTarget, 1);
}
public void TSection_2Elems()
{
var k3d = new Toolkit();
var logger = new MessageLogger();
double Lx = 1.0;
double Ly = 2.0;
double Lz = 3.0;
var points = new List <Point3> {
new Point3(0, Ly, 0), new Point3(0, 0, 0),
new Point3(Lx, 0, 0),
new Point3(0, 0, Lz)
};
var mesh = new Mesh3();
foreach (var point in points)
{
mesh.AddVertex(point);
}
mesh.AddFace(new Face3(0, 1, 2));
mesh.AddFace(new Face3(1, 2, 3));
var material = k3d.Material.IsotropicMaterial("", "", 200000, 100000, 100000, 0, 0, 0, 0, 0);
var crosec = k3d.CroSec.ShellConst(0.1, 0, material);
var shells = k3d.Part.MeshToShell(
new List <Mesh3> {
mesh
}, null, new List <CroSec> {
crosec
}, true, logger, out var nodes,
0.005, null, points);
// create supports
var supportConditions_1 = new List <bool>()
{
true, true, true, true, true, true
};
var supports = new List <Support>
{
k3d.Support.Support(points[0], supportConditions_1),
k3d.Support.Support(points[1], supportConditions_1),
k3d.Support.Support(points[2], supportConditions_1)
};
// create a Point-load
double Fx = 100.0;
var loads = new List <Load>
{
k3d.Load.PointLoad(points[3], new Vector3(Fx, 0, 0), new Vector3()),
};
double c = 0.1;
var joints = new List <Joint>()
{
new JointLine(new List <string> {
""
},
new PolyLine3(new List <Point3> {
points[1], points[2]
}),
-Vector3.ZAxis, null, Math.PI * 0.25, new double?[] { c })
};
// create the model
var model = k3d.Model.AssembleModel(shells, supports, loads,
out var info, out var mass, out var cog, out var message, out var warning, joints);
// var model = k3d.Model.AssembleModel(shells, supports, loads,
// out var info, out var mass, out var cog, out var message, out var warning, joints, points);
// var model = k3d.Model.AssembleModel(shells, supports, loads,
// out var info, out var mass, out var cog, out var message, out var warning);
ThIAnalyze.solve(model, out var outMaxDisp, out var outG, out var outComp, out var warning_msg, out model);
var dispTarget = Fx / Lx / c;
var dispCalc = outMaxDisp[0];
Assert.AreEqual(dispCalc, dispTarget, 1);
}
public void DeformationTestIsotropicShellInPlane()
{
var nFaces = 1;
var length = 1.0;
var xIncMesh = length / nFaces;
var limit_dist = xIncMesh / 100.0;
var y0 = 0.0;
var y1 = 1.0;
// create the mesh
var mesh = new Mesh3((nFaces + 1) * 2, nFaces);
mesh.AddVertex(new Point3(0, y0, 0));
mesh.AddVertex(new Point3(0, y1, 0));
for (var faceInd = 0; faceInd < nFaces; ++faceInd)
{
mesh.AddVertex(new Point3((faceInd + 1) * xIncMesh, y0, 0));
mesh.AddVertex(new Point3((faceInd + 1) * xIncMesh, y1, 0));
var nV = mesh.Vertices.Count;
mesh.AddFace(nV - 4, nV - 3, nV - 1, nV - 2);
}
// create a shell
MeshToShell.solve(new List <Point3>(), new List <Mesh3>()
{
mesh
}, limit_dist, new List <string>(), new List <Color>(), new List <CroSec>(), true,
out List <Point3> outPoints, out List <BuilderShell> outBuilderShells, out MessageLogger outLogger);
// create two supports
var support1 = new Support(new Point3(0, y0, 0), new List <bool>()
{
true, true, true, true, true, true
}, Plane3.Default);
var support2 = new Support(new Point3(0, y1, 0), new List <bool>()
{
true, false, true, true, true, true
}, Plane3.Default);
// create two point loads
var pl1 = new PointLoad(mesh.Vertices.Count - 2, new Vector3(25, 0, 0), new Vector3(), false);
var pl2 = new PointLoad(mesh.Vertices.Count - 1, new Vector3(25, 0, 0), new Vector3(), false);
// assemble the model
var modelBuilder = new ModelBuilder(limit_dist);
var model = modelBuilder.build(new List <Point3>(), new List <FemMaterial>(), new List <CroSec>(),
new List <Support>()
{
support1, support2
}, new List <Load>()
{
pl1, pl2
}, outBuilderShells, new List <ElemSet>(),
new List <Joint>(), new MessageLogger()
);
ThIAnalyze.solve(model, out var outMaxDisp, out var outG, out var outComp, out var warning, out model);
Assert.AreEqual(outMaxDisp[0], 2.4858889456113236E-05, 1E-5);
}
/// <summary>
/// Performs the specified operation on the provided meshes.
/// </summary>
/// <param name="first">The first mesh</param>
/// <param name="second">The second mesh</param>
/// <param name="operation">The mesh opration to perform on the two meshes</param>
/// <returns>A triangular mesh resulting from performing the specified operation. If the resulting mesh is empty, will return null.</returns>
public static Mesh3 PerformCSG(Mesh3 first, Mesh3 second, CSGOperations operation)
{
Mesh3 finalResult = null;
unsafe
{
InteropMesh a = new InteropMesh();
InteropMesh b = new InteropMesh();
Vector3[] aTransformed = first.GetTransformedVertices();
Vector3[] bTransformed = second.GetTransformedVertices();
InteropMesh *result;
fixed(Vector3 *aVerts = &aTransformed[0], bVerts = &bTransformed[0])
{
fixed(int *aTris = &first.TriangleIndices[0], bTris = &second.TriangleIndices[0])
{
a.vertsArrayLength = first.Vertices.Length * 3;
a.triArrayLength = first.TriangleIndices.Length;
a.vertices = (double *)aVerts;
a.triangleIndices = aTris;
b.vertsArrayLength = second.Vertices.Length * 3;
b.triArrayLength = second.TriangleIndices.Length;
b.vertices = (double *)bVerts;
b.triangleIndices = bTris;
try
{
result = performCSG(ref a, ref b, operation);
}
catch (SEHException ex)
{
ArgumentException e = new ArgumentException("Carve has thrown an error. Possible reason is corrupt or self-intersecting meshes", ex);
throw e;
}
}
}
if (result->vertsArrayLength == 0)
{
freeMesh(result);
return(null);
}
Vector3[] vertices = new Vector3[result->vertsArrayLength / 3];
int[] triangleIndices = new int[result->triArrayLength];
// Copy the results back in parallel
Parallel.For(0, vertices.Length, i =>
{
vertices[i] = new Vector3(result->vertices[3 * i], result->vertices[3 * i + 1], result->vertices[3 * i + 2]);
});
Parallel.For(0, triangleIndices.Length, i =>
{
triangleIndices[i] = result->triangleIndices[i];
});
// If none of the vertices had colors, return whatever we have
if (!first.HasColours && !second.HasColours)
{
finalResult = new Mesh3(vertices, triangleIndices);
freeMesh(result);
}
else // Assign colors to the resulting mesh
{
uint[] colors = new uint[vertices.Length];
uint grayCode = 4286611584; // The uint value of the color gray (representing no color)
// Assign the default gray to all vertices
Parallel.For(0, colors.Length, i =>
{
colors[i] = grayCode;
});
#region Worst practices of parallel coding
/**
* The procedure for color matching is creating a map of (vertex=>color) and then
* comparing all vertices of the resulting mesh (in parallel) with this map and
* assigning colors as necessary
*/
if (first.HasColours)
{
ConcurrentDictionary <Vector3, uint> firstMap = new ConcurrentDictionary <Vector3, uint>();
// Create vertex to color map
Parallel.For(0, aTransformed.Length, i =>
{
firstMap[aTransformed[i]] = first.VertexColours[i];
});
// Assign colors
Parallel.For(0, vertices.Length, i =>
{
if (firstMap.ContainsKey(vertices[i]))
{
colors[i] = firstMap[vertices[i]];
}
});
}
if (second.HasColours)
{
ConcurrentDictionary <Vector3, uint> secondMap = new ConcurrentDictionary <Vector3, uint>();
Parallel.For(0, bTransformed.Length, i =>
{
secondMap[bTransformed[i]] = second.VertexColours[i];
});
Parallel.For(0, vertices.Length, i =>
{
if (secondMap.ContainsKey(vertices[i]))
{
colors[i] = secondMap[vertices[i]];
}
});
}
#endregion
finalResult = new Mesh3(vertices, triangleIndices, colors);
}
} // end-unsafe
Matrix3 transform = first.Transform.Invert();
finalResult = new Mesh3(finalResult.Vertices.Select(x => transform.Transform(x - first.Position)).ToArray(),
finalResult.TriangleIndices, finalResult.VertexColours);
finalResult.Position = first.Position;
finalResult.Transform = first.Transform;
return(finalResult);
}
static void Main(string[] args)
{
Window window = new Window(1024, 768, "3D Orthographic Test");
window.SetDefaultOrthographicSize(200);
window.SetZNearZFar(-300, 300);
window.EnableDepthTest();
window.SetClearColor(0f, 1f, 1f, 1f);
Texture backgroundTexture = new Texture("Assets/airadventurelevel1.png");
Sprite background = new Sprite(window.OrthoWidth, window.OrthoHeight);
Mesh3 mesh3 = new Mesh3();
Mesh3 suzanne = ObjLoader.Load("Assets/suzanne.obj", new Vector3(50, -50, 50))[0];
suzanne.Position3 = new Vector3(75, 100, 100);
suzanne.vc = new float[suzanne.v.Length / 3 * 4];
int vcPos = 0;
for (int i = 0; i < suzanne.v.Length; i += 3)
{
suzanne.vc[vcPos++] = suzanne.v[i] / 50f;
suzanne.vc[vcPos++] = suzanne.v[i + 1] / -50f;
suzanne.vc[vcPos++] = suzanne.v[i + 2] / 50f;
suzanne.vc[vcPos++] = 0.5f;
}
suzanne.UpdateVertexColor();
Mesh3 stormTrooper = ObjLoader.Load("Assets/Stormtrooper.obj", new Vector3(50, -50, 50))[0];
stormTrooper.Position3 = new Vector3(200, 200, 100);
Texture texture = new Texture("Assets/Stormtrooper.png");
texture.SetRepeatX();
texture.SetRepeatY();
mesh3.v = new float[]
{
// front face
0, 0, 0,
100, 0, 0,
0, 100, 0,
100, 0, 0,
100, 100, 0,
0, 100, 0,
// back face
0, 0, -100,
100, 0, -100,
0, 100, -100,
100, 0, -100,
100, 100, -100,
0, 100, -100,
// bottom face
0, 100, 0,
0, 100, -100,
100, 100, 0,
0, 100, -100,
100, 100, -100,
100, 100, 0,
// right face
100, 0, 0,
100, 0, -100,
100, 100, 0,
100, 0, -100,
100, 100, -100,
100, 100, 0,
// left face
0, 0, 0,
0, 0, -100,
0, 100, 0,
0, 0, -100,
0, 100, -100,
0, 100, 0,
// top face
0, 0, 0,
0, 0, -100,
100, 0, 0,
0, 0, -100,
100, 0, -100,
100, 0, 0,
};
mesh3.UpdateVertex();
mesh3.Pivot3 = new Vector3(50, 50, -50);
mesh3.Position3 = new Vector3(130, 130, 100);
mesh3.Scale3 = new Vector3(0.5f, 0.5f, 0.5f);
while (window.opened)
{
if (window.GetKey(KeyCode.Esc))
{
break;
}
if (window.GetKey(KeyCode.Up))
{
mesh3.EulerRotation3 += new Vector3(-20 * window.deltaTime, 0, 0);
suzanne.EulerRotation3 += new Vector3(0, -30 * window.deltaTime, 0);
stormTrooper.EulerRotation3 += new Vector3(0, 30 * window.deltaTime, 0);
}
mesh3.Position3 = new Vector3(130, 130, 100);
mesh3.Scale3 = new Vector3(0.5f, 0.5f, 0.5f);
mesh3.EulerRotation3 += new Vector3(0, -10 * window.deltaTime, 0);
background.DrawTexture(backgroundTexture);
stormTrooper.DrawTexture(texture);
mesh3.DrawWireframe(1f, 0f, 0f, 1f);
window.CullBackFaces();
suzanne.Draw();
window.DisableCullFaces();
window.Update();
}
}
static void Main(string[] args)
{
Window window = new Window(1024, 768, "Aiv.Fast3D Perspective Test", false, 24, 0);
window.SetDefaultOrthographicSize(10);
//Window window = new Window("Aiv.Fast3D Perspective Test", 24, 4);
window.EnableDepthTest();
//window.CullBackFaces();
window.SetCursor(false);
PerspectiveCamera camera = new PerspectiveCamera(new Vector3(0, 6, 30), new Vector3(-10, 180, 0), 60, 0.01f, 1000);
Texture crate = new Texture("Assets/crate.jpg");
Texture floorTexture = new Texture("Assets/floor.jpg");
floorTexture.SetRepeatX();
floorTexture.SetRepeatY();
Texture stormTrooperTexture = new Texture("Assets/Stormtrooper.png");
stormTrooperTexture.SetRepeatX();
stormTrooperTexture.SetRepeatY();
Cube cube = new Cube();
Cube floor = new Cube();
floor.Scale3 = new Vector3(150, 50f, 150);
floor.Position3 = new Vector3(0, -25, 0);
// tiling texture
for (int i = 0; i < floor.uv.Length; i++)
{
floor.uv[i] *= 10;
}
floor.UpdateUV();
Mesh3 stormTrooper = ObjLoader.Load("Assets/Stormtrooper.obj", Vector3.One)[0];
//stormTrooper.RegenerateNormals();
Pyramid pyramid = new Pyramid();
Texture logoAiv = new Texture("Assets/LogoAIV.png");
Sprite logo = new Sprite(1 * logoAiv.Ratio, 1);
Camera hudCamera = new Camera();
logo.Camera = hudCamera;
float lightRotation = -30;
DepthTexture shadowTexture = new DepthTexture(4096, 4096, 24);
Sprite shadow = new Sprite(5, 5);
shadow.Camera = hudCamera;
float shadow_left = -30;
float shadow_right = 30;
float shadow_bottom = -30;
float shadow_top = 30;
float shadow_near = -30;
float shadow_far = 30;
DirectionalLight directionalLight = new DirectionalLight(Utils.EulerRotationToDirection(new Vector3(lightRotation, 180, 0)));
directionalLight.SetShadowProjection(shadow_left, shadow_right, shadow_bottom, shadow_top, shadow_near, shadow_far);
//directionalLight.Color = new Vector3(0.5f, 1, 0.5f);
float crateRotation = 0;
Mesh3[] botMesh = FbxLoader.Load("Assets/running.fbx", new Vector3(0.02f, 0.02f, 0.02f));
SkeletalAnimation[] animations = FbxLoader.LoadAnimations("Assets/running.fbx", new Vector3(0.02f, 0.02f, 0.02f));
int numFrames = 0;
Mesh3 movingTrooper = ObjLoader.Load("Assets/Stormtrooper.obj", Vector3.One)[0];
movingTrooper.Position3 = new Vector3(0, 0, 2);
foreach (SkeletalAnimation animation in animations)
{
Console.WriteLine(animation.Name);
foreach (string subject in animation.KeyFrames.Keys)
{
Console.WriteLine(subject);
int currentFrames = 0;
foreach (SkeletalAnimation.KeyFrame frame in animation.KeyFrames[subject])
{
Console.WriteLine(frame.Time + " " + frame.Position + " " + frame.Rotation + " " + frame.Scale);
currentFrames++;
}
if (currentFrames > numFrames)
{
numFrames = currentFrames;
}
}
}
float neckRotation = 0;
int animationIndex = 0;
float animationTimer = 1f / animations[0].Fps;
movingTrooper.SetParent(cube);
Mesh3[] tank = ObjLoader.Load("Assets/T34.obj", Vector3.One);
Texture tankDiffuse = new Texture("Assets/T-34.png");
Texture tankSpecular = new Texture("Assets/T-34_S.png");
//window.AddPostProcessingEffect(new DepthViewer());
window.AddPostProcessingEffect(new Fog());
//window.AddPostProcessingEffect(new Sobel());
Vector3 pyramidRotation = Vector3.Zero;
PostProcessingEffect fxaa = window.AddPostProcessingEffect(new FXAA());
Plane plane = new Plane();
Vector3 shadowOffset = new Vector3(0, 0, 0.22f);
Sphere sphere = new Sphere();
Texture world = new Texture("Assets/world.jpg");
while (window.IsOpened)
{
if (window.GetKey(KeyCode.Esc))
{
break;
}
if (window.GetKey(KeyCode.W))
{
camera.Position3 += camera.Forward * 10 * window.deltaTime;
}
if (window.GetKey(KeyCode.S))
{
camera.Position3 += -camera.Forward * 10 * window.deltaTime;
}
if (window.GetKey(KeyCode.D))
{
camera.Position3 += camera.Right * 10 * window.deltaTime;
}
if (window.GetKey(KeyCode.A))
{
camera.Position3 += -camera.Right * 10 * window.deltaTime;
}
if (window.GetKey(KeyCode.Up))
{
camera.Position3 += camera.Up * 10 * window.deltaTime;
}
if (window.GetKey(KeyCode.Down))
{
camera.Position3 += -camera.Up * 10 * window.deltaTime;
}
if (window.HasFocus)
{
// currently broken, the mouse is too flaky
//float yaw = MouseX(window) * (90 + 45f);
//float pitch = MouseY(window) * 90f;
//camera.EulerRotation3 += new Vector3(pitch, yaw, 0) * window.deltaTime;
}
if (window.GetKey(KeyCode.Right))
{
camera.EulerRotation3 += new Vector3(0, 90 + 45, 0) * window.deltaTime;
}
if (window.GetKey(KeyCode.Left))
{
camera.EulerRotation3 -= new Vector3(0, 90 + 45, 0) * window.deltaTime;
}
if (window.GetKey(KeyCode.P))
{
camera.EulerRotation3 += new Vector3(90 + 45, 0, 0) * window.deltaTime;
}
if (window.GetKey(KeyCode.L))
{
camera.EulerRotation3 -= new Vector3(90 + 45, 0, 0) * window.deltaTime;
}
//fxaa.enabled = window.GetKey(KeyCode.X);
if (window.GetKey(KeyCode.Num1))
{
shadowOffset += Vector3.UnitX * 2 * window.deltaTime;
Console.WriteLine(shadowOffset);
}
if (window.GetKey(KeyCode.Num2))
{
shadowOffset -= Vector3.UnitX * 2 * window.deltaTime;
Console.WriteLine(shadowOffset);
}
if (window.GetKey(KeyCode.Num3))
{
shadowOffset += Vector3.UnitY * 2 * window.deltaTime;
Console.WriteLine(shadowOffset);
}
if (window.GetKey(KeyCode.Num4))
{
shadowOffset -= Vector3.UnitY * 2 * window.deltaTime;
Console.WriteLine(shadowOffset);
}
if (window.GetKey(KeyCode.Num5))
{
shadowOffset += Vector3.UnitZ * 0.2f * window.deltaTime;
Console.WriteLine(shadowOffset);
}
if (window.GetKey(KeyCode.Num6))
{
shadowOffset -= Vector3.UnitZ * 2 * window.deltaTime;
Console.WriteLine(shadowOffset);
}
directionalLight.SetShadowProjection(shadow_left, shadow_right, shadow_bottom, shadow_top, shadow_near, shadow_far);
animationTimer -= window.deltaTime;
if (animationTimer <= 0)
{
animationIndex++;
if (animationIndex >= numFrames)
{
animationIndex = 0;
}
animationTimer = 1f / animations[0].Fps;
}
foreach (string subject in animations[0].KeyFrames.Keys)
{
if (botMesh[0].HasBone(subject))
{
Mesh3.Bone bone = botMesh[0].GetBone(subject);
if (animationIndex < animations[0].KeyFrames[subject].Count)
{
//bone.Position = animations[0].KeyFrames[subject][animationIndex].Position;
//bone.Rotation = animations[0].KeyFrames[subject][animationIndex].Rotation;
}
}
}
pyramidRotation += new Vector3(0, 10, 0) * window.deltaTime;
neckRotation += window.deltaTime;
string boneName = "mixamorig:Neck";
if (botMesh[0].HasBone(boneName))
{
Mesh3.Bone bone = botMesh[0].GetBone(boneName);
bone.Rotation = Quaternion.FromEulerAngles(new Vector3(0, (float)Math.Sin(neckRotation) / 2, 0));
}
if (botMesh[1].HasBone(boneName))
{
Mesh3.Bone bone = botMesh[1].GetBone(boneName);
bone.Rotation = Quaternion.FromEulerAngles(new Vector3(0, (float)Math.Sin(neckRotation) / 2, 0));
}
crateRotation += 30 * window.deltaTime;
//lightRotation += 10 * window.deltaTime;
//directionalLight.UpdateDirection(Utils.EulerRotationToDirection(new Vector3(lightRotation, 180, 0)));
window.DisableCullFaces();
// draw shadow map texture
window.RenderTo(shadowTexture);
window.CullFrontFaces();
floor.DrawShadowMap(directionalLight);
pyramid.Scale3 = new Vector3(1, 2, 1);
pyramid.EulerRotation3 = pyramidRotation;
pyramid.Position3 = new Vector3(-6, 2, 10) + shadowOffset;
pyramid.DrawShadowMap(directionalLight);
pyramid.Scale3 = new Vector3(1, 2, 1);
pyramid.Rotation3 = Vector3.Zero;
pyramid.Position3 = new Vector3(-30, 2, 10) + shadowOffset;
pyramid.DrawShadowMap(directionalLight);
botMesh[0].Position3 = new Vector3(6, 0, 10) + shadowOffset;
botMesh[0].DrawShadowMap(directionalLight);
botMesh[1].Position3 = new Vector3(6, 0, 10) + shadowOffset;
botMesh[1].DrawShadowMap(directionalLight);
stormTrooper.Position3 = new Vector3(0, 0, 5) + shadowOffset;
stormTrooper.Rotation3 = Vector3.Zero;
stormTrooper.DrawShadowMap(directionalLight);
stormTrooper.Position3 = new Vector3(-5, 0, 5) + shadowOffset;
stormTrooper.Rotation3 = Vector3.Zero;
stormTrooper.DrawShadowMap(directionalLight);
stormTrooper.Position3 = new Vector3(7, 0, 5) + shadowOffset;
stormTrooper.Rotation3 = Utils.LookAt((camera.Position3 - stormTrooper.Position3).Normalized());
stormTrooper.DrawShadowMap(directionalLight);
cube.EulerRotation3 = new Vector3(0, crateRotation, 0);
cube.Position3 = new Vector3(0, 7, 0) + shadowOffset;
cube.DrawShadowMap(directionalLight);
cube.EulerRotation3 = Vector3.Zero;
cube.Position3 = new Vector3(5, 1, 5) + shadowOffset;
cube.DrawShadowMap(directionalLight);
foreach (Mesh3 item in tank)
{
item.Position3 = new Vector3(-10, 0, 20) + shadowOffset;
item.DrawShadowMap(directionalLight);
}
window.DisableCullFaces();
window.RenderTo(null);
window.CullBackFaces();
//window.DisableCullFaces();
floor.DrawPhong(floorTexture, directionalLight, new Vector3(0.5f, 0.5f, 0.5f), 0, shadowTexture);
pyramid.Scale3 = new Vector3(1, 2, 1);
pyramid.EulerRotation3 = pyramidRotation;
pyramid.Position3 = new Vector3(-6, 2, 10);
pyramid.DrawGouraud(new Vector4(1, 0, 0, 1), directionalLight, shadowTexture);
pyramid.Scale3 = new Vector3(1, 2, 1);
pyramid.EulerRotation3 = Vector3.Zero;
pyramid.Position3 = new Vector3(-30, 2, 10);
pyramid.DrawGouraud(new Vector4(1, 1, 0, 1), directionalLight, shadowTexture);
botMesh[0].Position3 = new Vector3(6, 0, 10);
botMesh[0].DrawGouraud(new Vector4(0, 0.8f, 1, 1), directionalLight, shadowTexture, 0.01f);
botMesh[1].Position3 = new Vector3(6, 0, 10);
botMesh[1].DrawGouraud(new Vector4(1, 0, 0, 1), directionalLight, shadowTexture, 0.01f);
stormTrooper.Position3 = new Vector3(0, 0, 5);
stormTrooper.Rotation3 = Vector3.Zero;
stormTrooper.DrawGouraud(stormTrooperTexture, directionalLight, shadowTexture);
stormTrooper.Position3 = new Vector3(-5, 0, 5);
stormTrooper.Rotation3 = Vector3.Zero;
stormTrooper.DrawPhong(stormTrooperTexture, directionalLight, new Vector3(0, 0.1f, 0), 0.75f, shadowTexture);
stormTrooper.Position3 = new Vector3(7, 0, 5);
stormTrooper.Rotation3 = Utils.LookAt((camera.Position3 - stormTrooper.Position3).Normalized());
stormTrooper.DrawCel(stormTrooperTexture, directionalLight, new Vector3(0, 0.1f, 0), 0.75f, shadowTexture);
//cube.DrawColor(new Vector4(1, 0, 0, 1));
cube.EulerRotation3 = new Vector3(0, crateRotation, 0);
cube.Position3 = new Vector3(0, 7, 0);
cube.DrawTexture(crate);
if (window.GetKey(KeyCode.Space))
{
movingTrooper.Position3 += movingTrooper.Forward * window.deltaTime * 2;
}
if (window.GetKey(KeyCode.G))
{
movingTrooper.EulerRotation3 += new Vector3(0, 90, 0) * window.deltaTime;
}
if (window.GetKey(KeyCode.H))
{
movingTrooper.EulerRotation3 -= new Vector3(0, 90, 0) * window.deltaTime;
}
movingTrooper.DrawGouraud(new Vector4(1, 0, 0, 1), directionalLight);
cube.EulerRotation3 = Vector3.Zero;
cube.Position3 = new Vector3(5, 1, 5);
cube.DrawGouraud(new Vector4(0, 0, 1, 1), directionalLight, shadowTexture);
foreach (Mesh3 item in tank)
{
item.Position3 = new Vector3(-10, 0, 20);
item.DrawPhong(tankDiffuse, directionalLight, new Vector3(0.1f, 0.1f, 0.1f), tankSpecular);
}
plane.Position3 = new Vector3(-13, 5, 0);
plane.EulerRotation3 += Vector3.UnitY * 30 * window.deltaTime;
plane.DrawColor(new Vector4(1, 1, 0, 1));
sphere.Position3 = new Vector3(-5, 2, 20);
sphere.EulerRotation3 += Vector3.UnitY * 10 * window.deltaTime;
sphere.Scale3 = new Vector3(3);
sphere.DrawPhong(world, directionalLight, new Vector3(0.2f, 0.2f, 0.2f));
//sphere.DrawColor(new Vector4(1, 0, 0, 1));
logo.DrawTexture(logoAiv);
shadow.DrawTexture(shadowTexture);
// this ensure postprocessing works
window.DisableCullFaces();
plane.Position3 = new Vector3(-10, 5, 0);
plane.EulerRotation3 += Vector3.UnitY * 30 * window.deltaTime;
plane.DrawColor(new Vector4(0, 1, 1, 1));
window.Update();
}
}
public void MeshLoadProfiling()
{
var k3d = new Toolkit();
var logger = new MessageLogger();
int nBeams = 20;
int nFaces = 1500;
double lengthBeams = 10.0;
double xIncBeam = lengthBeams / nBeams;
double xIncMesh = lengthBeams / nFaces;
double limit_dist = xIncBeam / 100.0;
// create beams
var lines = new List <Line3>();
var nodeI = new Point3(0, 0, 0);
for (int beamInd = 0; beamInd < nBeams; ++beamInd)
{
var nodeK = new Point3(nodeI.X + xIncBeam, 0, 0);
lines.Add(new Line3(nodeI, nodeK));
nodeI = nodeK;
}
var builderElements = k3d.Part.LineToBeam(lines, new List <string>(), new List <CroSec>(), logger, out List <Point3> outPoints);
// create a MeshLoad
var mesh = new Mesh3((nFaces + 1) * 2, nFaces);
mesh.AddVertex(new Point3(0, -0.5, 0));
mesh.AddVertex(new Point3(0, 0.5, 0));
for (var faceInd = 0; faceInd < nFaces; ++faceInd)
{
mesh.AddVertex(new Point3((faceInd + 1) * xIncMesh, -0.5, 0));
mesh.AddVertex(new Point3((faceInd + 1) * xIncMesh, 0.5, 0));
var nV = mesh.Vertices.Count;
mesh.AddFace(nV - 4, nV - 3, nV - 1, nV - 2);
}
UnitsConversionFactory ucf = UnitsConversionFactory.Conv();
UnitConversion m = ucf.m();
var baseMesh = m.toBaseMesh(mesh);
// create a mesh load
var load = k3d.Load.MeshLoad(new List <Vector3>()
{
new Vector3(0, 0, -1)
}, baseMesh);
// create a support
var support = k3d.Support.Support(new Point3(0, 0, 0), k3d.Support.SupportFixedConditions);
// assemble the model
var model = k3d.Model.AssembleModel(builderElements, new List <Support>()
{
support
}, new List <Load>()
{
load
},
out var info, out var mass, out var cog, out var message, out var runtimeWarning);
// calculate the model
model = k3d.Algorithms.AnalyzeThI(model, out var outMaxDisp, out var outG, out var outComp, out var warning);
Assert.AreEqual(outMaxDisp[0], 2.8232103119228276, 1E-5);
}
public void Initialize()
{
var k3d = new Toolkit();
var mesh = new Mesh3();
mesh.AddVertex(0, 0, 0);
mesh.AddVertex(0, 1, 0);
mesh.AddVertex(1, 0, 0);
mesh.AddVertex(1, 1, 0);
mesh.AddFace(0, 2, 3);
mesh.AddFace(0, 3, 1);
var supportConditions = new List <bool>()
{
true, true, true, true, true, true
};
var supports = new List <Support>
{
k3d.Support.Support(new Point3(0, 0, 0), supportConditions),
k3d.Support.Support(new Point3(0, 1, 0), supportConditions),
};
var loads = new List <Load>
{
k3d.Load.PointLoad(new Point3(1, 1, 0), new Vector3(-5, 0, -5)),
k3d.Load.PointLoad(new Point3(1, 0, 0), new Vector3(-5, 0, -5)),
};
var logger = new MessageLogger();
var crosec = k3d.CroSec.ReinforcedConcreteStandardShellConst(1);//20, 0, null, new List<double> { 4, 4, -4, -4 }, 0);
var shells = k3d.Part.MeshToShell(new List <Mesh3> {
mesh
}, null, new List <CroSec> {
crosec
}, logger, out var nodes);
var model = k3d.Model.AssembleModel(shells, supports, loads, out var info, out var mass, out var cog, out var message, out var any_warning);
model = k3d.Algorithms.AnalyzeThI(model, out var maxDisplacements, out var gravityForce, out var elasticEnergy, out var warning);
_model = model;
_inputPolyline = new PolyLine3(new Point3(0.5, -0.5, 1), new Point3(0.5, 1.5, 1));
_projectionVector = new Vector3(0, 0, -1);
_tol = 1E-12;
_delta = 0.02;
_outputPolylines = new List <PolyLine3>()
{
new PolyLine3
(
new Point3(0.5, 0, 0),
new Point3(0.5, 0.5, 0),
new Point3(0.5, 1, 0)
)
};
_outputCrossedFaces = new List <List <int> >()
{
new List <int>()
{
0, 1
}
};
}
public void Initialize()
{
//Create Mesh
var mesh = new Mesh3();
mesh.AddVertex(0, 0, 0);
mesh.AddVertex(0, 1, 0);
mesh.AddVertex(1, 0, 0);
mesh.AddVertex(1, 1, 0);
mesh.AddVertex(2, 0, 0);
mesh.AddVertex(2, 1, 0);
mesh.AddVertex(0, 0, 0);
mesh.AddVertex(1, 0, 0);
mesh.AddVertex(2, 0, 0);
mesh.AddVertex(0, 0, 1);
mesh.AddVertex(1, 0, 1);
mesh.AddVertex(2, 0, 1);
mesh.AddVertex(0, 0, 2);
mesh.AddVertex(1, 0, 2);
mesh.AddVertex(2, 0, 2);
mesh.AddVertex(2, 0, 0);
mesh.AddVertex(2, 1, 0);
mesh.AddVertex(2, 0, 1);
mesh.AddVertex(2, 1, 1);
mesh.AddVertex(2, 0, 2);
mesh.AddVertex(2, 1, 2);
mesh.AddVertex(2, 1, 0);
mesh.AddVertex(1, 1, 0);
mesh.AddVertex(0, 1, 0);
mesh.AddVertex(2, 1, 1);
mesh.AddVertex(1, 1, 1);
mesh.AddVertex(0, 1, 1);
mesh.AddVertex(2, 1, 2);
mesh.AddVertex(1, 1, 2);
mesh.AddVertex(0, 1, 2);
mesh.AddVertex(0, 1, 0);
mesh.AddVertex(0, 0, 0);
mesh.AddVertex(0, 1, 1);
mesh.AddVertex(0, 0, 1);
mesh.AddVertex(0, 1, 2);
mesh.AddVertex(0, 0, 2);
mesh.AddVertex(0, 0, 2);
mesh.AddVertex(1, 0, 2);
mesh.AddVertex(2, 0, 2);
mesh.AddVertex(0, 1, 2);
mesh.AddVertex(1, 1, 2);
mesh.AddVertex(2, 1, 2);
mesh.AddFace(0, 1, 3);
mesh.AddFace(2, 3, 5);
mesh.AddFace(6, 7, 10);
mesh.AddFace(7, 8, 11);
mesh.AddFace(9, 10, 13);
mesh.AddFace(10, 11, 14);
mesh.AddFace(15, 16, 18);
mesh.AddFace(17, 18, 20);
mesh.AddFace(21, 22, 25);
mesh.AddFace(22, 23, 26);
mesh.AddFace(24, 25, 28);
mesh.AddFace(25, 26, 29);
mesh.AddFace(30, 31, 33);
mesh.AddFace(32, 33, 35);
mesh.AddFace(36, 37, 40);
mesh.AddFace(37, 38, 41);
mesh.AddFace(0, 3, 2);
mesh.AddFace(2, 5, 4);
mesh.AddFace(6, 10, 9);
mesh.AddFace(7, 11, 10);
mesh.AddFace(9, 13, 12);
mesh.AddFace(10, 14, 13);
mesh.AddFace(15, 18, 17);
mesh.AddFace(17, 20, 19);
mesh.AddFace(21, 25, 24);
mesh.AddFace(22, 26, 25);
mesh.AddFace(24, 28, 27);
mesh.AddFace(25, 29, 28);
mesh.AddFace(30, 33, 32);
mesh.AddFace(32, 35, 34);
mesh.AddFace(36, 40, 39);
mesh.AddFace(37, 41, 40);
//Create Model
var k3d = new Toolkit();
var supportConditions = new List <bool>()
{
true, true, true, true, true, true
};
var supports = new List <Support>
{
k3d.Support.Support(new Point3(0, 0, 0), supportConditions),
k3d.Support.Support(new Point3(0, 1, 0), supportConditions),
k3d.Support.Support(new Point3(1, 0, 0), supportConditions),
k3d.Support.Support(new Point3(1, 1, 0), supportConditions),
k3d.Support.Support(new Point3(2, 0, 0), supportConditions),
k3d.Support.Support(new Point3(2, 1, 0), supportConditions)
};
var loads = new List <Load>
{
k3d.Load.PointLoad(new Point3(0, 0, 2), new Vector3(1000, 0, 0)),
k3d.Load.PointLoad(new Point3(1, 0, 2), new Vector3(1000, 0, 0)),
k3d.Load.PointLoad(new Point3(2, 0, 2), new Vector3(1000, 0, 0)),
k3d.Load.PointLoad(new Point3(2, 1, 2), new Vector3(1000, 0, 0)),
k3d.Load.PointLoad(new Point3(1, 1, 2), new Vector3(1000, 0, 0)),
k3d.Load.PointLoad(new Point3(0, 1, 2), new Vector3(1000, 0, 0))
};
var logger = new MessageLogger();
var crosec = k3d.CroSec.ReinforcedConcreteStandardShellConst(25, 0, null, new List <double> {
4, 4, -4, -4
}, 0);
var shells = k3d.Part.MeshToShell(new List <Mesh3> {
mesh
}, null, new List <CroSec> {
crosec
}, logger, out var nodes);
var model = k3d.Model.AssembleModel(shells, supports, loads,
out var info, out var mass, out var cog, out var message, out var any_warning);
model = k3d.Algorithms.AnalyzeThI(model, out var maxDisplacements,
out var gravityForce, out var elasticEnergy, out var warning);
//Create projection Vector
Vector3 proj_vect = new Vector3(0, 1, 0);
//Create other definition
var tol = 1E-12;
var delta = 0.02;
_model = model;
_projectionVector = proj_vect;
_tol = tol;
_delta = delta;
}
public void Initialize()
{
//Create Mesh
var mesh = new Mesh3();
mesh.AddVertex(0, 0, 0);
mesh.AddVertex(0, 1, 0);
mesh.AddVertex(0, 2, 0);
mesh.AddVertex(1, 0, 0);
mesh.AddVertex(1, 1, 0);
mesh.AddVertex(1, 2, 0);
mesh.AddVertex(2, 0, 0);
mesh.AddVertex(2, 1, 0);
mesh.AddVertex(2, 2, 0);
mesh.AddFace(0, 3, 4);
mesh.AddFace(1, 4, 5);
mesh.AddFace(3, 6, 7);
mesh.AddFace(4, 7, 8);
mesh.AddFace(0, 4, 1);
mesh.AddFace(1, 5, 2);
mesh.AddFace(3, 7, 4);
mesh.AddFace(4, 8, 5);
//Create Model
var k3d = new Toolkit();
var supportConditions = new List <bool>()
{
true, true, true, true, true, true
};
var supports = new List <Support>
{
k3d.Support.Support(new Point3(0, 0, 0), supportConditions),
k3d.Support.Support(new Point3(0, 1, 0), supportConditions),
k3d.Support.Support(new Point3(0, 2, 0), supportConditions)
};
var loads = new List <Load>
{
k3d.Load.PointLoad(new Point3(2, 2, 0), new Vector3(0, 0, -5)),
k3d.Load.PointLoad(new Point3(2, 1, 0), new Vector3(0, 0, -5)),
k3d.Load.PointLoad(new Point3(2, 0, 0), new Vector3(0, 0, -5)),
};
var logger = new MessageLogger();
var crosec = k3d.CroSec.ReinforcedConcreteStandardShellConst(25, 0, null, new List <double> {
4, 4, -4, -4
}, 0);
var shells = k3d.Part.MeshToShell(new List <Mesh3> {
mesh
}, null, new List <CroSec> {
crosec
}, logger, out var nodes);
var model = k3d.Model.AssembleModel(shells, supports, loads,
out var info, out var mass, out var cog, out var message, out var any_warning);
model = k3d.Algorithms.AnalyzeThI(model, out var maxDisplacements,
out var gravityForce, out var elasticEnergy, out var warning);
//Create projection Vector
Vector3 proj_vect = new Vector3(0, 0, -1);
//Create other definition
var tol = 1E-12;
var delta = 0.02;
_model = model;
_projectionVector = proj_vect;
_tol = tol;
_delta = delta;
}
private static IEnumerable <Polygon3> CreateTesselatedLineSupport(List <Point3> intersectionPoints, double plateSpacing, Mesh3 model)
{
intersectionPoints.Sort(new Point3XComparer());
double xyLength = intersectionPoints[0].DistanceTo(intersectionPoints[intersectionPoints.Count - 1]);
double xyAvgSegmentLength = xyLength / (intersectionPoints.Count - 1);
double buildPlateZ = model.MinPoint.Z - plateSpacing;
double zSegmentCountSum = 0;
foreach (Point3 intersection in intersectionPoints)
{
zSegmentCountSum += Math.Abs(intersection.Z - buildPlateZ) / xyAvgSegmentLength;
}
int zAvgSegmentCount = (int)(zSegmentCountSum / intersectionPoints.Count);
int numRows = zAvgSegmentCount + 2;
int numCols = intersectionPoints.Count;
Point3[,] pointGrid = new Point3[numRows, numCols];
for (int row = 0; row != numRows; row++)
{
for (int col = 0; col != numCols; col++)
{
Point3 referencePoint = intersectionPoints[col];
float newZ = (float)(referencePoint.Z - Math.Abs(referencePoint.Z - buildPlateZ) / (numRows - 1) * row);
pointGrid[row, col] = new Point3(referencePoint.X, referencePoint.Y, newZ);
}
}
Console.WriteLine("Filled grid of points");
List <Polygon3> scaffoldingFacets = new List <Polygon3>();
for (int row = 0; row != numRows - 1; row++)
{
for (int col = 0; col != numCols - 1; col++)
{
//Console.WriteLine($"Row {row}, Col {col}");
Point3 p1 = pointGrid[row + 1, col + 1];
Point3 p2 = pointGrid[row + 1, col];
Point3 p3 = pointGrid[row, col];
Point3 p4 = pointGrid[row, col + 1];
scaffoldingFacets.Add(TesselatePoints(p3, p2, p1));
scaffoldingFacets.Add(TesselatePoints(p1, p4, p3));
}
}
Console.WriteLine("Created tesselation from grid");
return(scaffoldingFacets);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
if (IsModeShort(stream.Version))
{
RenderMode = stream.ReadUInt16();
}
else
{
RenderMode = stream.ReadInt32();
}
if (IsSortModeFirst(stream.Version))
{
SortMode = stream.ReadUInt16();
}
if (IsReadMinParticleSize(stream.Version))
{
MinParticleSize = stream.ReadSingle();
}
MaxParticleSize = stream.ReadSingle();
CameraVelocityScale = stream.ReadSingle();
VelocityScale = stream.ReadSingle();
LengthScale = stream.ReadSingle();
SortingFudge = stream.ReadSingle();
if (IsReadNormalDirection(stream.Version))
{
NormalDirection = stream.ReadSingle();
}
if (!IsSortModeFirst(stream.Version))
{
SortMode = stream.ReadInt32();
}
if (IsReadRenderAlignment(stream.Version))
{
RenderAlignment = stream.ReadInt32();
Pivot.Read(stream);
}
if (IsReadUseCustomVertexStreams(stream.Version))
{
UseCustomVertexStreams = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
if (IsReadVertexStreamMask(stream.Version))
{
VertexStreamMask = stream.ReadInt32();
}
if (IsReadVertexStreams(stream.Version))
{
m_vertexStreams = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
Mesh.Read(stream);
if (IsReadMeshes(stream.Version))
{
Mesh1.Read(stream);
Mesh2.Read(stream);
Mesh3.Read(stream);
}
if (IsReadMaskInteraction(stream.Version))
{
MaskInteraction = stream.ReadInt32();
}
}
public void SetParent(Mesh3 mesh)
{
this.mesh.SetParent(mesh);
}
public ShellMesh(Shell s, Mesh3 m)
{
Shell = s;
Mesh = m;
}
public static Mesh3 Chuck(params object[] o)
{
Mesh3 mesh = new Mesh3();
int v0 = mesh.AddVertex(0, 0, 0);
int v1 = mesh.AddVertex(40, 0, 0);
int v2 = mesh.AddVertex(40, 15, 0);
int v3 = mesh.AddVertex(0, 15, 0);
int v4 = mesh.AddVertex(90, 0, 0);
int v5 = mesh.AddVertex(90, 30, 0);
int v6 = mesh.AddVertex(40, 30, 0);
int v7 = mesh.AddVertex(110, 0, 0);
int v8 = mesh.AddVertex(110, 45, 0);
int v9 = mesh.AddVertex(90, 45, 0);
int v12 = mesh.AddVertex(90, 45, -30);
int v13 = mesh.AddVertex(90, 30, -30);
int v14 = mesh.AddVertex(40, 30, -30);
int v15 = mesh.AddVertex(40, 15, -30);
int v16 = mesh.AddVertex(0, 15, -30);
int v17 = mesh.AddVertex(90, 0, -30);
int v18 = mesh.AddVertex(40, 0, -30);
int v19 = mesh.AddVertex(0, 0, -30);
int v10 = mesh.AddVertex(110, 0, -30);
int v11 = mesh.AddVertex(110, 45, -30);
int v20 = mesh.AddVertex(120, 45, -20);
int v21 = mesh.AddVertex(120, 45, -10);
int v22 = mesh.AddVertex(120, 0, -10);
int v23 = mesh.AddVertex(120, 0, -20);
int n0 = mesh.AddNormal(0, 0, 1);
int[] poly0 = { v0, v1, v2, v3 };
int[] normal0 = { n0, n0, n0, n0 };
mesh.AddPoly(poly0, normal0);
int[] poly1 = { v1, v4, v5, v6 };
mesh.AddPoly(poly1, normal0);
int[] poly2 = { v4, v7, v8, v9 };
mesh.AddPoly(poly2, normal0);
int n1 = mesh.AddNormal(1, 0, 0);
int[] poly3 = { v21, v22, v23, v20 };
int[] normal1 = { n1, n1, n1, n1 };
mesh.AddPoly(poly3, normal1);
int n3 = mesh.AddNormal(0, 1, 0);
int[] poly4 = { v9, v8, v11, v12 };
int[] normal3 = { n3, n3, n3, n3 };
mesh.AddPoly(poly4, normal3);
int[] poly5 = { v6, v5, v13, v14 };
mesh.AddPoly(poly5, normal3);
int[] poly6 = { v3, v2, v15, v16 };
mesh.AddPoly(poly6, normal3);
int n2 = mesh.AddNormal(0, 0, -1);
int[] normal2 = { n2, n2, n2, n2 };
int[] poly7 = { v12, v11, v10, v17 };
mesh.AddPoly(poly7, normal2);
int[] poly8 = { v14, v13, v17, v18 };
mesh.AddPoly(poly8, normal2);
int[] poly9 = { v16, v15, v18, v19 };
mesh.AddPoly(poly9, normal2);
int n4 = mesh.AddNormal(-1, 0, 0);
int[] normal4 = { n4, n4, n4, n4 };
int[] poly10 = { v9, v12, v13, v5 };
mesh.AddPoly(poly10, normal4);
int[] poly11 = { v6, v14, v15, v2 };
mesh.AddPoly(poly11, normal4);
int[] poly12 = { v0, v3, v16, v19 };
mesh.AddPoly(poly12, normal4);
int n5 = mesh.AddNormal(0, -1, 0);
int[] normal5 = { n5, n5, n5, n5 };
int[] poly13 = { v0, v19, v10, v7 };
mesh.AddPoly(poly13, normal5);
int[] poly14 = { v8, v7, v22, v21 };
int n6 = mesh.AddNormal(new Vector3D(1, 0, 1).Unit());
int[] normal6 = { n6, n6, n6, n6 };
mesh.AddPoly(poly14, normal6);
int[] poly15 = { v11, v20, v23, v10 };
int n7 = mesh.AddNormal(new Vector3D(1, 0, -1).Unit());
int[] normal7 = { n7, n7, n7, n7 };
mesh.AddPoly(poly15, normal2);
int[] poly16 = { v8, v21, v20, v11 };
mesh.AddPoly(poly16, normal3);
int[] poly17 = { v7, v10, v23, v22 };
mesh.AddPoly(poly17, normal5);
return mesh;
}
public void ReinforcedPlate()
{
var k3d = new Toolkit();
var logger = new MessageLogger();
double length = 1.0;
var mesh = new Mesh3();
mesh.AddVertex(new Point3(0, length, 0));
mesh.AddVertex(new Point3(0, 0, 0));
mesh.AddVertex(new Point3(length, 0, 0));
mesh.AddVertex(new Point3(length, length, 0));
mesh.AddFace(new Face3(0, 1, 3));
mesh.AddFace(new Face3(1, 2, 3));
var crosec = k3d.CroSec.ReinforcedConcreteStandardShellConst(25, 0, null, new List <double> {
4, 4, -4, -4
}, 0);
var shells = k3d.Part.MeshToShell(new List <Mesh3> {
mesh
}, null, new List <CroSec> {
crosec
}, logger, out var nodes);
// create supports
var supportConditions = new List <bool>()
{
true, true, true, true, true, true
};
var supports = new List <Support>
{
k3d.Support.Support(0, supportConditions),
k3d.Support.Support(1, supportConditions),
};
// create a Point-load
var loads = new List <Load>
{
k3d.Load.PointLoad(2, new Vector3(), new Vector3(0, 25, 0)),
k3d.Load.PointLoad(3, new Vector3(), new Vector3(0, 25, 0))
};
// create the model
var model = k3d.Model.AssembleModel(shells, supports, loads,
out var info, out var mass, out var cog, out var message, out var warning);
model = k3d.Algorithms.OptiReinf(model,
out List <double> maxDisplacements, out List <double> compliances, out message, out double reinfMass);
k3d.Results.ShellForcesLocal(model, null, 0,
out var nxx, out var nyy, out var nxy,
out var mxx, out var myy, out var mxy,
out var vx, out var vy);
Assert.AreEqual(mxx[0][0], 50.082245640312429, 1E-5);
Assert.AreEqual(mxx[0][1], 49.91775435968767, 1E-5);
var crosec_shell = model.elems[0].crosec as CroSec_Shell;
var reinf_thick = crosec_shell.elem_crosecs[0].layers[1].height;
Assert.AreEqual(reinf_thick, 0.00046824411288599481, 1E-5);
}
public void SetParent(Mesh3 mesh)
{
this.shape[mainMesh].SetParent(mesh);
}
