public bool Update()
{
if (!ModelComponent.Enabled || ModelComponent.Skeleton == 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;
}
private AnimationClip CreateModelChangeAnimation(Model model)
{
var changeMegalodonAnimClip = new AnimationClip();
var modelCurve = new AnimationCurve<object>();
modelCurve.KeyFrames.Add(new KeyFrameData<object>(CompressedTimeSpan.Zero, model));
changeMegalodonAnimClip.AddCurve("[ModelComponent.Key].Model", modelCurve);
return changeMegalodonAnimClip;
}
protected override Task LoadContent()
{
//Profiler.Enable(GameProfilingKeys.GameDrawFPS);
ProfilerSystem.EnableProfiling(false, GameProfilingKeys.GameDrawFPS);
model = Content.Load<Model>("Model");
material1 = Content.Load<Material>("Material1");
material2 = Content.Load<Material>("Material2");
SetupScene();
int cubeWidth = 8;
//var skybox = Asset.Load<Skybox>("Skybox");
//var skyboxEntity = new Entity { new SkyboxComponent { Skybox = skybox } };
//Scene.Entities.Add(skyboxEntity);
//var backgroundTexture = Asset.Load<Texture>("XenkoBackground");
//var backgroundEntity = new Entity { new BackgroundComponent { Texture = backgroundTexture } };
//Scene.Entities.Add(backgroundEntity);
for (int i = 0; i < cubeWidth; ++i)
{
for (int j = 0; j < cubeWidth; ++j)
{
for (int k = 0; k < cubeWidth; ++k)
{
var position = new Vector3((i - cubeWidth / 2) * 2.4f, (j - cubeWidth / 2) * 2.4f, (k - cubeWidth / 2) * 2.4f);
//var material = (k/4)%2 == 0 ? material1 : material2;
var isShadowReceiver = (k / 2) % 2 == 0;
var entity = new Entity
{
new ModelComponent { Model = model, Materials = { material1 }, IsShadowReceiver = isShadowReceiver },
};
entity.Transform.Position = position;
Scene.Entities.Add(entity);
}
}
}
//var spriteSheet = Asset.Load<SpriteSheet>("SpriteSheet");
//var spriteEntity = new Entity
//{
// new SpriteComponent
// {
// SpriteProvider = new SpriteFromSheet { Sheet = spriteSheet },
// }
//};
//Scene.Entities.Add(spriteEntity);
camera.Position = new Vector3(35.0f, 5.5f, 22.0f);
camera.SetTarget(Scene.Entities.Last(), true);
return base.LoadContent();
}
protected override async Task LoadContent()
{
await base.LoadContent();
font = Content.Load<SpriteFont>("Font");
teapot = Content.Load<Model>("Teapot");
batch = new SpriteBatch(GraphicsDevice);
BuildUI();
spriteComponent = new SpriteComponent { SpriteProvider = new SpriteFromSheet { Sheet = Content.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(GraphicsDevice, 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.Entities.Add(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.Entities.Add(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.Entities.Add(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);
}
/// <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.Skeleton = Skeleton;
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);
}
/// <summary>
/// Compares the shadow options between the two meshes.
/// </summary>
/// <param name="baseMesh">The base mesh.</param>
/// <param name="newMesh">The mesh to compare.</param>
/// <param name="extra">Unused parameter.</param>
/// <returns>True if the options are the same, false otherwise.</returns>
private static bool CompareShadowOptions(Model model, Mesh baseMesh, Mesh newMesh)
{
// TODO: Check is Model the same for the two mesh?
var material1 = model.Materials.GetItemOrNull(baseMesh.MaterialIndex);
var material2 = model.Materials.GetItemOrNull(newMesh.MaterialIndex);
return material1 == material2 || (material1 != null && material2 != null && material1.IsShadowCaster == material2.IsShadowCaster &&
material1.IsShadowReceiver == material2.IsShadowReceiver);
}
/// <summary>
/// Compares the parameters of the two meshes.
/// </summary>
/// <param name="baseMesh">The base mesh.</param>
/// <param name="newMesh">The mesh to compare.</param>
/// <param name="extra">Unused parameter.</param>
/// <returns>True if all the parameters are the same, false otherwise.</returns>
private static bool CompareParameters(Model model, Mesh baseMesh, Mesh newMesh)
{
var localParams = baseMesh.Parameters;
if (localParams == null && newMesh.Parameters == null)
return true;
if (localParams == null || newMesh.Parameters == null)
return false;
return IsSubsetOf(localParams, newMesh.Parameters) && IsSubsetOf(newMesh.Parameters, localParams);
}
