public bool Update()
{
if (!ModelComponent.Enabled || ModelComponent.ModelViewHierarchy == null || ModelComponent.Model == null)
{
return false;
}
var newModel = ModelComponent.Model;
if (previousModel != newModel)
{
// When changing the model, we need to regenerate the render meshes
for(int i = 0; i < RenderMeshesPerEffectSlot.Count; i++)
{
// TODO: We should dispose render mehses here, but need to check exactly how
// Changing a struct so make a copy first (TODO: Replace with ref locals when released)
var renderMeshes = RenderMeshesPerEffectSlot[i];
renderMeshes.Clear();
RenderMeshesPerEffectSlot[i] = renderMeshes;
}
previousModel = newModel;
}
return true;
}
protected override async Task LoadContent()
{
await base.LoadContent();
font = Asset.Load<SpriteFont>("Font");
teapot = Asset.Load<Model>("Teapot");
batch = new SpriteBatch(GraphicsDevice);
BuildUI();
spriteComponent = new SpriteComponent { SpriteProvider = new SpriteFromSheet { Sheet = Asset.Load<SpriteSheet>("SpriteSheet") } };
modelComponent = new ModelComponent { Model = teapot };
modelComponent2 = new ModelComponent { Model = teapot };
modelComponent3 = new ModelComponent { Model = teapot };
entity = new Entity { spriteComponent, modelComponent };
entity2 = new Entity { modelComponent2 };
entity3 = new Entity { modelComponent3 };
SceneSystem.SceneInstance.Scene.Entities.Add(entity);
SceneSystem.SceneInstance.Scene.Entities.Add(entity2);
SceneSystem.SceneInstance.Scene.Entities.Add(entity3);
if (Input.Accelerometer.IsSupported)
Input.Accelerometer.IsEnabled = true;
if (Input.Compass.IsSupported)
Input.Compass.IsEnabled = true;
if (Input.Gyroscope.IsSupported)
Input.Gyroscope.IsEnabled = true;
if (Input.UserAcceleration.IsSupported)
Input.UserAcceleration.IsEnabled = true;
if (Input.Gravity.IsSupported)
Input.Gravity.IsEnabled = true;
if (Input.Orientation.IsSupported)
Input.Orientation.IsEnabled = true;
ChangeScene(0);
}
protected override async Task LoadContent()
{
await base.LoadContent();
Window.AllowUserResizing = true;
// Instantiate a scene with a single entity and model component
var scene = new Scene();
// Create a cube entity
cubeEntity = new Entity();
// Create a procedural model with a diffuse material
var model = new Model();
var material = Material.New(
new MaterialDescriptor
{
Attributes =
{
Diffuse = new MaterialDiffuseMapFeature(new ComputeColor(Color.White)),
DiffuseModel = new MaterialDiffuseLambertModelFeature()
}
});
model.Materials.Add(material);
cubeEntity.Add(new ModelComponent(model));
var modelDescriptor = new ProceduralModelDescriptor(new CubeProceduralModel());
modelDescriptor.GenerateModel(Services, model);
// Add the cube to the scene
scene.AddChild(cubeEntity);
// Create a camera entity and add it to the scene
var cameraEntity = new Entity { new CameraComponent() };
cameraEntity.Transform.Position = new Vector3(0, 0, 5);
scene.AddChild(cameraEntity);
// Create a light
var lightEntity = new Entity()
{
new LightComponent()
};
lightEntity.Transform.Position = new Vector3(0, 0, 1);
lightEntity.Transform.Rotation = Quaternion.RotationY(MathUtil.DegreesToRadians(45));
scene.AddChild(lightEntity);
// Create a graphics compositor
var compositor = new SceneGraphicsCompositorLayers();
bool isLDR = false;
if (isLDR)
{
compositor.Master.Renderers.Add(new ClearRenderFrameRenderer());
compositor.Master.Renderers.Add(new SceneCameraRenderer() {});
}
else
{
var layer = new SceneGraphicsLayer();
var renderHDROutput = new LocalRenderFrameProvider { Descriptor = { Format = RenderFrameFormat.HDR, DepthFormat = RenderFrameDepthFormat.Shared} };
layer.Output = renderHDROutput;
layer.Renderers.Add(new ClearRenderFrameRenderer());
layer.Renderers.Add(new SceneCameraRenderer());
compositor.Layers.Add(layer);
compositor.Master.Renderers.Add(new SceneEffectRenderer()
{
Effect = new PostProcessingEffects()
});
}
compositor.Cameras.Add(cameraEntity.Get<CameraComponent>());
SceneSystem.SceneInstance = new SceneInstance(Services, scene);
// Use this graphics compositor
scene.Settings.GraphicsCompositor = compositor;
// Create a scene instance
SceneSystem.SceneInstance = new SceneInstance(Services, scene);
}
public void Initialize(Model model)
{
Initialize(model.Hierarchy != null ? model.Hierarchy.Nodes : null);
nodeTransformations[0].Flags &= ~ModelNodeFlags.EnableTransform;
}
/// <summary>
/// Initializes a new instance of the <see cref="ModelViewHierarchyUpdater"/> class.
/// </summary>
/// <param name="model">The model.</param>
public ModelViewHierarchyUpdater(Model model)
{
if (model == null) throw new ArgumentNullException("model");
Initialize(model);
}
/// <summary>
/// Create a clone with its own ParameterCollection.
/// It allows reuse of a single Model for multiple ModelComponent.
/// </summary>
public Model Instantiate()
{
var result = new Model();
if (Children != null)
{
result.Children = new List<Model>();
foreach (var child in Children)
{
result.Children.Add(child.Instantiate());
}
}
foreach (var mesh in Meshes)
{
var meshCopy = new Mesh(mesh);
result.Meshes.Add(meshCopy);
}
result.Hierarchy = Hierarchy;
result.BoundingBox = BoundingBox;
return result;
}
// Temporarily removed
//[DataMemberConvert]
//public ParameterCollection Parameters
//{
// get { return parameters; }
//}
/// <summary>
/// Adds the specified model view (for collection initializers).
/// </summary>
/// <param name="model">The model view.</param>
public void Add(Model model)
{
children.Add(model);
}
public void Generate(IServiceRegistry services, Model model)
{
if (services == null) throw new ArgumentNullException("services");
if (model == null) throw new ArgumentNullException("model");
var graphicsDevice = services.GetSafeServiceAs<IGraphicsDeviceService>().GraphicsDevice;
var data = this.CreatePrimitiveMeshData();
if (data.Vertices.Length == 0)
{
throw new InvalidOperationException("Invalid GeometricPrimitive [{0}]. Expecting non-zero Vertices array");
}
var boundingBox = BoundingBox.Empty;
for (int i = 0; i < data.Vertices.Length; i++)
BoundingBox.Merge(ref boundingBox, ref data.Vertices[i].Position, out boundingBox);
BoundingSphere boundingSphere;
unsafe
{
fixed (void* verticesPtr = data.Vertices)
BoundingSphere.FromPoints((IntPtr)verticesPtr, 0, data.Vertices.Length, VertexPositionNormalTexture.Size, out boundingSphere);
}
var originalLayout = data.Vertices[0].GetLayout();
// Generate Tangent/BiNormal vectors
var resultWithTangentBiNormal = VertexHelper.GenerateTangentBinormal(originalLayout, data.Vertices, data.Indices);
// Generate Multitexcoords
var result = VertexHelper.GenerateMultiTextureCoordinates(resultWithTangentBiNormal);
var meshDraw = new MeshDraw();
var layout = result.Layout;
var vertexBuffer = result.VertexBuffer;
var indices = data.Indices;
if (indices.Length < 0xFFFF)
{
var indicesShort = new ushort[indices.Length];
for (int i = 0; i < indicesShort.Length; i++)
{
indicesShort[i] = (ushort)indices[i];
}
meshDraw.IndexBuffer = new IndexBufferBinding(Buffer.Index.New(graphicsDevice, indicesShort).RecreateWith(indicesShort), false, indices.Length);
}
else
{
if (graphicsDevice.Features.Profile <= GraphicsProfile.Level_9_3)
{
throw new InvalidOperationException("Cannot generate more than 65535 indices on feature level HW <= 9.3");
}
meshDraw.IndexBuffer = new IndexBufferBinding(Buffer.Index.New(graphicsDevice, indices).RecreateWith(indices), true, indices.Length);
}
meshDraw.VertexBuffers = new[] { new VertexBufferBinding(Buffer.New(graphicsDevice, vertexBuffer, BufferFlags.VertexBuffer).RecreateWith(vertexBuffer), layout, data.Vertices.Length) };
meshDraw.DrawCount = indices.Length;
meshDraw.PrimitiveType = PrimitiveType.TriangleList;
var mesh = new Mesh { Draw = meshDraw, BoundingBox = boundingBox, BoundingSphere = boundingSphere };
model.BoundingBox = boundingBox;
model.BoundingSphere = boundingSphere;
model.Add(mesh);
if (MaterialInstance != null && MaterialInstance.Material != null)
{
model.Materials.Add(MaterialInstance);
}
}