/// <summary>
/// <see cref="PrepareForDraw"/> prepares and updates the Material, ShapeBuilder and VertexBuilder if necessary
/// </summary>
public void PrepareForDraw(out bool vertexBufferHasChanged, out int vertexSize, out int vertexCount)
{
var fieldsList = new ParticlePoolFieldsList(pool);
// User changes to materials might cause vertex layout change
Material.PrepareVertexLayout(fieldsList);
// User changes to shape builders might cause vertex layout change
ShapeBuilder.PrepareVertexLayout(fieldsList);
// Recalculate the required vertex count and stride
VertexBuilder.SetRequiredQuads(ShapeBuilder.QuadsPerParticle, pool.LivingParticles, pool.ParticleCapacity);
vertexBufferHasChanged = (Material.HasVertexLayoutChanged || ShapeBuilder.VertexLayoutHasChanged || VertexBuilder.IsBufferDirty);
// Update the vertex builder and the vertex layout if needed
if (vertexBufferHasChanged)
{
VertexBuilder.ResetVertexElementList();
Material.UpdateVertexBuilder(VertexBuilder);
ShapeBuilder.UpdateVertexBuilder(VertexBuilder);
VertexBuilder.UpdateVertexLayout();
}
vertexSize = VertexBuilder.VertexDeclaration.CalculateSize();
vertexCount = VertexBuilder.VertexCount;
VertexBuilder.SetDirty(false);
}
public override void Run(RenderControl render)
{
var material = MeshStandardMaterial.Create("workpiece");
material.SetColor(new Vector3(0.9f));
material.SetFaceSide(EnumFaceSide.DoubleSide);
var shape = ShapeBuilder.MakeCylinder(GP.YOZ(), 5, 50, 0);
mWorkpiece = BrepSceneNode.Create(shape, material, null);
render.ShowSceneNode(mWorkpiece);
{
var coord = new GAx2(new GPnt(0, 0, 5), GP.DZ());
var toolShape = ShapeBuilder.MakeCone(coord, 0, 2, 5, 0);
render.ShowShape(toolShape, Vector3.Blue);
}
render.ShowSceneNode(mMotionTrail);
mLength = 0;
mTheta = 0;
}
private void loadMaterial(XmlReader textReader, ShapeBuilder builder)
{
currentMaterial = textReader.GetAttribute("name");
#if VERBOSE
Log.Default.sendMessage("Creating material named {0}.", LogLevel.Info, "ShapeLoading", currentMaterial);
#endif
float restitution = 0.0f;
float staticFriction = 0.0f;
float dynamicFriction = 0.0f;
while (!(textReader.Name == MATERIAL && textReader.NodeType == XmlNodeType.EndElement) && textReader.Read())
{
if (textReader.NodeType == XmlNodeType.Element)
{
if (textReader.Name.Equals(RESTITUTION))
{
restitution = readRestitution(textReader);
}
else if (textReader.Name.Equals(STATIC_FRICTION))
{
staticFriction = readStaticFriction(textReader);
}
else if (textReader.Name.Equals(DYNAMIC_FRICTION))
{
dynamicFriction = readDynamicFriction(textReader);
}
}
}
builder.createMaterial(currentMaterial, restitution, staticFriction, dynamicFriction);
}
private void loadBox(XmlReader textReader, ShapeBuilder builder)
{
Vector3 extents = readExtents(textReader);
String name = readName(textReader);
Quaternion rotation = Quaternion.Identity;
Vector3 location = Vector3.Zero;
while (!(textReader.Name == BOX && textReader.NodeType == XmlNodeType.EndElement) && textReader.Read())
{
if (textReader.NodeType == XmlNodeType.Element)
{
if (textReader.Name.Equals(LOCATION))
{
location = readTranslation(textReader);
}
else if (textReader.Name.Equals(ROTATION))
{
rotation = readRotation(textReader);
}
}
}
builder.buildBox(name, extents, location, rotation, currentMaterial);
currentMaterial = null;
#if VERBOSE
Log.Default.sendMessage("Creating collision box named " + name + ".", LogLevel.Info, "ShapeLoading");
#endif
}
private void BtnBuild_Click(object sender, RoutedEventArgs e)
{
// создаем набор случайных примитивов
RandomFactory drankDirector = new RandomFactory();
for (int i = 0; i < 5; i++)
{
AddToCanvas(
drankDirector.BuildRandomShape(), // директор
random.NextDouble() * (canvas.ActualWidth - 50),
random.NextDouble() * (canvas.ActualHeight - 50));
}
// клонирование дерева
Shape tree = new ShapeBuilder(ShapeBuilder.Type.TREE).Build();
tree.Stroke = Brushes.Blue;
double left = random.NextDouble() * (canvas.ActualWidth - 50);
double top = random.NextDouble() * (canvas.ActualHeight - 50);
AddToCanvas(tree, left, top);
for (int j = 0; j < 2; j++)
{
left += tree.Width * 0.5;
Tree copy = (tree as Tree).Clone() as Tree; // копия
copy.Stroke = Brushes.Green;
AddToCanvas(copy, left, top);
}
}
protected override void OnLoad()
{
base.OnLoad();
// initialize and bind framebuffer
_framebuffer = new Framebuffer();
_framebuffer.Bind(FramebufferTarget.Framebuffer);
// initialize a renderbuffer and bind it to the depth attachment
// to support depth testing while rendering to the texture
_depthBuffer = new Renderbuffer();
_depthBuffer.Init(RenderbufferStorage.DepthComponent, FramebufferWidth, FramebufferHeight);
_framebuffer.Attach(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, _depthBuffer);
// initialize texture and bind it to the color attachment
_texture = new Texture2D(SizedInternalFormat.Rgba8, FramebufferWidth, FramebufferHeight, 1);
_framebuffer.Attach(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, _texture);
Framebuffer.Unbind(FramebufferTarget.Framebuffer);
// initialize shaders
_colorProgram = ProgramFactory.Create <SimpleColorProgram>();
_textureProgram = ProgramFactory.Create <SimpleTextureProgram>();
// initialize demonstration geometry
_cube = ShapeBuilder.CreateColoredCube(_colorProgram.InPosition, _colorProgram.InColor);
_quad = ShapeBuilder.CreateTexturedQuad(_textureProgram.InPosition, _textureProgram.InTexCoord);
// set camera position
ActiveCamera.Position = new Vector3(0, 0, 3);
// enable depth testing
GL.Enable(EnableCap.DepthTest);
}
public override void Run(RenderControl renderer)
{
var shape = ShapeBuilder.MakeSphere(new GPnt(), 1);
var bufferShape = new BufferShape(shape, null, null, 0.1);
bufferShape.Build();
float distance = 3.0f;
int halfCount = 5;
var scene = renderer.GetScene();
for (int ii = -halfCount; ii < halfCount; ++ii)
{
for (int jj = -halfCount; jj < halfCount; ++jj)
{
for (int kk = -halfCount; kk < halfCount; ++kk)
{
var node = new BrepSceneNode(bufferShape);
node.SetTransform(Matrix4.makeTranslation(ii * distance, jj * distance, kk * distance));
scene.AddNode(node);
}
}
}
renderer.ZoomAll();
Matrix4 m1 = new Matrix4(1);
Matrix4 m2 = new Matrix4(1);
Matrix4 x = m1 * m2;
}
public override void Run(RenderControl renderer)
{
string fileName = GetResourcePath("Holes.stp");
var shape = StepIO.Open(fileName);
if (shape == null)
{
return;
}
renderer.ShowShape(shape, Vector3.LightGray);
var bbox = shape.GetBBox();
var shape2 = ShapeBuilder.MakeBox(new GAx2(bbox.CornerMax(), GP.DZ()), 100, 100, 10);
renderer.ShowShape(shape2, Vector3.LightGray);
ExtremaShapeShape ess = new ExtremaShapeShape();
if (!ess.Initialize(shape, shape2, 0.001))
{
return;
}
var pt1 = ess.GetPointOnShape1(0);
var pt2 = ess.GetPointOnShape2(0);
var line = SketchBuilder.MakeLine(pt1, pt2);
renderer.ShowShape(line, Vector3.Red);
}
public override void Run(RenderControl render)
{
var paramCurve = Sketch2dBuilder.MakeLine(new GPnt2d(0, 0), new GPnt2d(Math.PI * 20, 20));
// curve one cone
{
var cone = ShapeBuilder.MakeCone(GP.XOY(), 1, 10, 20, 0);
var coneFace = cone.FindChild(EnumTopoShapeType.Topo_FACE, 0);
var curveOnConeSurface = SketchBuilder.MakeCurveOnSurface(paramCurve, coneFace);
var material = LineDashedMaterial.Create("my.dashed.material");
material.SetColor(ColorTable.Hex(0x0FFAA));
var node = BrepSceneNode.Create(curveOnConeSurface, null, material);
node.ComputeLineDistances(); // Enable dashed line style.
render.ShowSceneNode(node);
}
// curve one cylinder
{
var cylinder = ShapeBuilder.MakeCylinder(GP.XOY(), 2, 20, 0);
var cylinderFace = cylinder.FindChild(EnumTopoShapeType.Topo_FACE, 0);
var curveOnCylinderSurface = SketchBuilder.MakeCurveOnSurface(paramCurve, cylinderFace);
var node2 = BrepSceneNode.Create(curveOnCylinderSurface, null, null);
render.ShowSceneNode(node2);
}
}
public void ShapeBuilder_Should_Throw_Exception()
{
var height = 0;
var shapeBuider = new ShapeBuilder();
Assert.Throws <ArgumentException>(() => shapeBuider.CreateCube(height));
}
public override void Run(RenderControl render)
{
var material = MeshStandardMaterial.Create("workpiece");
material.SetColor(new Vector3(0.9f));
material.SetFaceSide(EnumFaceSide.DoubleSide);
var shape = ShapeBuilder.MakeCylinder(GP.YOZ(), 5, 50, 0);
mWorkpiece = BrepSceneNode.Create(shape, material, null);
render.ShowSceneNode(mWorkpiece);
var coord = new GAx2(new GPnt(0, 0, 5), GP.DZ());
var toolShape = ShapeBuilder.MakeCone(coord, 0, 2, 5, 0);
var toolNode = render.ShowShape(toolShape, ColorTable.Blue);
render.ShowSceneNode(mMotionTrail);
// Initialize Animation
mAnimation = new RigidAnimation();
var rotation = Matrix4.makeRotationAxis(new Vector3(1, 0, 0), (float)Math.PI);
var trf = Matrix4.makeTranslation(-50, 0, 0) * rotation;
mAnimation.Add(new MatrixAnimationClip(mWorkpiece, mWorkpiece.GetTransform(), trf, 0, 10));
mAnimation.Add(new MatrixAnimationClip(toolNode, toolNode.GetTransform(), trf, 10, 15));
mAnimation.Add(new RotateAnimationClip(toolNode, Vector3.UNIT_Z, (float)Math.PI * 4, 16, 20));
}
/// <summary>
/// Build the vertex buffer from particle data
/// Should come before <see cref="KickVertexBuffer"/>
/// </summary>
/// <param name="device">The graphics device, used to rebuild vertex layouts and shaders if needed</param>
/// <param name="invViewMatrix">The current camera's inverse view matrix</param>
public void BuildVertexBuffer(CommandList commandList, ref Matrix invViewMatrix)
{
// Get camera-space X and Y axes for billboard expansion and sort the particles if needed
var unitX = new Vector3(invViewMatrix.M11, invViewMatrix.M12, invViewMatrix.M13);
var unitY = new Vector3(invViewMatrix.M21, invViewMatrix.M22, invViewMatrix.M23);
depthSortVector = Vector3.Cross(unitX, unitY);
ParticleSorter.Sort();
// If the particles are in world space they don't need to be fixed as their coordinates are already in world space
// If the particles are in local space they need to be drawn in world space using the emitter's current location matrix
var posIdentity = new Vector3(0, 0, 0);
var rotIdentity = new Quaternion(0, 0, 0, 1);
var scaleIdentity = 1f;
if (simulationSpace == EmitterSimulationSpace.Local)
{
posIdentity = drawPosition;
rotIdentity = drawRotation;
scaleIdentity = drawScale;
}
VertexBuilder.MapBuffer(commandList);
ShapeBuilder.BuildVertexBuffer(VertexBuilder, unitX, unitY, ref posIdentity, ref rotIdentity, scaleIdentity, ParticleSorter);
VertexBuilder.RestartBuffer();
ShapeBuilder.SetRequiredQuads(ShapeBuilder.QuadsPerParticle, pool.LivingParticles, pool.ParticleCapacity);
Material.PatchVertexBuffer(VertexBuilder, unitX, unitY, ParticleSorter);
VertexBuilder.UnmapBuffer(commandList);
}
public void Render(ShapeBuilder <T> shape, Matrix world, ShapeLayer layer)
{
if (Engine.Scene == null || Engine.Scene.ActiveCamera == null)
{
return;
}
//var device = GraphicDeviceFactory.Device;
//device.VertexDeclaration = vd.VertexDeclaration;
//var _fill = device.GetRenderState(RenderState.FillMode);
//GraphicDeviceFactory.Device.SetRenderState(RenderState.FillMode, fill);
//effect.Technique = technique;
//effect.SetViewProjMatrix(Engine.Scene.ActiveCamera.ViewProj);
//effect.SetWorldMatrix(world);
//effect.SetValue(hColor, UseShapeColor ? shape.Color : color);
//effect.Apply(() =>
// {
// if (shape.Indices != null)
// device.DrawIndexedUserPrimitives(shape.PrimitiveType, layer.StartIndex, layer.StartVertex,
// layer.VertexCount, layer.PrimitiveCount, shape.Indices, Format.Index16, shape.Vertices, vd.Size);
// });
//GraphicDeviceFactory.Device.SetRenderState(RenderState.FillMode, _fill);
}
protected override void OnLoad()
{
base.OnLoad();
// load texture from file
using (var bitmap = new Bitmap("Data/Textures/crate.png"))
{
BitmapTexture.CreateCompatible(bitmap, out _texture);
_texture.LoadBitmap(bitmap);
}
// initialize shaders
_textureProgram = ProgramFactory.Create <SimpleTextureProgram>();
// initialize cube object and base view matrix
_objectView = _baseView = Matrix4.Identity;
// initialize demonstration geometry
_cube = ShapeBuilder.CreateTexturedCube(_textureProgram.InPosition, _textureProgram.InTexCoord);
// Enable culling, our cube vertices are defined inside out, so we flip them
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Back);
// initialize camera position
ActiveCamera.Position = new Vector3(0, 0, 4);
// set nice clear color
GL.ClearColor(Color.MidnightBlue);
_stopwatch.Restart();
}
public override void Run(RenderControl render)
{
RedMaterial = MeshPhongMaterial.Create("phong.color");
RedMaterial.SetColor(Vector3.Red);
GrayMaterial = MeshPhongMaterial.Create("phong.color");
GrayMaterial.SetColor(Vector3.LightGray);
GrayMaterial.SetTransparent(true);
GrayMaterial.SetOpacity(0.5f);
var tube = ShapeBuilder.MakeTube(new GPnt(0, 0, 5), GP.DZ(), 10, 2, 50);
TubeNode = BrepSceneNode.Create(tube, RedMaterial, null);
var cylinder = ShapeBuilder.MakeCylinder(GP.XOY(), 10, 60, 0);
CylinderNode = BrepSceneNode.Create(cylinder, GrayMaterial, null);
render.ShowSceneNode(TubeNode);
render.ShowSceneNode(CylinderNode);
var cone = ShapeBuilder.MakeCone(GP.YOZ(), 5, 0, 10, 0);
var bs = new BufferShape(cone, RedMaterial, null, 0.1);
bs.Build();
ConeNode1 = new BrepSceneNode(bs);
ConeNode2 = new BrepSceneNode(bs);
render.ShowSceneNode(ConeNode1);
render.ShowSceneNode(ConeNode2);
}
void loadCapsule(XmlReader textReader, ShapeBuilder builder)
{
String name = readName(textReader);
Vector3 location = Vector3.Zero;
Quaternion rotation = Quaternion.Identity;
float radius = readRadius(textReader);
float height = readHeight(textReader);
while (!(textReader.Name == CAPSULE && textReader.NodeType == XmlNodeType.EndElement) && textReader.Read())
{
if (textReader.NodeType == XmlNodeType.Element)
{
if (textReader.Name.Equals(LOCATION))
{
location = readTranslation(textReader);
}
else if (textReader.Name.Equals(ROTATION))
{
rotation = readRotation(textReader);
}
}
}
builder.buildCapsule(name, radius, height, location, rotation, currentMaterial);
currentMaterial = null;
#if VERBOSE
Log.Default.sendMessage("Creating collision capsule named " + name + ".", LogLevel.Info, "ShapeLoading");
#endif
}
public override bool OnParameterChanged(Element instance, ParameterDict parameters)
{
var shape = CastShapeElement(instance);
var radius = parameters.AsDouble("Radius", 5.0f);
shape.SetShape(ShapeBuilder.MakeSphere(GP.Origin(), radius));
return(true);
}
public override void loadShapes(ShapeBuilder builder, string filename, VirtualFileSystem vfs)
{
Log.Default.sendMessage("Loading collision shapes from " + filename + ".", LogLevel.Info, "ShapeLoading");
using (var stream = vfs.openStream(filename, FileMode.Open, FileAccess.Read))
{
using (XmlReader textReader = XmlReader.Create(stream, new XmlReaderSettings()
{
DtdProcessing = DtdProcessing.Prohibit, IgnoreWhitespace = true
}))
{
while (textReader.Read())
{
if (textReader.NodeType == XmlNodeType.Element)
{
if (textReader.Name.Equals(COMPOUND))
{
loadCompound(textReader, builder);
}
else if (textReader.Name.Equals(SPHERE))
{
loadSphere(textReader, builder);
}
else if (textReader.Name.Equals(BOX))
{
loadBox(textReader, builder);
}
else if (textReader.Name.Equals(MESH))
{
loadMesh(textReader, builder);
}
else if (textReader.Name.Equals(CONVEXHULL))
{
loadConvexHull(textReader, builder);
}
else if (textReader.Name.Equals(MATERIAL))
{
loadMaterial(textReader, builder);
}
else if (textReader.Name.Equals(PLANE))
{
loadPlane(textReader, builder);
}
else if (textReader.Name.Equals(CAPSULE))
{
loadCapsule(textReader, builder);
}
else if (textReader.Name.Equals(SOFT_BODY))
{
loadSoftBody(textReader, builder);
}
}
}
}
}
#if VERBOSE
Log.Default.sendMessage("Finished loading collision shapes from " + filename + ".", LogLevel.Info, "ShapeLoading");
#endif
}
public void AddBezier()
{
var builder = new ShapeBuilder();
builder.AddBezier(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 30), new Vector2(10, 40));
var shape = builder.Build();
Assert.Equal(1, shape.Paths.Length);
}
public ActionResult CreateShape(ShapeType shapeType)
{
string clientAddress = HttpContext.Request.UserHostAddress;
var shape = new ShapeBuilder(shapeType).Draw();
logger.Trace("Client:" + HttpContext.Request.UserHostAddress + " " + JsonConvert.SerializeObject(shape, Formatting.Indented));
return(Json(shape));
}
public void DrawLinesOpenFigure()
{
var builder = new ShapeBuilder();
builder.AddLine(10, 10, 10, 90);
builder.AddLine(10, 90, 50, 50);
var shape = builder.Build();
Assert.Equal(1, shape.Paths.Length);
Assert.IsType <Path>(shape.Paths[0]);
}
public Shape Construct()
{
ShapeBuilder builder = new ShapeBuilder();
builder.GetCircle();
builder.SetColour(2);
builder.SetThickness(4);
return(builder.GetResult());
}
void ShapeBuilderOptions(ShapeBuilder builder)
{
var menu = new GenericMenu();
menu.AddItem(new GUIContent("Reset", "Reset the selected Shape parameters."), false, () =>
{
builder.ResetParameters();
RebuildPreview();
});
menu.ShowAsContext();
}
public void ShapeBuilder_Should_Create_New_Cube()
{
var height = 5;
var shapeBuider = new ShapeBuilder();
var result = shapeBuider.CreateCube(height);
Assert.True(result != null);
Assert.Equal(5, result.Height);
Assert.Equal(5, result.Length);
Assert.Equal(5, result.Width);
}
/// <summary>
/// Load the shapes that have not yet been loaded.
/// </summary>
/// <param name="loader">The ShapeLoader to use to load the shapes.</param>
/// <param name="builder">The builder to use to construct the shapes.</param>
public void loadShapes(ShapeLoader loader, ShapeBuilder builder)
{
Log.Info("Loading shape group {0}", Name);
foreach (ShapeLocation location in shapeLocations.Values)
{
if (!location.Loaded)
{
loadShape(location, loader, builder);
}
}
loaded = true;
}
/// <summary>
/// Helper function to scan a directory for all shape files present.
/// </summary>
/// <param name="location"></param>
/// <param name="loader"></param>
/// <param name="builder"></param>
private void scanDirectory(ShapeLocation location, ShapeLoader loader, ShapeBuilder builder, VirtualFileSystem vfs)
{
IEnumerable <String> files = vfs.listFiles(location.LocName, location.Recursive);
foreach (String path in files)
{
if (loader.canLoadShape(path, vfs))
{
loader.loadShapes(builder, path, vfs);
}
}
}
public void DrawLinesClosedFigure()
{
var builder = new ShapeBuilder();
builder.AddLine(10, 10, 10, 90);
builder.AddLine(10, 90, 50, 50);
builder.CloseFigure();
var shape = builder.Build();
Assert.Equal(1, shape.Paths.Length);
Assert.IsType <Polygon>(shape.Paths[0].AsShape());
}
private void OnEnable()
{
m_ShapeBuidler = target as ShapeBuilder;
m_SelectionInfo = new SelectionInfo();
m_ShapePreset = serializedObject.FindProperty("ShapePreset");
m_RectangleWidth = serializedObject.FindProperty("RectangleWidth");
m_RectangleDepth = serializedObject.FindProperty("RectangleDepth");
m_CircleRadius = serializedObject.FindProperty("CircleRadius");
m_CirclePoints = serializedObject.FindProperty("CirclePoints");
m_RoundCoordinates = serializedObject.FindProperty("RoundCoordinates");
}
void loadPlane(XmlReader textReader, ShapeBuilder builder)
{
String name = readName(textReader);
Vector3 normal = readPlaneNormal(textReader);
float d = readPlaneDistance(textReader);
builder.buildPlane(name, normal, d, currentMaterial);
currentMaterial = null;
#if VERBOSE
Log.Default.sendMessage("Creating collision plane named " + name + ".", LogLevel.Info, "ShapeLoading");
#endif
}
// Строитель(Builder) - шаблон проектирования, который инкапсулирует создание объекта и позволяет разделить его на различные этапы.
//Когда использовать паттерн Строитель?
//Когда процесс создания нового объекта не должен зависеть от того,
// из каких частей этот объект состоит и как эти части связаны между собой
//Когда необходимо обеспечить получение различных вариаций объекта в процессе его создания
// pattern Builder;
private void Button_Click(object sender, RoutedEventArgs e)
{
ShapeCreator creator = new ShapeCreator();
ShapeBuilder builder = null;
Brush br = Brushes.Red;
switch (((TextBlock)comboBoxColor.SelectedItem).Text)
{
case "Red": br = Brushes.Red; break;
case "Green": br = Brushes.Green; break;
case "Blue": br = Brushes.Blue; break;
}
double X = rand.Next(0, 300);
double Y = rand.Next(0, 300);
string f1 = ((TextBlock)comboBoxMain.SelectedItem).Text;
string f2 = ((TextBlock)comboBoxSecond.SelectedItem).Text;
if (f1 == "Эллипс" && f2 == "Круг")
{
builder = new MainInnerShapeBuilder1();
}
else if (f1 == "Эллипс" && f2 == "Треугольник")
{
builder = new MainInnerShapeBuilder2();
}
else if (f1 == "Прямоугольник" && f2 == "Круг")
{
builder = new MainInnerShapeBuilder3();
}
else if (f1 == "Прямоугольник" && f2 == "Треугольник")
{
builder = new MainInnerShapeBuilder4();
}
CompositeShape compositeShape = creator.Create(builder);
compositeShape.MainShape.sh.Fill = br; // заливка
compositeShape.MainShape.sh.Stroke = br; // обводка
compositeShape.MainShape.sh.Margin = new Thickness(X, Y, 0, 0);
compositeShape.InnerShape.sh2.Margin = new Thickness(X, Y, 0, 0);
grid3.Children.Add(compositeShape.MainShape.sh);
grid3.Children.Add(compositeShape.InnerShape.sh2);
}
public void BuildWall(Plane p)
{
ShapeBuilder shapebuilder = new ShapeBuilder(model);
Matrix transform = GetTransform();
Vector2[] points = shapebuilder.GetShape(ref transform, p);
shape = new Shape(points, false);
offset = shape.GetCenter() - new Vector2(position.X, position.Y);
shape.CenterAtZero();
body = new Body(shape, float.MaxValue);
body.position.X = position.X + offset.X;
body.position.Y = position.Y + offset.Y;
body.is_static = true;
body.Update(0);
}
