private void SetInstancedBuffers(GeometryMesh mesh)
{
var geometryData = mesh.Geometry;
this.Device.SetVertexBuffers(new VertexBufferBinding(geometryData.VertexBuffer), new VertexBufferBinding(this.InstanceBuffer, 0, 1));
this.Device.Indices = geometryData.IndexBuffer;
}
private void UpdateGeometryCache()
{
try
{
FileStream file = new FileStream(geometryCachePath, FileMode.Create);
System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(file, System.IO.Compression.CompressionMode.Compress);
BufferedStream stream = new BufferedStream(zip);
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter f = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
int count = namedBrushes.Count;
f.Serialize(stream, count);
int serializedCount = 0;
int i = 0;
foreach (var kvp in namedBrushes)
{
Message("BrushManager: " + i.ToString() + "/" + count.ToString() + " serialize");
i++;
GeometryMesh mesh = (GeometryMesh)kvp.Value.Model.Batch.MeshSource;
if (mesh == null)
{
throw new InvalidOperationException();
}
f.Serialize(stream, kvp.Key);
f.Serialize(stream, mesh);
serializedCount++;
}
stream.Close();
}
catch (Exception e)
{
Trace.TraceWarning("Updating geometry cache failed:\n" + e.ToString());
}
}
private void SetBuffers(GeometryMesh mesh)
{
var geometryData = mesh.Geometry;
this.Device.SetVertexBuffer(geometryData.VertexBuffer);
this.Device.Indices = geometryData.IndexBuffer;
}
private void UpdatePointHemicube(Model model, Point point, Group group)
{
//string mapName = "point_normals_for_ambient_occlusion";
GeometryMesh mesh = model.Batch.MeshSource as GeometryMesh;
if (mesh == null)
{
return;
}
Matrix4 pointFrame = new Matrix4();
Geometry geometry = mesh.Geometry;
var pointLocations = geometry.PointAttributes.Find <Vector3>("point_locations");
Vector3 eye = pointLocations[point];
Vector3 normal = geometry.ComputePointNormal(point);
eye = model.Frame.LocalToWorld.Matrix.TransformPoint(eye);
normal = model.Frame.LocalToWorld.Matrix.TransformDirection(normal);
//eye += 10.0f * hemicubeRenderer.Near * normal;
//aoEye = eye;
//aoBack = normal;
Matrix4.CreateLookAt(eye, eye + normal, normal.MinAxis, out pointFrame);
Vector3 positionInWorld = pointFrame.TransformPoint(new Vector3(0.0f, 0.0f, 0.0f));
renderer.PartialGLStateResetToDefaults();
pointViewHemicubeRenderer.ProgramOverride = null;
pointViewHemicubeRenderer.Render(pointFrame, group);
}
public void FlatNormals(Model model)
{
if (model == null)
{
return;
}
GeometryMesh mesh = model.Batch.MeshSource as GeometryMesh;
if (mesh == null)
{
return;
}
Geometry newGeometry = new CloneGeometryOperation(mesh.Geometry, null).Destination;
newGeometry.ComputePolygonCentroids();
newGeometry.ComputePolygonNormals();
//newGeometry.ComputeCornerNormals(0.0f/*2.0f * (float)Math.PI*/);
newGeometry.SmoothNormalize("corner_normals", "polygon_normals", (0.0f * (float)Math.PI));
newGeometry.BuildEdges();
model.Batch.MeshSource = new GeometryMesh(newGeometry, NormalStyle.PolygonNormals);
model.Name = "Flat(" + model.Name + ")";
}
/// <summary>
/// Updates ambient occlusion for all models in receivers group
/// </summary>
public void UpdateAmbientOcclusion(Group receivers, Group occluders)
{
string pointNormalsName = "point_normals_for_ambient_occlusion";
{
foreach (var model in receivers.Models)
{
//updateMsg = "ComputePointNormals for " + i + " / " + receivers.Models.Count;
//OnRenderFrame(null);
GeometryMesh mesh = model.Batch.MeshSource as GeometryMesh;
if (mesh != null)
{
Geometry geometry = mesh.Geometry;
geometry.ComputePointNormals(pointNormalsName);
}
}
//renderer.PartialGLStateResetToDefaults();
//aoHemicubeRenderer.ProgramOverride = renderer.Programs["LightOccluder"];
foreach (var model in receivers.Models)
{
//updateMsg = "UpdateAmbientOcclusion for " + i + " / " + receivers.Models.Count;
//OnRenderFrame(null);
UpdateAmbientOcclusionModel(model, occluders);
}
//updateMsg = "";
}
}
public ColorPicker(
//FramebufferManager framebufferManager,
MaterialManager materialManager,
IRenderer renderer
)
{
GeometryMesh discMesh = new GeometryMesh(
new RenderStack.Geometry.Shapes.Disc(1.0, 0.8, 32, 2),
NormalStyle.PolygonNormals
);
GeometryMesh triangleMesh = new GeometryMesh(
new RenderStack.Geometry.Shapes.Triangle(0.8f / 0.57735027f),
NormalStyle.PolygonNormals
);
hsv = materialManager["HSVColorFill"];
hsv2 = materialManager["HSVColorFill2"];
disc = new Model("disc", discMesh, hsv, 0.0f, 0.0f, 0.0f);
triangle = new Model("triangle", triangleMesh, hsv2, 0.0f, 0.0f, 0.0f);
group.Add(disc);
group.Add(triangle);
//this.framebufferManager = framebufferManager;
this.materialManager = materialManager;
this.renderer = renderer;
this.ninePatch = new NinePatch(Style.NinePatchStyle);
FillBasePixels = new Vector2(aSize, aSize);
}
public void MakeModelPhysicsConvexHull(Model model)
{
GeometryMesh mesh = model.Batch.MeshSource as GeometryMesh;
Geometry geometry = mesh.Geometry;
var pointLocations = geometry.PointAttributes.Find <Vector3>("point_locations");
List <Vector3> positions = new List <Vector3>();
BoundingBox box = new BoundingBox();
for (int i = 0; i < geometry.Points.Count; ++i)
{
Point point = geometry.Points[i];
Vector3 p = pointLocations[point];
positions.Add(p);
box.ExtendBy(p);
}
ConvexHullShape shape = new ConvexHullShape(positions);
model.PhysicsShape = shape;
/*System.Diagnostics.Trace.TraceInformation(
* "ConvexHull"
+ " Shift = " + shape.Shift.ToString()
+ " BoundingBox = " + box.ToString()
+ );*/
}
public unsafe void UpdateMeshCornerColors(GeometryMesh mesh)
{
if (mesh.Geometry.CornerAttributes.Contains <Vector4>("corner_colors") == false)
{
return;
}
var cornerColors = mesh.Geometry.CornerAttributes.Find <Vector4>("corner_colors");
var attributeColor = mesh.GetMesh.VertexBufferRange.VertexFormat.FindAttribute(VertexUsage.Color, 0);
//GL.BindBuffer(mesh.GetMesh.VertexBufferRange.Buffer.BufferTarget, mesh.GetMesh.VertexBufferRange.BufferObject);
renderer.Requested.Mesh = mesh.GetMesh;
renderer.BindAttributesAndCheckForUpdates();
IntPtr ptr = GL.MapBuffer(mesh.GetMesh.VertexBufferRange.BufferTargetGL, BufferAccess.ReadWrite);
byte * bytePtr = (byte *)ptr;
int index = 0;
foreach (Polygon polygon in mesh.Geometry.Polygons)
{
foreach (Corner corner in polygon.Corners)
{
byte * offsetPtr = &bytePtr[mesh.GetMesh.VertexBufferRange.VertexFormat.Stride * index + attributeColor.Offset];
float *fPtr = (float *)(offsetPtr);
fPtr[0] = cornerColors[corner].X;
fPtr[1] = cornerColors[corner].Y;
fPtr[2] = cornerColors[corner].Z;
fPtr[3] = cornerColors[corner].W;
++index;
}
}
GL.UnmapBuffer(mesh.GetMesh.VertexBufferRange.BufferTargetGL);
}
private bool IsMeshExist(GEOMETRYTYPE meshType, out GeometryMesh mesh, List <System.Object> param = null)
{
bool bRet = false;
mesh = null;
if (null == m_MeshTbl)
{
return(false);
}
foreach (var item in m_MeshTbl)
{
if (null == item)
{
continue;
}
if (
(item.Type == meshType) &&
item.IsMeshEqual(param)
)
{
mesh = item;
break;
}
}
return(bRet);
}
static GeometryMesh SolidToMesh(Solid S)
{
GeometryMesh Mesh = new GeometryMesh();
Mesh.Vertices = S.Vertices.ToVertices(S.Colors);
Mesh.Indices = S.Indices;
return(Mesh);
}
public TreeTemplate(
int sliceCount,
int stackDivision,
int coneCount,
float height,
float radius,
float radAdd
)
{
var attributePosition = new Attribute(VertexUsage.Position, VertexAttribPointerType.Float, 0, 3);
var attributeNormal = new Attribute(VertexUsage.Normal, VertexAttribPointerType.Float, 0, 3); /* content normals */
VertexFormat vertexFormat = new VertexFormat();
vertexFormat.Add(attributePosition);
vertexFormat.Add(attributeNormal);
this.sliceCount = sliceCount;
this.stackDivision = stackDivision;
this.coneCount = coneCount;
this.height = height;
this.radius = radius;
this.radAdd = radAdd;
float coneHeight = height / (float)coneCount;
Matrix4 rotZ = Matrix4.CreateRotation(
RenderStack.Math.Conversions.DegreesToRadians(90.0f),
Vector3.UnitZ
);
float cylHeight = coneHeight;
float cylRadius = height / 20.0f;
Geometry cylinderGeometry = new RenderStack.Geometry.Shapes.Cylinder(-cylHeight, cylHeight, cylRadius, sliceCount);
cylinderGeometry.Transform(rotZ);
GeometryMesh cylinderMesh = new GeometryMesh(cylinderGeometry, NormalStyle.CornerNormals, vertexFormat);
Shape cylinderShape = new CylinderShape(cylHeight, cylRadius);
cylinderMesh.GetMesh.Name = "cylinder";
meshes.Add(cylinderMesh);
shapes.Add(cylinderShape);
for (int c = 0; c < coneCount; c++)
{
float topRadius = (coneCount - 1 - c) * radius / (float)coneCount;
float bottomRadius = topRadius + radAdd;
float R = bottomRadius;
float r = topRadius;
float fullConeHeight = (R * coneHeight) / (R - r);
float minX = -fullConeHeight / 3.0f;
float maxX = 2.0f * fullConeHeight / 3.0f;
float offset = -minX;
Geometry coneGeometry = new RenderStack.Geometry.Shapes.Cone(minX, maxX, bottomRadius, 0.0f, true, true, sliceCount, stackDivision);
coneGeometry.Transform(rotZ);
GeometryMesh coneMesh = new GeometryMesh(coneGeometry, NormalStyle.CornerNormals, vertexFormat);
Shape coneShape = new ConeShape(fullConeHeight, R);
coneMesh.GetMesh.Name = "cone" + c.ToString();
meshes.Add(coneMesh);
shapes.Add(coneShape);
}
}
public static GeometryMesh Intersection(GeometryMesh A, GeometryMesh B)
{
Solid SolidA = new Solid(A.Vertices.Select((V) => V.Position).ToArray(), A.Indices, A.Vertices.Select((V) => V.Color).ToArray());
Solid SolidB = new Solid(B.Vertices.Select((V) => V.Position).ToArray(), B.Indices, B.Vertices.Select((V) => V.Color).ToArray());
BooleanModeller Modeller = new BooleanModeller(SolidA, SolidB);
return(SolidToMesh(Modeller.getIntersection()));
}
public void MakeLightWaveScene()
{
Reset();
LWScene scene = LWSceneParser.Load("res/Scenes/boxi3.lws");
Debug.WriteLine(scene.Objects.Count + " objects");
Debug.WriteLine(scene.Lights.Count + " lights");
Debug.WriteLine(scene.Cameras.Count + " cameras");
Material wood = materialManager["wood"];
var loadedModels = new Dictionary <string, RenderStack.LightWave.LWModel>();
foreach (var @object in scene.Objects)
{
try
{
string name = "res/Objects/" + @object.Name.Split('/').Last();
LWModel lwModel = null;
if (loadedModels.ContainsKey(name))
{
lwModel = loadedModels[name];
}
else
{
loadedModels[name] = lwModel = RenderStack.LightWave.LWModelParser.Load(name);
}
foreach (var layer in lwModel.Layers.Values)
{
var mesh = new GeometryMesh(layer.Geometry, NormalStyle.CornerNormals);
var model = new Model(layer.Name, mesh, wood, Motion(@object, 0.0f));
AddModel(model);
}
Debug.WriteLine("\tObject '" + @object.Name + "' " + @object.Bones.Count + " bones @ ");
}
catch (System.Exception)
{
}
}
foreach (var item in scene.Cameras)
{
Debug.WriteLine("\tCamera '" + item.Name + "'");
}
foreach (var item in scene.Lights)
{
Debug.WriteLine("\tLight '" + item.Name + "'");
}
AddCameras();
camera.Frame.LocalToParent.Set(
Motion(scene.Cameras.First(), 0.0f)
);
AddCameraUserControls();
}
public void UpdateAmbientOcclusionOld(Model model, Group occluders)
{
string mapName = "point_normals_for_ambient_occlusion";
GeometryMesh mesh = model.Batch.MeshSource as GeometryMesh;
if (mesh == null)
{
return;
}
Matrix4 pointFrame = new Matrix4();
Geometry geometry = mesh.Geometry;
var pointLocations = geometry.PointAttributes.Find <Vector3>("point_locations");
var polygonCentroids = geometry.PolygonAttributes.Find <Vector3>("polygon_centroids");
var pointNormals = geometry.PointAttributes.Find <Vector3>(mapName);
var cornerNormals = geometry.CornerAttributes.Contains <Vector3>("corner_normals") ? geometry.CornerAttributes.Find <Vector3>("corner_normals") : null;
var cornerColors = geometry.CornerAttributes.FindOrCreate <Vector4>("corner_colors");
cornerColors.Clear();
float[] colorBuffer = new float[mesh.GetMesh.VertexBufferRange.Count * 4];
foreach (Polygon polygon in geometry.Polygons)
{
foreach (Corner corner in polygon.Corners)
{
Point point = corner.Point;
Vector3 eye = Vector3.Mix(pointLocations[point], polygonCentroids[polygon], 0.01f);
Vector3 normal;
if (
(cornerNormals != null) &&
(cornerNormals.ContainsKey(corner) == true)
)
{
normal = cornerNormals[corner];
}
else
{
normal = pointNormals[point];
}
eye = model.Frame.LocalToWorld.Matrix.TransformPoint(eye);
normal = model.Frame.LocalToWorld.Matrix.TransformDirection(normal);
eye += normal * 0.01f;
//aoEye = eye;
//aoBack = normal;
Matrix4.CreateLookAt(eye, eye + normal, normal.MinAxis, out pointFrame);
Vector3 positionInWorld = pointFrame.TransformPoint(new Vector3(0.0f, 0.0f, 0.0f));
aoHemicubeRenderer.Render(pointFrame, occluders);
float occlusion = aoHemicubeRenderer.Average;
cornerColors[corner] = new Vector4(occlusion, occlusion, occlusion, 1.0f);
}
}
mesh.BuildMeshFromGeometry(BufferUsageHint.StaticDraw, NormalStyle.CornerNormals);
model.Name = "AmbientOcclusion(" + model.Name + ")";
}
public GeometryInputShaderBinding(GeometryMesh geometryMesh, VertexShader10 vertexShader, PixelShader10 pixelShader)
{
m_geometryMesh = geometryMesh;
m_pixelShader = pixelShader;
m_vertexShader = vertexShader;
/* Create the D3D input layout for the GPU */
m_inputLayout = new InputLayout(geometryMesh.InternalDevice,
vertexShader.InternalShaderByteCode,
geometryMesh.GetInputElements());
}
private void CreateSphere(GeometryData geometry, Material material, Vector3 position, Vector3 scale)
{
var mesh = new GeometryMesh(geometry, material, Matrix.Identity);
var model = new GeometryModel();
model.Add(mesh);
(var sphereGeometry, var sphereTransform, var sphereBounds) = this.Geometry.Create(model);
sphereTransform.MoveTo(position);
sphereTransform.SetScale(scale);
}
private void LoadBrush(object obj)
{
var brushManager = BaseServices.Get <BrushManager>();
var tls = brushManager.ThreadInfo;
BrushInfo bInfo = (BrushInfo)(obj);
tls.stream.Seek(index[bInfo.index], SeekOrigin.Begin);
string name = (string)tls.formatter.Deserialize(tls.stream);
GeometryMesh mesh = (GeometryMesh)tls.formatter.Deserialize(tls.stream);
MakeBrush(name, mesh);
}
public Manipulator(ManipulatorManager manager)
{
this.manager = manager;
Active = false;
ActiveAxis = Axis.None;
var redMaterial = manager.MaterialManager["ManipulatorRed"];
var greenMaterial = manager.MaterialManager["ManipulatorGreen"];
var blueMaterial = manager.MaterialManager["ManipulatorBlue"];
var renderer = manager.Renderer;
float cylinderWidth = 0.02f;
float coneStart = 0.4f;
float coneWidth = 0.2f;
float scale = 0.15f;
//float scale = 1.0f;
var axisCylinder = new GeometryMesh(
new Cylinder(0.0, coneStart * scale, cylinderWidth * scale, 20),
NormalStyle.CornerNormals
);
var axisCone = new GeometryMesh(
new Cone(coneStart * scale, 1.0 * scale, coneWidth * scale, 0.0, true, false, 20, 4),
NormalStyle.CornerNormals
);
Matrix4 translation = Matrix4.CreateTranslation(0.0f, 0.0f, 0.0f);
Matrix4 toYAxis = Matrix4.CreateRotation((float)Math.PI * 0.5f, new Vector3(0.0f, 0.0f, 1.0f));
Matrix4 toZAxis = Matrix4.CreateRotation(-(float)Math.PI * 0.5f, new Vector3(0.0f, 1.0f, 0.0f));
XCylinder = new Model("X-Axis Cylinder", axisCylinder, redMaterial);
XCone = new Model("X-Axis Cone", axisCone, redMaterial);
YCylinder = new Model("Y-Axis Cylinder", axisCylinder, greenMaterial, toYAxis);
YCone = new Model("Y-Axis Cone", axisCone, greenMaterial, toYAxis);
ZCylinder = new Model("Z-Axis Cylinder", axisCylinder, blueMaterial, toZAxis);
ZCone = new Model("Z-Axis Cone", axisCone, blueMaterial, toZAxis);
XCylinder.Frame.Parent = transform;
XCone.Frame.Parent = transform;
YCylinder.Frame.Parent = transform;
YCone.Frame.Parent = transform;
ZCylinder.Frame.Parent = transform;
ZCone.Frame.Parent = transform;
manager.ManipulatorGroup.Add(XCylinder);
manager.ManipulatorGroup.Add(XCone);
manager.ManipulatorGroup.Add(YCylinder);
manager.ManipulatorGroup.Add(YCone);
manager.ManipulatorGroup.Add(ZCylinder);
manager.ManipulatorGroup.Add(ZCone);
}
public void UpdateFrozenMesh()
{
if (FrozenMesh == null)
{
FrozenMesh = new GeometryMesh(new Tube(curve, TubeRadius, 12, 60), NormalStyle.CornerNormals);
}
else
{
//frozenMesh.Reset();
FrozenMesh.Geometry = new Tube(curve, TubeRadius, 12, 60);
FrozenMesh.BuildMeshFromGeometry(BufferUsageHint.StaticDraw, NormalStyle.CornerNormals);
}
}
private void ReadBlendData(EndianReader reader, SectionBlock section, GeometryMesh mesh, Halo2.Vertex vert, byte[] nodeMap)
{
if (section.NodesPerVertex == 0 && section.GeometryClassification == Halo2.GeometryClassification.Rigid)
{
mesh.NodeIndex = 0;
return;
}
if (section.GeometryClassification == Halo2.GeometryClassification.Rigid)
{
mesh.VertexWeights = VertexWeights.Rigid;
}
else if (section.GeometryClassification == Halo2.GeometryClassification.RigidBoned)
{
mesh.VertexWeights = VertexWeights.Skinned;
vert.BlendIndices = new RealVector4D(reader.ReadByte(), 0, 0, 0);
vert.BlendWeight = new RealVector4D(1, 0, 0, 0);
reader.ReadByte();
}
else if (section.GeometryClassification == Halo2.GeometryClassification.Skinned)
{
mesh.VertexWeights = VertexWeights.Skinned;
if (section.NodesPerVertex == 2 || section.NodesPerVertex == 4)
{
reader.ReadInt16();
}
var nodes = Enumerable.Range(0, 4).Select(i => section.NodesPerVertex > i ? reader.ReadByte() : 0).ToList();
var weights = Enumerable.Range(0, 4).Select(i => section.NodesPerVertex > i ? reader.ReadByte() / (float)byte.MaxValue : 0).ToList();
if (section.NodesPerVertex == 1 && weights.Sum() == 0)
{
weights[0] = 1;
}
vert.BlendIndices = new RealVector4D(nodes[0], nodes[1], nodes[2], nodes[3]);
vert.BlendWeight = new RealVector4D(weights[0], weights[1], weights[2], weights[3]);
}
if (nodeMap.Length > 0)
{
var temp = vert.BlendIndices;
vert.BlendIndices = new RealVector4D
{
X = section.NodesPerVertex > 0 ? nodeMap[(int)temp.X] : 0,
Y = section.NodesPerVertex > 1 ? nodeMap[(int)temp.Y] : 0,
Z = section.NodesPerVertex > 2 ? nodeMap[(int)temp.Z] : 0,
W = section.NodesPerVertex > 3 ? nodeMap[(int)temp.W] : 0,
};
}
}
/// <summary>
/// Updates ambient occlusion for single model.
/// This version updates point normals.
/// </summary>
public void UpdateAmbientOcclusionModel(Model model, Group occluders)
{
string pointNormalsName = "point_normals_for_ambient_occlusion";
GeometryMesh mesh = model.Batch.MeshSource as GeometryMesh;
if (mesh != null)
{
Geometry geometry = mesh.Geometry;
geometry.ComputePointNormals(pointNormalsName);
}
//renderer.PartialGLStateResetToDefaults();
//aoHemicubeRenderer.ProgramOverride = renderer.Programs["LightOccluder"];
UpdateAmbientOcclusion(model, occluders, pointNormalsName);
}
protected override void InitializeService()
{
SpawnPosition = new Vector3(0.0f, 2.0f, 0.0f);
// "alpha" is used as player ship
{
float sq3 = (float)Math.Sqrt(3.0f);
Geometry gLow = new CustomTetrahedron(1.0f, sq3 / 2.0f, 2.0f);
gLow.BuildEdges();
Geometry g = new SubdivideGeometryOperation(gLow).Destination;
//g.Transform(Matrix4.CreateScale(1.6f));
//g = new CatmullClarkGeometryOperation(g).Destination;
//g = new CatmullClarkGeometryOperation(g).Destination;
var gm = new GeometryMesh(
g,
NormalStyle.PolygonNormals
);
var m = gm.GetMesh;
alpha = new UnitType(
"Alpha",
materialManager["magenta"],
m,
MakeShape(gLow),
g.ComputeBoundingSphere(),
10.0f, // max health
1.0f, // density
null,
//typeof(PhysicsFrameController)
typeof(LookAtPhysicsFrameController)
);
}
{
Geometry g = new Cuboctahedron(1.0f);
helium = new UnitType(
"Helium",
materialManager["red"],
new GeometryMesh(g, NormalStyle.PolygonNormals).GetMesh,
MakeShape(g),
g.ComputeBoundingSphere(),
5.0f,
1.0f,
seeker as IAI,
typeof(LookAtPhysicsFrameController)
);
}
}
public void AddSimpleScene()
{
// Shapes here have local 0,0,0 at center of mass
Geometry cubeGeometry = new RenderStack.Geometry.Shapes.Cube(1.0f, 1.0f, 1.0f);
GeometryMesh cubeMesh = new GeometryMesh(cubeGeometry, NormalStyle.PolygonNormals);
GeometryMesh sphereMesh = new GeometryMesh(
new RenderStack.Geometry.Shapes.Sphere(0.75, 20, 12),
NormalStyle.CornerNormals
);
Geometry cylinderGeometry = new RenderStack.Geometry.Shapes.Cylinder(-0.5f, 0.5f, 0.5f, 24);
cylinderGeometry.Transform(
Matrix4.CreateRotation(
Conversions.DegreesToRadians(90.0f),
Vector3.UnitZ
)
);
GeometryMesh cylinderMesh = new GeometryMesh(cylinderGeometry, NormalStyle.CornerNormals);
Geometry coneGeometry = new RenderStack.Geometry.Shapes.Cone(-1.0f / 3.0f, 2.0f / 3.0f, 0.75f, 0.0f, true, false, 24, 10);
coneGeometry.Transform(
Matrix4.CreateRotation(
Conversions.DegreesToRadians(90.0f),
Vector3.UnitZ
)
);
GeometryMesh coneMesh = new GeometryMesh(coneGeometry, NormalStyle.CornerNormals);
/* Models */
float gap = 2.5f;
Material pearl = materialManager["pearl"];
Material gold = materialManager["gold"];
Material red = materialManager["red"];
Material green = materialManager["green"];
Material cyan = materialManager["cyan"];
Material blue = materialManager["blue"];
Material magenta = materialManager["magenta"];
Material pink = materialManager["pink"];
AddModel(new Model("cube", cubeMesh, pearl, -3.5f * gap, 0.5f, 0.0f));
AddModel(new Model("box", cubeMesh, gold, -2.5f * gap, 0.5f, 0.0f));
AddModel(new Model("sphere", sphereMesh, red, -1.5f * gap, 0.75f, 0.0f));
AddModel(new Model("sphere", sphereMesh, green, -0.5f * gap, 0.75f, 0.0f));
AddModel(new Model("cylinder", cylinderMesh, cyan, 0.5f * gap, 0.5f, 0.0f));
AddModel(new Model("cylinder", cylinderMesh, blue, 1.5f * gap, 0.5f, 0.0f));
AddModel(new Model("cone", coneMesh, magenta, 2.5f * gap, 1.0f / 3.0f, 0.0f));
AddModel(new Model("cone", coneMesh, pink, 3.5f * gap, 1.0f / 3.0f, 0.0f));
}
public float AddStereoscopicTest()
{
float radius = 0.5f;
float spread = 3.0f;
int xCount = 6;
int zCount = 6;
bool slow = Configuration.slow;
int step = slow ? 2 : 1;
GeometryMesh mesh = new GeometryMesh(
new RenderStack.Geometry.Shapes.Sphere(
radius,
slow ? 14 : 20,
slow ? 8 : 12
),
NormalStyle.PointNormals
);
SphereShape shape = new SphereShape(radius);
for (int x = 0; x < xCount; x += step)
{
float xRel = (float)(x) / (float)(xCount - 1);
float r, g, b;
RenderStack.Math.Conversions.HSVtoRGB(xRel * 360.0f, 1.0f, 1.0f, out r, out g, out b);
var material = materialManager.MakeSimpleMaterial("stereo" + xRel.ToString(), r, g, b);
xRel = (2.0f * xRel) - 1.0f;
for (int z = 0; z < zCount; z += step)
{
Model newModel = new Model(
"stereo sphere " + x + " " + z,
mesh,
material,
spread * ((float)(x) - (float)(xCount - 1.0) / 2.0f), // X
radius, // Y
spread * ((float)(z) - (float)(zCount - 1.0) / 2.0f) // z
);
newModel.PhysicsShape = shape;
newModel.Static = false;
AddModel(newModel);
newModel.RigidBody.Material.Restitution = 1.0f;
newModel.RigidBody.Material.StaticFriction = 0.0f;
newModel.RigidBody.Material.DynamicFriction = 0.0f;
}
}
float size = 2.0f * (spread * ((float)(xCount - 1.0f) / 2.0f) + radius * 4.0f);
return(size);
}
public Batch(IMeshSource meshSource)
{
MeshSource = meshSource;
GeometryMesh g = meshSource as GeometryMesh;
if (g != null)
{
//BoundingBox = g.Geometry.BoundingBox();
BoundingSphere = g.Geometry.ComputeBoundingSphere();
}
else
{
BoundingSphere.Center = Vector3.Zero;
BoundingSphere.Radius = float.MaxValue;
}
}
public void MakeBoxScene()
{
Reset();
float scale = 1.0f;
//sceneManager.AddFloor(22.0f * scale, 0, -1.0f);
AddFloor(30.0f * scale, 5, -0.5f);
#if true
float gap = 10.0f;
Material magenta = materialManager["magenta"];
for (float x = 0.5f; x <= 2.0f; x += 0.5f)
{
for (float z = 0.5f; z <= 2.0f; z += 0.5f)
{
Geometry g = new RenderStack.Geometry.Shapes.Cube(
new Vector3(x, 1.0f, z), new IVector3(2, 2, 2)
);
//g.Geodesate();
GeometryMesh mesh = new GeometryMesh(
g,
NormalStyle.CornerNormals
);
Shape shape = new BoxShape(x, 1.0f, z);
//Shape shape = new RenderStack.Physics.SphereShape(1.0f);
AddModel(
new Model(
"Cube(" + x + ", 1.0, " + z + ")",
mesh,
magenta,
-10.0f + (float)(x * gap),
0.5f,
-10.0f + (float)(z * gap)
),
shape
);
}
}
#endif
AddCameras();
AddCameraUserControls();
}
public void AddFloor(float size)
{
Geometry g = new Cube(size, 1.0, size);
//g = new SubdivideGeometryOperation(g).Destination;
//g = new SubdivideGeometryOperation(g).Destination;
//g = new SubdivideGeometryOperation(g).Destination;
GeometryMesh floorMesh = new GeometryMesh(g, NormalStyle.PolygonNormals);
var floorModel = new Model(
"Cube (floor)",
floorMesh,
materialManager.GridMaterial,
0.0f, -0.5f, 0.0f
);
AddModel(floorModel);
}
public void MakeNoiseScene()
{
Reset();
float scale = 1.0f;
AddFloor(30.0f * scale, 5, -0.5f);
int subdiv = 3;
Geometry coneGeometry = new RenderStack.Geometry.Shapes.Cone(
-1.0f / 3.0f, 2.0f / 3.0f, 0.75f, 0.0f, true, false, 24 * subdiv, 10 * subdiv
);
coneGeometry.Transform(
Matrix4.CreateRotation(
RenderStack.Math.Conversions.DegreesToRadians(90.0f),
Vector3.UnitZ
)
);
//coneGeometry = Mush(0.08f, coneGeometry);
var coneMesh = new GeometryMesh(coneGeometry, NormalStyle.CornerNormals);
var coneShape = new ConeShape(1.0f, 0.75f);
var gold = materialManager["noisy"];
var magenta = materialManager["magenta"];
userInterfaceManager.CurrentMaterial = "noisy";
Geometry ellipsoidGeometry = new RenderStack.Geometry.Shapes.Ellipsoid(
new Vector3(0.5f, 1.0f, 1.5f), 20, 12
);
var ellipsoidMesh = new GeometryMesh(ellipsoidGeometry, NormalStyle.PointNormals);
var ellipsoidShape = new EllipsoidShape(0.5f, 1.0f, 1.5f);
for (float x = -4.0f; x <= 4.0f; x += 8.0f)
{
for (float z = -4.0f; z <= 4.0f; z += 8.0f)
{
AddModel(new Model("cone", coneMesh, gold, x, 1.0f / 3.0f, z), coneShape).RigidBody.IsActive = false;
AddModel(new Model("ellipsoid", ellipsoidMesh, magenta, x, 2.0f, z), ellipsoidShape).RigidBody.IsActive = false;
}
}
AddCameras();
AddCameraUserControls();
}
public void ReleaseMesh(GEOMETRYTYPE meshType, List <System.Object> param = null)
{
GeometryMesh geometryMesh = null;
if (IsMeshExist(meshType, out geometryMesh, param = null))
{
if (
(geometryMesh != null) &&
(geometryMesh.DrawCounter > 0)
)
{
geometryMesh.DrawCounter--;
}
}
return;
}
public void MakeTree(Vector3 pos, TreeTemplate template)
{
int i = 0;
Material wood = materialManager["wood"];
Material leaves = materialManager["leaves"];
float coneHeight = template.Height / (float)template.ConeCount;
Matrix4 rotZ = Matrix4.CreateRotation(
RenderStack.Math.Conversions.DegreesToRadians(90.0f),
Vector3.UnitZ
);
float cylHeight = coneHeight;
float cylRadius = template.Height / 20.0f;
GeometryMesh cylinderMesh = template.Meshes[i];
Shape cylinderShape = template.Shapes[i];
++i;
Model rootModel = new Model("TreeRoot", cylinderMesh, wood, pos.X, pos.Y + cylHeight / 2.0f, pos.Z);
AddModel(rootModel, null);
Model below = rootModel;
float prevOffset = cylHeight / 2.0f;
for (int c = 0; c < template.ConeCount; c++)
{
float topRadius = (template.ConeCount - 1 - c) * template.Radius / (float)template.ConeCount;
float bottomRadius = topRadius + template.RadAdd;
float R = bottomRadius;
float r = topRadius;
float fullConeHeight = (R * coneHeight) / (R - r);
float minX = -fullConeHeight / 3.0f;
//float maxX = 2.0f * fullConeHeight / 3.0f;
float offset = -minX;
GeometryMesh coneMesh = template.Meshes[i];
Shape coneShape = template.Shapes[i];
++i;
Model coneModel = new Model("TreeCone", coneMesh, leaves, 0.0f, prevOffset + offset, 0.0f);
coneModel.Frame.Parent = below.Frame;
AddModel(coneModel, null);
Bender bender = new Bender(Vector3.UnitZ, 0.1f, 2.0f);
bender.Frame = coneModel.Frame;
Add(bender);
below = coneModel;
prevOffset = offset;
}
}
