public RenderObject(Model9 model, Entity entity, string metaName, string technique)
{
Model = model;
Entity = entity;
MetaName = metaName;
Technique = technique;
}
public void HideFrame(string name, Model9 model)
{
model.SkinnedMesh.ForEachFrame((frame) =>
{
if (frame.Name == name)
{
frame = null;
}
});
}
public string GetSplatTechniqueExtention(Model9 model, Settings settings)
{
bool splat1 = false;
bool splat2 = false;
if (model.MaterialTexture[0] != null || model.MaterialTexture[1] != null || model.MaterialTexture[2] != null || model.MaterialTexture[3] != null)
{
splat1 = true;
}
if (model.MaterialTexture[4] != null || model.MaterialTexture[5] != null || model.MaterialTexture[6] != null || model.MaterialTexture[7] != null)
{
splat2 = true;
}
string techniqueExtention = "";
if (splat1)
{
techniqueExtention += "Splat1";
}
else
{
techniqueExtention += "NoSplat1";
}
if (splat2)
{
techniqueExtention += "Splat2";
}
else
{
techniqueExtention += "NoSplat2";
}
if (settings.TerrainQuality == Settings.TerrainQualities.Low)
{
return(techniqueExtention + "Lowest");
}
else
{
return(techniqueExtention + "NoLowest");
}
}
public void Insert(Model9 model, Entity entity, MetaModel metaModel, string metaName, SkinnedMesh skinnedMesh, SlimDX.Direct3D9.Mesh mesh, bool halfSkinned)
{
if (skinnedMesh != null)
{
RenderSkinnedMesh sm;
if (!SkinnedMeshes.TryGetValue(skinnedMesh, out sm))
{
SkinnedMeshes[skinnedMesh] = sm = new RenderSkinnedMesh();
}
sm.Insert(model, entity, metaModel, metaName);
}
else if (mesh != null)
{
RenderMesh m;
if (!Meshes.TryGetValue(mesh, out m))
{
Meshes[mesh] = m = new RenderMesh(mesh.IndexBuffer, mesh.VertexBuffer);
}
m.Insert(model, entity, metaModel, metaName);
}
}
public void Insert(Model9 model, Entity entity, MetaModel metaModel, string metaName, Settings settings)
{
//if (!IsVisible(metaModel, settings)) return;
string techniqueNameEnding = Renderer.GetTechniqueNameExtension(metaModel, settings, techniqueNames);
if (metaModel.HasAlpha)
{
//Renderer.totalAddedItems++;
AlphaObjects.Add(new Common.Tuple <Model9, Entity, string, string>(model, entity, metaName, techniqueNameEnding));
}
else if (metaModel.SplatMapped)
{
//Renderer.totalAddedItems++;
string techniqueName = "";
techniqueName = "Standard" + Renderer.GetTechniqueNameExtension(metaModel, settings, techniqueNames);
techniqueName += GetSplatTechniqueExtention(model, settings);
RenderSplatMesh r;
if (!SplatTechniques.TryGetValue(techniqueName, out r))
{
SplatTechniques[techniqueName] = r = new RenderSplatMesh();
}
r.Insert(model, entity, metaModel, metaName);
if (entity.Scene.DesignMode)
{
SplatObjects.Add(new Common.Tuple <Model9, Entity, string>(model, entity, metaName));
}
}
else if (metaModel.SkinnedMesh != null)
{
foreach (var SM in model.SkinnedMesh.MeshContainers)
{
if (SM.Second.SkinInfo != null)
{
//Renderer.totalAddedItems++;
string techniqueName = "SkinnedMesh" + techniqueNameEnding;
RenderTechnique r;
if (!Techniques.TryGetValue(techniqueName, out r))
{
Techniques[techniqueName] = r = new RenderTechnique();
}
r.Insert(model, entity, metaModel, metaName, model.SkinnedMesh, null, false);
}
else
{
//Renderer.totalAddedItems++;
RenderTechnique r;
if (!Techniques.TryGetValue("ShadowedSceneInstanced" + techniqueNameEnding, out r))
{
Techniques["ShadowedSceneInstanced" + techniqueNameEnding] = r = new RenderTechnique();
}
r.Insert(model, entity, metaModel, metaName, null, SM.Second.MeshData.Mesh, true);
}
}
}
else if (metaModel.XMesh != null)
{
//Renderer.totalAddedItems++;
RenderTechnique r;
if (!Techniques.TryGetValue("ShadowedSceneInstanced" + techniqueNameEnding, out r))
{
Techniques["ShadowedSceneInstanced" + techniqueNameEnding] = r = new RenderTechnique();
}
r.Insert(model, entity, metaModel, metaName, null, model.XMesh, false);
}
}
public void Update(Model9 model, float dtime, Matrix world)
{
if (model != null && model.SkinnedMesh != null)
{
#if PROFILE_ANIMATIONS
if (ResetMatricesStart != null)
{
ResetMatricesStart();
}
#endif
((CustomFrame)model.SkinnedMesh.RootFrame).ResetMatrices();
#if PROFILE_ANIMATIONS
if (ResetMatricesStop != null)
{
ResetMatricesStop();
}
if (SetupACStrat != null)
{
SetupACStrat();
}
#endif
if (TrackFadeTime[CurrentTrack] > 0)
{
#if DEBUG_ANIMATIONS
if (i % 15 == 0 && Entity.Name != "MainCharacter")
{
Console.WriteLine("Previous: " + (TrackFadeTime[CurrentTrack] / FadeTime));
Console.WriteLine("Current: " + (FadeTime - TrackFadeTime[CurrentTrack]) / FadeTime);
}
i++;
#endif
AnimationController.SetTrackWeight(previousTrack, TrackFadeTime[CurrentTrack] / FadeTime);
AnimationController.SetTrackWeight(CurrentTrack, (FadeTime - TrackFadeTime[CurrentTrack]) / FadeTime);
TrackFadeTime[CurrentTrack] -= dtime;
}
else
{
AnimationController.DisableTrack(previousTrack);
AnimationController.SetTrackSpeed(previousTrack, 0);
AnimationController.SetTrackWeight(previousTrack, 0);
AnimationController.SetTrackWeight(CurrentTrack, 1);
}
if (!TrackPaused[CurrentTrack] && !Looping[CurrentTrack])
{
if (TrackDurations[CurrentTrack] - dtime > 0)
{
TrackDurations[CurrentTrack] -= dtime;
}
else
{
TrackDurations[CurrentTrack] = 0;
AnimationController.SetTrackPosition(CurrentTrack, TrackDurations[CurrentTrack] - 0.01f);
AnimationController.SetTrackSpeed(CurrentTrack, 0);
TrackPaused[CurrentTrack] = true;
if (AnimationDone != null)
{
AnimationDone(0);
}
}
}
#if PROFILE_ANIMATIONS
if (SetupACStop != null)
{
SetupACStop();
}
if (AdvanceTimeStart != null)
{
AdvanceTimeStart();
}
#endif
AnimationController.AdvanceTime(dtime, null);
#if PROFILE_ANIMATIONS
if (AdvanceTimeStop != null)
{
AdvanceTimeStop();
}
if (AdjustFrameMatricesStrat != null)
{
AdjustFrameMatricesStrat();
}
#endif
foreach (var v in FrameCustomValues)
{
#if DEBUG
if (v.Value.M22 == float.NaN || v.Value.M21 == float.NaN || v.Value.M23 == float.NaN || v.Value.M24 == float.NaN)
{
throw new Exception("Matrix contains NaN");
}
#endif
model.SkinnedMesh.ForEachFrame((f) =>
{
if (f.Name == v.Key)
{
f.TransformationMatrix *= v.Value;
}
});
}
#if PROFILE_ANIMATIONS
if (AdjustFrameMatricesStop != null)
{
AdjustFrameMatricesStop();
}
if (UpdateMatricesStart != null)
{
UpdateMatricesStart();
}
#endif
model.SkinnedMesh.UpdateFrameMatrices(model.SkinnedMesh.RootFrame, world);
#if PROFILE_ANIMATIONS
if (UpdateMatricesStop != null)
{
UpdateMatricesStop();
}
if (StoreMatricesStart != null)
{
StoreMatricesStart();
}
#endif
foreach (var frame in SkinnedMesh.Frames)
{
if (frame.Name == "sword1" || frame.Name == "rifle" || frame.Name == "joint3")
{
FrameTransformation[frame] = frame.CombinedTransform;
}
}
foreach (Common.Tuple <CustomFrame, CustomMeshContainer> meshContainer in SkinnedMesh.MeshContainers)
{
string name = meshContainer.First.Name;
if (meshContainer.Second != null)
{
if (meshContainer.Second.SkinInfo != null)
{
BoneCombination[] combinations = meshContainer.Second.BoneCombinations;
Matrix[][] combinationMatrices = new Matrix[combinations.Length][];
for (int i = 0; i < combinations.Length; i++)
{
Matrix[] boneMatrices = new Matrix[meshContainer.Second.PaletteEntries];
for (int pe = 0; pe < meshContainer.Second.PaletteEntries; pe++)
{
int index = combinations[i].BoneIds[pe];
if (index != -1)
{
boneMatrices[pe] = meshContainer.Second.BoneOffsets[index] *
meshContainer.Second.BoneMatricesLookup[index].CombinedTransform;
}
}
combinationMatrices[i] = boneMatrices;
}
StoredFrameMatrices[meshContainer.Second.MeshData.Mesh] = combinationMatrices;
}
else
{
Matrix[][] combinedTransform = new Matrix[1][];
combinedTransform[0] = new Matrix[] { meshContainer.First.CombinedTransform };
StoredFrameMatrices[meshContainer.Second.MeshData.Mesh] = combinedTransform;
}
}
}
#if PROFILE_ANIMATIONS
if (StoreMatricesStop != null)
{
StoreMatricesStop();
}
#endif
//model.SkinnedMesh.ForEachFrame((frame) =>
//{
// FrameTransformation[frame] = frame.CombinedTransform;
// frame.ForEachMeshContainer((mc) =>
// {
// if (mc.SkinInfo != null)
// {
// BoneCombination[] combinations = mc.BoneCombinations;
// Common.Tuple<Matrix[], Matrix[]>[] combinationMatrices =
// new Common.Tuple<Matrix[], Matrix[]>[combinations.Length];
// for (int i = 0; i < combinations.Length; i++)
// {
// Matrix[] boneMatrices = new Matrix[mc.PaletteEntries];
// Matrix[] normalMatrices = new Matrix[mc.PaletteEntries];
// for (int pe = 0; pe < mc.PaletteEntries; pe++)
// {
// int index = combinations[i].BoneIds[pe];
// if (index != -1)
// {
// boneMatrices[pe] = mc.BoneOffsets[index] *
// mc.BoneMatricesLookup[index].CombinedTransform;
// normalMatrices[pe] = SlimDX.Matrix.Transpose(
// SlimDX.Matrix.Invert(boneMatrices[pe]));
// }
// }
// combinationMatrices[i] = new Common.Tuple<Matrix[], Matrix[]>(
// boneMatrices, normalMatrices);
// }
// StoredFrameMatrices[mc.MeshData.Mesh] = combinationMatrices;
// }
// else
// {
// Common.Tuple<Matrix[], Matrix[]>[] combinedTransform =
// new Common.Tuple<Matrix[], Matrix[]>[1];
// combinedTransform[0] = new Common.Tuple<Matrix[], Matrix[]>(
// new Matrix[1] { frame.CombinedTransform },
// new Matrix[1] { Matrix.Transpose(Matrix.Invert(frame.CombinedTransform)) });
// StoredFrameMatrices[mc.MeshData.Mesh] = combinedTransform;
// }
// });
//});
}
}
public void Insert(Model9 model, Entity e, MetaModel metaModel, string metaName)
{
RenderObjects.Add(new Common.Tuple <Model9, Entity, string>(model, e, metaName));
}
void RenderEntitiesWithEffect(Entity entity, Matrix combinedTransform, Matrix viewProjection, Matrix halfPixelOffset)
{
if (!entity.Visible)
{
return;
}
entity.EnsureConstructed(); // Force construct
if (entity.OrientationRelation == OrientationRelation.Relative)
{
combinedTransform *= entity.WorldMatrix;
}
else
{
combinedTransform = entity.WorldMatrix;
}
List <Common.Tuple <MetaResource <Model9, Model10>, Model9> > list = new List <Common.Tuple <MetaResource <Model9, Model10>, Model9> >();
foreach (var model in entity.AllGraphics)
{
if (model != null)
{
#if USE_PEEK
#if PROFILE_INTERFACERENDERER
if (PeekStart != null)
{
PeekStart();
}
#endif
Content.Model9 m;
if (!cachedGraphics.TryGetValue(model, out m))
{
m = cachedGraphics[model] = Scene.View.Content.Peek <Content.Model9>(model);
}
#if PROFILE_INTERFACERENDERER
if (PeekEnd != null)
{
PeekEnd();
}
#endif
#else
Model9 m = null;
if (model != null)
{
m = Resources[new Common.Tuple <Entity, MetaResourceBase>(entity, (MetaResourceBase)model)];
}
#endif
if (m != null && m.RenderedLast)
{
list.Add(new Common.Tuple <MetaResource <Model9, Model10>, Model9>(model, m)); // hack so important things can be rendered later in the process
}
else if (Drawable(entity))
{
RenderModelWithEffect(m, combinedTransform, viewProjection, halfPixelOffset, model);
}
}
}
foreach (var m in list)
{
if (Drawable(entity))
{
RenderModelWithEffect(m.Second, combinedTransform, viewProjection, halfPixelOffset, m.First);
}
}
foreach (var e in new List <Entity>(entity.Children))
{
RenderEntitiesWithEffect(e, combinedTransform, viewProjection, halfPixelOffset);
}
}
