public Skybox(GraphicsDevice device)
{
float x = 0.525731f;
float z = 0.850651f;
var vertices = new SkyboxVertex[12]
{
new SkyboxVertex(-x, 0f, z), new SkyboxVertex(x, 0f, z),
new SkyboxVertex(-x, 0f, -z), new SkyboxVertex(x, 0f, -z),
new SkyboxVertex(0f, z, x), new SkyboxVertex(0f, z, -x),
new SkyboxVertex(0f, -z, x), new SkyboxVertex(0f, -z, -x),
new SkyboxVertex(z, x, 0f), new SkyboxVertex(-z, x, 0f),
new SkyboxVertex(z, -x, 0f), new SkyboxVertex(-z, -x, 0f),
};
var indices = new int[60]
{
1,4,0, 4,9,0, 4,5,9, 8,5,4, 1,8,4,
1,10,8, 10,3,8, 8,3,5, 3,2,5, 3,7,2,
3,10,7, 10,6,7, 6,11,7, 6,0,11, 6,1,0,
10,1,6, 11,0,9, 2,11,9, 5,2,9, 11,2,7
};
vertexBuffer = Buffer<SkyboxVertex>.New(device, vertices, BufferFlags.VertexBuffer);
indexBuffer = Buffer<int>.New(device, indices, BufferFlags.IndexBuffer);
skyboxEffect = EffectLoader.Load(@"Graphics/Shaders/Skybox.fx");
skyboxTex = Texture2D.Load(device, @"G:\Users\Athrun\Documents\Stratum\trunk\src\Stratum\WorldEngine\Earth\milkyWay.tif");
}
protected virtual void TrackEffect(Effect effect)
{
if (!effectsToAlwaysCheck.Contains(effect))
{
effectsToAlwaysCheck.Add(effect);
}
}
public ParticleSystem(GraphicsDevice device, ContentManager content)
{
this.device = device;
// Create vertex buffer used to spawn new particles
this.particleStart = Buffer.Vertex.New<ParticleVertex>(device, MAX_NEW);
// Create vertex buffers to use for updating and drawing the particles alternatively
var vbFlags = BufferFlags.VertexBuffer | BufferFlags.StreamOutput;
this.particleDrawFrom = Buffer.New<ParticleVertex>(device, MAX_PARTICLES, vbFlags);
this.particleStreamTo = Buffer.New<ParticleVertex>(device, MAX_PARTICLES, vbFlags);
this.layout = VertexInputLayout.FromBuffer(0, this.particleStreamTo);
this.effect = content.Load<Effect>("ParticleEffect");
this.texture = content.Load<Texture2D>("Dot");
this.viewParameter = effect.Parameters["_view"];
this.projParameter = effect.Parameters["_proj"];
this.lookAtMatrixParameter = effect.Parameters["_lookAtMatrix"];
this.elapsedSecondsParameter = effect.Parameters["_elapsedSeconds"];
this.camDirParameter = effect.Parameters["_camDir"];
this.gravityParameter = effect.Parameters["_gravity"];
this.textureParameter = effect.Parameters["_texture"];
this.samplerParameter = effect.Parameters["_sampler"];
this.updatePass = effect.Techniques["UpdateTeq"].Passes[0];
this.renderPass = effect.Techniques["RenderTeq"].Passes[0];
}
/// <summary>
/// Draws all of the ModelMeshPart objects in this mesh, using their current Effect settings.
/// </summary>
/// <param name="context">The graphics context.</param>
/// <param name="boneTransforms">The model's bone transforms.</param>
/// <param name="effectOverride">The effect to use instead of the effect attached to each mesh part. Default is null (use Effect in MeshPart)</param>
/// <exception cref="System.InvalidOperationException">Model has no effect</exception>
public void Draw(GraphicsDevice context, Matrix[] boneTransforms, Effect effectOverride = null)
{
int count = this.MeshParts.Count;
for (int i = 0; i < count; i++)
{
ModelMeshPart part = MeshParts[i];
Effect effect = effectOverride ?? part.Effect;
if (effect == null)
{
throw new InvalidOperationException("ModelMeshPart has no effect and effectOverride is null");
}
var skinnedEffect = effect as SkinnedEffect;
int boneCount = part.SkinnedBones.Count;
if (skinnedEffect != null && boneCount > 0)
{
var transforms = new Matrix[boneCount];
for (int j = 0; j < boneCount; j++)
{
var skinnedBone = part.SkinnedBones[j];
Matrix.Multiply(ref skinnedBone.OffsetMatrix, ref boneTransforms[skinnedBone.Bone.Index], out transforms[j]);
}
skinnedEffect.SetBoneTransforms(transforms);
}
int passCount = effect.CurrentTechnique.Passes.Count;
for (int j = 0; j < passCount; j++)
{
effect.CurrentTechnique.Passes[j].Apply();
part.Draw(context);
}
}
}
protected virtual void TrackEffect(Effect effect)
{
var fileList = compiler.LoadDependency(effect.RawEffectData.Arguments.DependencyFilePath);
List<FileSystemWatcher> watchers;
if (!effectsToWatcher.TryGetValue(effect, out watchers))
{
watchers = new List<FileSystemWatcher>();
effectsToWatcher.Add(effect, watchers);
}
var dirList = GetDirectoryList(fileList);
var currentWatchers = new List<FileSystemWatcher>();
foreach (var dirPath in dirList)
{
// Try to find an existing watcher
var watcher = FindWatcher(watchers, dirPath) ?? FindWatcher(watcherToEffects.Keys, dirPath);
if (watcher == null)
{
watcher = new FileSystemWatcher(dirPath);
var effectPerWatch = new List<Effect> { effect };
watcherToEffects.Add(watcher, effectPerWatch);
watcher.Changed += watcher_Changed;
watcher.EnableRaisingEvents = true;
}
else
{
var effectPerWatch = watcherToEffects[watcher];
if (!effectPerWatch.Contains(effect))
{
effectPerWatch.Add(effect);
}
}
if (!watchers.Contains(watcher))
{
watchers.Add(watcher);
}
if (!currentWatchers.Contains(watcher))
{
currentWatchers.Add(watcher);
}
}
// Release any previous watcher allocated that are no longer needed.
foreach (var watcher in watchers)
{
if (!currentWatchers.Contains(watcher))
{
RemoveEffectFromWatcher(effect, watcher);
}
}
// Update the list of watchers for the specified effect
watchers.Clear();
watchers.AddRange(currentWatchers);
}
protected override void LoadContent()
{
base.LoadContent();
spriteBatch = ToDisposeContent(new SpriteBatch(GraphicsDevice));
texture = Content.Load<Texture2D>("Input");
customEffect = Content.Load<Effect>("Effect");
}
public virtual void Initialize()
{
GraphicsDevice device = Engine.GraphicsContext.Device;
wireFrame = EffectLoader.Load(@"World/Earth/Shaders/DeferredTerrain.fx");
vertexBuffer = Buffer<TerrainVertex>.New<TerrainVertex>(device, SharpDX.Utilities.SizeOf<TerrainVertex>() * 4 * 1000, BufferFlags.VertexBuffer, SharpDX.Direct3D11.ResourceUsage.Dynamic);
}
public Monkey(Project2Game game, Model model, Vector3 position)
: base(game, model, position)
{
// Load custom rainbox monkey effect
effect = game.Content.Load<Effect>("Shaders\\Cel");
PhysicsDescription.Mass = 20f;
//PhysicsDescription.Tag = "player";
}
public Boid(Project2Game game, Flock flock, Model model, Vector3 position, Flock.BoidType boidType)
: base(game, model, position)
{
this.health = maxHealth;
this.PhysicsDescription.Mass = 0.25f;
this.boidType = boidType;
this.flock = flock;
this.game.physics.World.CollisionSystem.CollisionDetected += HandleCollision;
effect = game.Content.Load<Effect>("Shaders\\Cel");
}
/// <summary>
/// Initializes a new instance of the <see cref="EffectDefaultParameters"/> struct.
/// </summary>
/// <param name="effect">The effect.</param>
public EffectDefaultParameters(Effect effect)
{
// Initialize predefined parameters used by Model.Draw (to speedup things internally)
WorldParameter = effect.Parameters["World"];
ViewParameter = effect.Parameters["View"];
ViewInverseParameter = effect.Parameters["ViewInverse"];
ProjectionParameter = effect.Parameters["Projection"];
WorldViewParameter = effect.Parameters["WorldView"];
ViewProjectionParameter = effect.Parameters["ViewProjection"] ?? effect.Parameters["ViewProj"];
WorldInverseTransposeParameter = effect.Parameters["WorldInverseTranspose"];
WorldInverseTransposeViewParameter = effect.Parameters["WorldInverseTransposeView"];
WorldViewProjectionParameter = effect.Parameters["WorldViewProj"] ?? effect.Parameters["WorldViewProjection"];
}
public GameModel(Model model, Game game, float x, float y, float z)
{
this.game = (Project2Game) game;
this.model = model;
effect = game.Content.Load<Effect>("ObjectShader");
this.position = new Vector3(x, y, z);
World = Matrix.Identity;
lightPointPositions = new [] {
new Vector3(0, 180, 0),
new Vector3(-this.game.landscape.baord_size_public , 180, 0),
new Vector3(this.game.landscape.baord_size_public, 180, this.game.landscape.baord_size_public)
};
}
protected override void LoadContent()
{
// Importer for many models
var importer = new AssimpImporter();
// Load a specific model
//string fileName = System.IO.Path.GetFullPath(Content.RootDirectory + "/tower.3ds");
//Scene scene = importer.ImportFile(fileName, PostProcessSteps.MakeLeftHanded);
//m_model = new Model(scene, GraphicsDevice, Content);
// Load shader
EffectCompilerFlags compilerFlags = EffectCompilerFlags.None;
EffectCompiler compiler = new EffectCompiler();
#if DEBUG
compilerFlags |= EffectCompilerFlags.Debug;
#endif
var simpleShaderCompileResult = compiler.CompileFromFile(Content.RootDirectory + "/pointlight.fx", compilerFlags);
if (simpleShaderCompileResult.HasErrors)
{
System.Console.WriteLine(simpleShaderCompileResult.Logger.Messages);
System.Diagnostics.Debugger.Break();
}
m_simpleEffect = new SharpDX.Toolkit.Graphics.Effect(GraphicsDevice, simpleShaderCompileResult.EffectData);
m_simpleEffect.Parameters["diffuseSampler"].SetResource(m_linearSamplerState);
base.LoadContent();
map = new Map(@"Content\map.PNG", new Size2(20, 20));
map.LoadContent(GraphicsDevice, Content);
player = new Player(new Vector3(0.0f, 10.0f, 0.0f), GraphicsDevice);
player.Map = map;
spritebatch = new SpriteBatch(GraphicsDevice, 2048);
compass = Content.Load <Texture2D>("compass.png");
torch = Content.Load <Texture2D>("torchPlaceholder.png");
compassNeedle = Content.Load <Texture2D>("needle.png");
particle = Content.Load <Texture2D>("particle.png");
gameOver = Content.Load <Texture2D>("gameover.png");
emitter.position = new Vector2(width - torch.Width / 3, height - torch.Height / 3);
}
protected override void LoadContent()
{
// Loads the effect
metaTunnelEffect = Content.Load<Effect>("metatunnel.fxo");
// Prepare a quad buffer
quadVertices = Buffer.Vertex.New(
GraphicsDevice,
new[]
{
new VertexPositionTexture(new Vector3(-1, 1, 0), new Vector2(0, 0)),
new VertexPositionTexture(new Vector3(1, 1, 0), new Vector2(1, 0)),
new VertexPositionTexture(new Vector3(-1, -1, 0), new Vector2(0, 1)),
new VertexPositionTexture(new Vector3(1, -1, 0), new Vector2(1, 1)),
});
// Create an input layout from the vertices
inputLayout = VertexInputLayout.FromBuffer(0, quadVertices);
}
// DepthStencilState _depthStencilDrawWhereNothing;
public Background(GraphicsDevice graphicsDevice)
{
/* var depthStencilStateDesc = SharpDX.Direct3D11.DepthStencilStateDescription.Default();
depthStencilStateDesc.IsDepthEnabled = false;
depthStencilStateDesc.DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.Zero;
_noDepthState = DepthStencilState.New(graphicsDevice, "NoZBuffer", depthStencilStateDesc);*/
EffectCompilerFlags compilerFlags = EffectCompilerFlags.None;
#if DEBUG
compilerFlags |= EffectCompilerFlags.Debug;
#endif
var shaderCompileResult = EffectCompiler.CompileFromFile("Content/sky.fx", compilerFlags);
if (shaderCompileResult.HasErrors)
{
System.Console.WriteLine(shaderCompileResult.Logger.Messages);
System.Diagnostics.Debugger.Break();
}
_effect = new SharpDX.Toolkit.Graphics.Effect(graphicsDevice, shaderCompileResult.EffectData);
}
/// <summary>
/// Draws all of the ModelMeshPart objects in this mesh, using their current Effect settings.
/// </summary>
/// <param name="context">The graphics context.</param>
/// <param name="effectOverride">The effect to use instead of the effect attached to each mesh part. Default is null (use Effect in MeshPart)</param>
/// <exception cref="System.InvalidOperationException">Model has no effect</exception>
public void Draw(GraphicsDevice context, Effect effectOverride = null)
{
int count = this.MeshParts.Count;
for (int i = 0; i < count; i++)
{
ModelMeshPart part = MeshParts[i];
Effect effect = effectOverride ?? part.Effect;
if (effect == null)
{
throw new InvalidOperationException("ModelMeshPart has no effect and effectOverride is null");
}
int passCount = effect.CurrentTechnique.Passes.Count;
for (int j = 0; j < passCount; j++)
{
effect.CurrentTechnique.Passes[j].Apply();
part.Draw(context);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimitiveQuad" /> class.
/// </summary>
/// <param name="graphicsDevice">The graphics device.</param>
public PrimitiveQuad(GraphicsDevice graphicsDevice)
{
GraphicsDevice = graphicsDevice;
quadEffect = ToDispose(new Effect(GraphicsDevice, effectBytecode));
quadPass = quadEffect.CurrentTechnique.Passes[0];
matrixParameter = quadEffect.Parameters["MatrixTransform"];
textureCopyPass = quadEffect.CurrentTechnique.Passes[1];
textureParameter = quadEffect.Parameters["Texture"];
colorParameter = quadEffect.Parameters["Color"];
textureSamplerParameter = quadEffect.Parameters["TextureSampler"];
// Default LinearClamp
textureSamplerParameter.SetResource(GraphicsDevice.SamplerStates.LinearClamp);
Transform = Matrix.Identity;
Color = new Color4(1.0f);
sharedData = GraphicsDevice.GetOrCreateSharedData(SharedDataType.PerDevice, "Toolkit::PrimitiveQuad::VertexBuffer", () => new SharedData(GraphicsDevice));
}
public static void drawModel(Model model, GraphicsDevice graphicsDevice, SharpDX.Toolkit.Graphics.Effect effect, Matrix transformation, Player player, GameTime gameTime)
{
// Fill the one constant buffer. Hint: it is not necessary to set
// things which did not change each frame. But in our case everything
// is changing
var transformCB = effect.ConstantBuffers["Transforms"];
transformCB.Parameters["worldViewProj"].SetValue(transformation * player.Cam.ViewProjection);
transformCB.Parameters["world"].SetValue(transformation);
Matrix worldInvTr = Helpers.CreateInverseTranspose(ref transformation);
transformCB.Parameters["worldInvTranspose"].SetValue(worldInvTr);
// Slow rotating light
double angle = -gameTime.TotalGameTime.TotalMilliseconds / 3000.0;
//transformCB.Parameters["lightPos"].SetValue(new Vector3((float)Math.Sin(angle) * 50.0f, 30.0f, (float)Math.Cos(angle) * 50.0f));
//transformCB.Parameters["lightPos"].SetValue(player.Position);
// Draw model
//effect.CurrentTechnique.Passes[0].Apply();
model.Draw(graphicsDevice, effect);
}
public VisionEffect(Effect effect, SamplerState samplerState = null)
{
GraphicsDevice = effect.GraphicsDevice;
Effect = effect;
Name = effect.Name;
_epTextureSampler = effect.Parameters["TextureSampler"];
if(_epTextureSampler!=null)
Sampler = samplerState ?? GraphicsDevice.SamplerStates.LinearWrap;
_epWorld = effect.Parameters["World"];
_epWorldInverseTranspose = effect.Parameters["WorldInverseTranspose"];
_epView = effect.Parameters["View"];
_epProjection = effect.Parameters["Projection"];
_epCameraPosition = effect.Parameters["CameraPosition"];
_epClipPlane = effect.Parameters["ClipPlane"];
_epSunlightDirection = effect.Parameters["SunlightDirection"];
_epTexture = effect.Parameters["Texture"];
_epDiffuseColor = effect.Parameters["DiffuseColor"];
_epDoShadowMapping = effect.Parameters["DoShadowMapping"];
_epShadowMap = effect.Parameters["ShadowMap"];
_epShadowViewProjection = effect.Parameters["ShadowViewProjection"];
_epShadowFarPlane = effect.Parameters["ShadowFarPlane"];
_epShadowMult = effect.Parameters["ShadowMult"];
_techStandard = effect.Techniques["TechStandard"];
_techClipPlane = effect.Techniques["TechClipPlane"];
_techDepthMap = effect.Techniques["TechDepthMap"];
//Debug.Assert( _epView != null );
//Debug.Assert(_techDepthMap != null);
if ( _epSunlightDirection != null)
_epSunlightDirection.SetValue(VisionContent.SunlightDirection);
}
private void RemoveEffect(Effect effect)
{
if (effect.IsSupportingDynamicCompilation)
{
lock (effectsCompilable)
{
effectsCompilable.Remove(effect);
UnTrackEffect(effect);
}
}
}
private void AddEffect(Effect effect)
{
if (effect.IsSupportingDynamicCompilation)
{
lock (effectsCompilable)
{
effectsCompilable.Add(effect);
TrackEffect(effect);
}
}
}
protected virtual void UnTrackEffect(Effect effect)
{
effectsToAlwaysCheck.Remove(effect);
}
/// <summary>
/// Render a model after applying the matrix transformations.
/// </summary>
/// <param name="context">The <see cref="GraphicsDevice"/> context.</param>
/// <param name="world">A world transformation matrix.</param>
/// <param name="view">A view transformation matrix.</param>
/// <param name="projection">A projection transformation matrix.</param>
/// <param name="effectOverride">An effect instance that will override all effects attached to this model. Null by default (no override)</param>
/// <exception cref="System.InvalidOperationException">Mesh has no effect and effectOverride is null</exception>
public unsafe void Draw(GraphicsDevice context, Matrix world, Matrix view, Matrix projection, Effect effectOverride = null)
{
int count = Meshes.Count;
int boneCount = Bones.Count;
Matrix *localSharedDrawBoneMatrices = stackalloc Matrix[boneCount]; // TODO use a global cache as BoneCount could generate a StackOverflow
CopyAbsoluteBoneTransformsTo(new IntPtr(localSharedDrawBoneMatrices));
var defaultParametersContext = default(EffectDefaultParametersContext);
for (int i = 0; i < count; i++)
{
var mesh = Meshes[i];
int index = mesh.ParentBone.Index;
int effectCount = mesh.Effects.Count;
if (effectOverride != null)
{
Matrix worldTranformed;
Matrix.Multiply(ref localSharedDrawBoneMatrices[index], ref world, out worldTranformed);
effectOverride.DefaultParameters.Apply(ref defaultParametersContext, ref worldTranformed, ref view, ref projection);
}
else
{
for (int j = 0; j < effectCount; j++)
{
var effect = mesh.Effects[j];
if (effect == null)
{
throw new InvalidOperationException("Mesh has no effect and effectOverride is null");
}
Matrix worldTranformed;
Matrix.Multiply(ref localSharedDrawBoneMatrices[index], ref world, out worldTranformed);
var matrices = effect as IEffectMatrices;
if (matrices == null)
{
effect.DefaultParameters.Apply(ref defaultParametersContext, ref worldTranformed, ref view, ref projection);
}
else
{
matrices.World = worldTranformed;
matrices.View = view;
matrices.Projection = projection;
}
}
}
mesh.Draw(context, effectOverride);
}
}
// Updates the parameters
public void SetLighting(Effect effect)
{
effect.Parameters["lightAmbCol"].SetValue(ambientCol);
effect.Parameters["lights"].SetValue(packedLights);
}
/// <summary>
/// Draws the specified effect onto the quad. The effect must have a pixel shader with the signature float2:TEXCOORD.
/// </summary>
/// <param name="effect">The effect.</param>
/// <param name="fullScreenTriangle">if set to <c>true</c> to draw an optimized full screen triangle as a full screen quad.</param>
public void Draw(Effect effect, bool fullScreenTriangle = false)
{
GraphicsDevice.SetVertexBuffer(fullScreenTriangle ? sharedData.VertexBufferFullQuad : sharedData.VertexBuffer);
GraphicsDevice.SetVertexInputLayout(sharedData.VertexInputLayout);
ResetShaderStages();
foreach (var pass in effect.CurrentTechnique.Passes)
{
// Apply the Effect pass
pass.Apply();
// Make sure that we are using our vertex shader
quadPass.Apply();
GraphicsDevice.Draw(PrimitiveType.TriangleStrip, fullScreenTriangle ? 3 : 4);
// Reset the quadPass and custom pass
quadPass.UnApply();
pass.UnApply();
}
// Reset the vertex buffer
GraphicsDevice.SetVertexBuffer(0, null, 0);
GraphicsDevice.InputAssemblerStage.SetInputLayout(null);
}
protected override void Update(GameTime gameTime)
{
base.Update(gameTime);
// check if data needs to be recreated
if (_data.IsDirty)
{
// dispose old effect
Utilities.Dispose(ref _effect);
// rebuild the effect
var effectData = _builder.Rebuild();
if (effectData != null)
// instantiate new effect from the built data
_effect = ToDispose(new Effect(GraphicsDevice, effectData));
}
}
/// <summary>
/// Binds the specified effect data to this instance.
/// </summary>
/// <param name="effectDataArg">The effect data arg.</param>
/// <param name="cloneFromEffect">The clone from effect.</param>
/// <exception cref="System.InvalidOperationException">If no techniques found in this effect.</exception>
/// <exception cref="System.ArgumentException">If unable to find effect [effectName] from the EffectPool.</exception>
internal void InitializeFrom(EffectData.Effect effectDataArg, Effect cloneFromEffect)
{
RawEffectData = effectDataArg;
// Clean any previously allocated resources
if (DisposeCollector != null)
{
DisposeCollector.DisposeAndClear();
}
ConstantBuffers.Clear();
Parameters.Clear();
Techniques.Clear();
ResourceLinker = ToDispose(new EffectResourceLinker());
if (effectConstantBuffersCache != null)
{
effectConstantBuffersCache.Clear();
}
// Copy data
IsSupportingDynamicCompilation = RawEffectData.Arguments != null;
ShareConstantBuffers = RawEffectData.ShareConstantBuffers;
// Create the local effect constant buffers cache
if (!ShareConstantBuffers)
effectConstantBuffersCache = new Dictionary<EffectConstantBufferKey, EffectConstantBuffer>();
var logger = new Logger();
int techniqueIndex = 0;
int totalPassCount = 0;
EffectPass parentPass = null;
foreach (var techniqueRaw in RawEffectData.Techniques)
{
var name = techniqueRaw.Name;
if (string.IsNullOrEmpty(name))
name = string.Format("${0}", techniqueIndex++);
var technique = new EffectTechnique(this, name);
Techniques.Add(technique);
int passIndex = 0;
foreach (var passRaw in techniqueRaw.Passes)
{
name = passRaw.Name;
if (string.IsNullOrEmpty(name))
name = string.Format("${0}", passIndex++);
var pass = new EffectPass(logger, this, technique, passRaw, name);
pass.Initialize(logger);
// If this is a subpass, add it to the parent pass
if (passRaw.IsSubPass)
{
if (parentPass == null)
{
logger.Error("Pass [{0}] is declared as a subpass but has no parent.");
}
else
{
parentPass.SubPasses.Add(pass);
}
}
else
{
technique.Passes.Add(pass);
parentPass = pass;
}
}
// Count the number of passes
totalPassCount += technique.Passes.Count;
}
if (totalPassCount == 0)
throw new InvalidOperationException("No passes found in this effect.");
// Log all the exception in a single throw
if (logger.HasErrors)
throw new InvalidOperationException(Utilities.Join("\n", logger.Messages));
// Initialize the resource linker when we are done with all pass/parameters
ResourceLinker.Initialize();
//// Sort all parameters by their resource types
//// in order to achieve better local cache coherency in resource linker
Parameters.Items.Sort((left, right) =>
{
// First, order first all value types, then resource type
var comparison = left.IsValueType != right.IsValueType ? left.IsValueType ? -1 : 1 : 0;
// If same type
if (comparison == 0)
{
// Order by resource type
comparison = ((int)left.ResourceType).CompareTo((int)right.ResourceType);
// If same, order by resource index
if (comparison == 0)
{
comparison = left.Offset.CompareTo(right.Offset);
}
}
return comparison;
});
// Prelink constant buffers
int resourceIndex = 0;
foreach (var parameter in Parameters)
{
// Recalculate parameter resource index
if (!parameter.IsValueType)
{
parameter.Offset = resourceIndex++;
}
// Set the default values
parameter.SetDefaultValue();
if (parameter.ResourceType == EffectResourceType.ConstantBuffer)
parameter.SetResource(ConstantBuffers[parameter.Name]);
}
// Compute slot links
foreach (var technique in Techniques)
{
foreach (var pass in technique.Passes)
{
foreach (var subPass in pass.SubPasses)
{
subPass.ComputeSlotLinks();
}
pass.ComputeSlotLinks();
}
}
// Setup the first Current Technique.
CurrentTechnique = this.Techniques[0];
// Initialize predefined parameters used by Model.Draw (to speedup things internally)
DefaultParameters = new EffectDefaultParameters(this);
// If this is a clone, we need to
if (cloneFromEffect != null)
{
// Copy the content of the constant buffers to the new instance.
for (int i = 0; i < ConstantBuffers.Count; i++)
{
cloneFromEffect.ConstantBuffers[i].CopyTo(ConstantBuffers[i]);
}
// Copy back all bound resources except constant buffers
// that are already initialized with InitializeFrom method.
for (int i = 0; i < cloneFromEffect.ResourceLinker.Count; i++)
{
if (cloneFromEffect.ResourceLinker.BoundResources[i] is EffectConstantBuffer)
continue;
ResourceLinker.BoundResources[i] = cloneFromEffect.ResourceLinker.BoundResources[i];
unsafe
{
ResourceLinker.Pointers[i] = cloneFromEffect.ResourceLinker.Pointers[i];
}
}
// If everything was fine, then we can register it into the pool
Pool.AddEffect(this);
}
// Allow subclasses to complete initialization.
Initialize();
}
/// <summary>
/// Render a model after applying the matrix transformations.
/// </summary>
/// <param name="context">The <see cref="GraphicsDevice"/> context.</param>
/// <param name="world">A world transformation matrix.</param>
/// <param name="view">A view transformation matrix.</param>
/// <param name="projection">A projection transformation matrix.</param>
/// <param name="effectOverride">An effect instance that will override all effects attached to this model. Null by default (no override)</param>
/// <exception cref="System.InvalidOperationException">Mesh has no effect and effectOverride is null</exception>
public unsafe void Draw(GraphicsDevice context, Matrix world, Matrix view, Matrix projection, Effect effectOverride = null)
{
int count = Meshes.Count;
int boneCount = Bones.Count;
if (sharedDrawBones == null || sharedDrawBones.Length < boneCount)
{
sharedDrawBones = new Matrix[boneCount];
}
CopyAbsoluteBoneTransformsTo(sharedDrawBones);
var defaultParametersContext = default(EffectDefaultParametersContext);
for (int i = 0; i < count; i++)
{
var mesh = Meshes[i];
int index = mesh.ParentBone.Index;
int effectCount = mesh.Effects.Count;
if (effectOverride != null)
{
if (effectOverride is SkinnedEffect)
{
effectOverride.DefaultParameters.Apply(ref defaultParametersContext, ref world, ref view, ref projection);
}
else
{
Matrix worldTranformed;
Matrix.Multiply(ref sharedDrawBones[index], ref world, out worldTranformed);
effectOverride.DefaultParameters.Apply(ref defaultParametersContext, ref worldTranformed, ref view, ref projection);
}
}
else
{
for (int j = 0; j < effectCount; j++)
{
var effect = mesh.Effects[j];
if (effect == null)
{
throw new InvalidOperationException("Mesh has no effect and effectOverride is null");
}
Matrix worldTranformed;
Matrix.Multiply(ref sharedDrawBones[index], ref world, out worldTranformed);
var matrices = effect as IEffectMatrices;
if (matrices == null)
{
effect.DefaultParameters.Apply(ref defaultParametersContext, ref world, ref view, ref projection);
}
else
{
matrices.World = effect is SkinnedEffect ? world : worldTranformed;
matrices.View = view;
matrices.Projection = projection;
}
}
}
mesh.Draw(context, sharedDrawBones, effectOverride);
}
}
public void Draw(Player player, GraphicsDevice graphicsDevice, SharpDX.Toolkit.Graphics.Effect effect, GameTime gameTime)
{
Matrix transformation = Matrix.Identity;
if (player.IsMoving)
{
player.Height = (float)Math.Pow(Math.Sin(player.MovingTime.TotalSeconds * 5), 2) * 0.8f + 15;
}
else
{
player.Height = Math.Max(player.Height - 3f * (float)gameTime.ElapsedGameTime.TotalSeconds, 15);
}
var transformCB = effect.ConstantBuffers["Transforms"];
transformCB.Parameters["worldViewProj"].SetValue(player.Cam.viewProjection);
transformCB.Parameters["world"].SetValue(ref player.Cam.view);
Matrix worldInvTr = Helpers.CreateInverseTranspose(ref player.Cam.view);
transformCB.Parameters["worldInvTranspose"].SetValue(ref worldInvTr);
transformCB.Parameters["cameraPos"].SetValue(player.Position);
var lightCB = effect.ConstantBuffers["Lights"];
lightCB.Parameters["lightDir"].SetValue(new Vector3(0));
lightCB.Parameters["specularPower"].SetValue(0);
lightCB.Parameters["dirLightColor"].SetValue(new Vector3(0.0f));
lightCB.Parameters["numPointLights"].SetValue(1);
PointLight[] pointLights = new PointLight[1];
pointLights[0].Set(10.0f, 60.0f + 7.5f + (player.IsMoving ? 2 : 1) * 2 * (float)Math.Pow(Math.Sin(gameTime.TotalGameTime.TotalMilliseconds / 150), 1) * 2);
pointLights[0].pos = player.Position;
//pointLights[0].color = (Vector3.Lerp(Color.White.ToVector3(), Vector3.Lerp(Color.DarkOrange.ToVector3(), Color.Yellow.ToVector3(), (float)(Math.Pow(Math.Sin(gameTime.TotalGameTime.TotalMilliseconds / 600), 2f)) * 0.5f), 0.5f));
pointLights[0].color = Color.White.ToVector3() * 0.5f;
lightCB.Parameters["lights"].SetValue(pointLights);
Point playerTilePosition = worldToTileCoordinates(player.Position);
const int DRAWING_RANGE = 5;
for (int x = playerTilePosition.X - DRAWING_RANGE; x <= playerTilePosition.X + DRAWING_RANGE; ++x)
{
for (int y = playerTilePosition.Y - DRAWING_RANGE; y <= playerTilePosition.Y + DRAWING_RANGE; ++y)
{
transformation = Matrix.Translation((x + 0.5f) * tileSize.Width, -player.Height, (y + 0.5f) * tileSize.Height);
if (x >= 0 && y >= 0 && x <= tiles.GetUpperBound(0) && y <= tiles.GetUpperBound(1))
{
switch (tiles[x, y])
{
case TileType.Wall:
Helpers.drawModel(wallModel, graphicsDevice, effect, transformation, player, gameTime);
break;
}
}
else
{
Helpers.drawModel(wallModel, graphicsDevice, effect, transformation, player, gameTime);
}
transformation *= Matrix.Translation(0, 25, 0);
Helpers.drawModel(ceilingModel, graphicsDevice, effect, transformation, player, gameTime);
}
}
for (int x = playerTilePosition.X - DRAWING_RANGE; x <= playerTilePosition.X + DRAWING_RANGE; ++x)
{
for (int y = playerTilePosition.Y - DRAWING_RANGE; y <= playerTilePosition.Y + DRAWING_RANGE; ++y)
{
if (x >= 0 && y >= 0 && x <= tiles.GetUpperBound(0) && y <= tiles.GetUpperBound(1))
{
switch (tiles[x, y])
{
case TileType.Wall:
transformation = Matrix.Translation((x + 0.5f) * tileSize.Width, -player.Height, (y + 0.5f) * tileSize.Height);
Helpers.drawModel(wallModel, graphicsDevice, effect, transformation, player, gameTime);
break;
}
}
}
}
for (int x = playerTilePosition.X - DRAWING_RANGE; x <= playerTilePosition.X + DRAWING_RANGE; ++x)
{
for (int y = playerTilePosition.Y - DRAWING_RANGE; y <= playerTilePosition.Y + DRAWING_RANGE; ++y)
{
if (x >= 0 && y >= 0 && x <= tiles.GetUpperBound(0) && y <= tiles.GetUpperBound(1))
{
switch (tiles[x, y])
{
case TileType.Floor_With_Key:
transformation = Matrix.Translation((x + 0.5f) * tileSize.Width, -player.Height, (y + 0.5f) * tileSize.Height);
Helpers.drawModel(floorKeyModel, graphicsDevice, effect, transformation, player, gameTime);
Helpers.drawModel(floorModel, graphicsDevice, effect, transformation, player, gameTime);
break;
}
}
}
}
for (int x = playerTilePosition.X - DRAWING_RANGE; x <= playerTilePosition.X + DRAWING_RANGE; ++x)
{
for (int y = playerTilePosition.Y - DRAWING_RANGE; y <= playerTilePosition.Y + DRAWING_RANGE; ++y)
{
if (x >= 0 && y >= 0 && x <= tiles.GetUpperBound(0) && y <= tiles.GetUpperBound(1))
{
switch (tiles[x, y])
{
case TileType.Door:
transformation = Matrix.Translation((x + 0.5f) * tileSize.Width, -player.Height, (y + 0.5f) * tileSize.Height);
Helpers.drawModel(doorModel, graphicsDevice, effect, transformation, player, gameTime);
break;
}
}
}
}
for (int x = playerTilePosition.X - DRAWING_RANGE; x <= playerTilePosition.X + DRAWING_RANGE; ++x)
{
for (int y = playerTilePosition.Y - DRAWING_RANGE; y <= playerTilePosition.Y + DRAWING_RANGE; ++y)
{
if (x >= 0 && y >= 0 && x <= tiles.GetUpperBound(0) && y <= tiles.GetUpperBound(1))
{
switch (tiles[x, y])
{
case TileType.Floor:
transformation = Matrix.Translation((x + 0.5f) * tileSize.Width, -player.Height, (y + 0.5f) * tileSize.Height);
Helpers.drawModel(floorModel, graphicsDevice, effect, transformation, player, gameTime);
break;
}
}
}
}
for (int x = playerTilePosition.X - DRAWING_RANGE; x <= playerTilePosition.X + DRAWING_RANGE; ++x)
{
for (int y = playerTilePosition.Y - DRAWING_RANGE; y <= playerTilePosition.Y + DRAWING_RANGE; ++y)
{
if (x >= 0 && y >= 0 && x <= tiles.GetUpperBound(0) && y <= tiles.GetUpperBound(1))
{
switch (tiles[x, y])
{
case TileType.Goal:
transformation = Matrix.Translation((x + 0.5f) * tileSize.Width, -player.Height, (y + 0.5f) * tileSize.Height);
Helpers.drawModel(floorModel, graphicsDevice, effect, transformation, player, gameTime);
break;
}
}
}
}
}
protected override void LoadContent()
{
_genGBuffer = new Effect(GraphicsDevice, VectorUtils.CompileEffect("shaders/genGBuffer.hlsl"));
_genShadowBuffer = new Effect(GraphicsDevice, VectorUtils.CompileEffect("shaders/genShadowBuffer.hlsl"));
_shadeGBuffer = new ShadeGBufferEffect(GraphicsDevice);
_sponzaMeshes = ToGfxMeshes(LoadObj(@"assets/obj/crytek-sponza/sponza.obj"));
_headMesh = ToGfxMeshes(LoadObj(@"assets/obj/head/head.obj"));
base.LoadContent();
}
private void RemoveEffectFromWatcher(Effect effect, FileSystemWatcher watcher)
{
var listOfEffect = watcherToEffects[watcher];
listOfEffect.Remove(effect);
if (listOfEffect.Count == 0)
{
watcher.EnableRaisingEvents = false;
watcher.Changed -= watcher_Changed;
watcher.Dispose();
watcherToEffects.Remove(watcher);
}
}
public EffectToRebind(Effect effect, EffectData effectData)
{
Effect = effect;
EffectData = effectData;
}
public Platform(ProjectGame game)
{
// Avoid null reference, it changes on the first update
if (standing_platform == null)
{
standing_platform = this;
next_standing_platform = this;
}
// Less tiles if the difficulty is higher
min_extra_tiles = (int)(max_extra_tiles - game.difficulty);
type = GameObjectType.Platform;
//Load textures
textureName = "Platform_Textures";
texture = game.Content.Load<Texture2D>(textureName);
// Store information of the platform and create information for the next one
platform = next_platform;
next_platform = create_platform(platform);
// Create the vertices based on the platform information
VertexPositionNormalTexture[] platform_vertices = create_vertices(platform, last_platform, next_platform);
last_platform = platform;
// Set the platform Z position of the intance and uptade the new Z position for the next one
z_position_start = z_position;
z_position -= tile_depth;
z_position_end = z_position;
// Calculates midpoint and base
platfom_midpoint = (platform.GetLength(0) * tile_width) - tile_width/2;
platform_base = Levels[0] - base_offset;
//Load effects
effect = game.Content.Load<Effect>("Phong");
lightManager = new LightManager(game);
lightManager.SetLighting(effect);
// Pass the vertices data
vertices = Buffer.Vertex.New(game.GraphicsDevice, platform_vertices);
inputLayout = VertexInputLayout.FromBuffer(0, vertices);
this.game = game;
}
/// <summary>
/// Draws this <see cref="GeometricPrimitive" /> using an optional effect. See remarks.
/// </summary>
/// <param name="effect">The effect. Null by default.</param>
/// <remarks>If an effect is passed to this method, a draw will be issued for each passes defined in the current technique of the effect.
/// If no effect are passed, it is expected that an <see cref="EffectPass"/> was previously applied.
/// </remarks>
public void Draw(Effect effect = null)
{
Draw(GraphicsDevice, effect);
}
public void Initialize()
{
cube = GeometricPrimitive.Cube.New(graphicsDevice);
var cubeBounds = new OrientedBoundingBox(new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(0.5f, 0.5f, 0.5f));
cubeMesh = new RenderMesh {
BoundingBox = cubeBounds,
IndexBuffer = cube.IndexBuffer,
IsIndex32Bits = cube.IsIndex32Bits,
InputLayout = VertexInputLayout.New<VertexPositionNormalTexture>(0),
ModelTransform = Matrix.Identity,
VertexBuffer = cube.VertexBuffer
};
basicEffect = new BasicEffect(graphicsDevice);
basicEffect.EnableDefaultLighting(); // enable default lightning, useful for quick prototyping
var debugEffectCompilerResult = new EffectCompiler().CompileFromFile("shaders/debug_solid.hlsl", EffectCompilerFlags.Debug);
debugEffect = new Effect(graphicsDevice, debugEffectCompilerResult.EffectData, graphicsDevice.DefaultEffectPool);
debugBatch = new PrimitiveBatch<VertexPositionColor>(graphicsDevice);
}
/// <summary>
/// Render a model after applying the matrix transformations.
/// </summary>
/// <param name="context">The <see cref="GraphicsDevice"/> context.</param>
/// <param name="world">A world transformation matrix.</param>
/// <param name="view">A view transformation matrix.</param>
/// <param name="projection">A projection transformation matrix.</param>
/// <param name="effectOverride">An effect instance that will override all effects attached to this model. Null by default (no override)</param>
/// <exception cref="System.InvalidOperationException">Mesh has no effect and effectOverride is null</exception>
public unsafe void Draw(GraphicsDevice context, Matrix world, Matrix view, Matrix projection, Effect effectOverride = null)
{
int count = Meshes.Count;
int boneCount = Bones.Count;
if (sharedDrawBones == null || sharedDrawBones.Length < boneCount)
{
sharedDrawBones = new Matrix[boneCount];
}
CopyAbsoluteBoneTransformsTo(sharedDrawBones);
var defaultParametersContext = default(EffectDefaultParametersContext);
for (int i = 0; i < count; i++)
{
var mesh = Meshes[i];
int index = mesh.ParentBone.Index;
int effectCount = mesh.Effects.Count;
if (effectOverride != null)
{
if (effectOverride is SkinnedEffect)
{
effectOverride.DefaultParameters.Apply(ref defaultParametersContext, ref world, ref view, ref projection);
}
else
{
Matrix worldTranformed;
Matrix.Multiply(ref sharedDrawBones[index], ref world, out worldTranformed);
effectOverride.DefaultParameters.Apply(ref defaultParametersContext, ref worldTranformed, ref view, ref projection);
}
}
else
{
for (int j = 0; j < effectCount; j++)
{
var effect = mesh.Effects[j];
if (effect == null)
{
throw new InvalidOperationException("Mesh has no effect and effectOverride is null");
}
Matrix worldTranformed;
Matrix.Multiply(ref sharedDrawBones[index], ref world, out worldTranformed);
var matrices = effect as IEffectMatrices;
if (matrices == null)
{
effect.DefaultParameters.Apply(ref defaultParametersContext, ref world, ref view, ref projection);
}
else
{
matrices.World = effect is SkinnedEffect ? world : worldTranformed;
matrices.View = view;
matrices.Projection = projection;
}
}
}
mesh.Draw(context, sharedDrawBones, effectOverride);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EffectCompilerEventArgs" /> class.
/// </summary>
/// <param name="effect">The effect.</param>
/// <param name="messages">The log messages.</param>
public EffectCompilerEventArgs(Effect effect, IList<LogMessage> messages = null)
{
Effect = effect;
Messages = new ReadOnlyCollection<LogMessage>(messages ?? EmptyLogMessages);
}
