public void Dying()
{
List <Soldier> soldiers = FindOpponentSoldiers(mark, position, (s) =>
{
return(withinCircleArea(position, attackArea, s.position));
});
for (int i = 0; i < soldiers.Count; i++)
{
soldiers[i].Hurt(damage, hurtType, false, this);
}
debuffHandler.Destory();
buffHandler.Destory();
RenderMessage message = new RenderMessage();
message.type = RenderMessage.Type.CrystalCarDestroy;
message.ownerId = id;
message.direction = direction.vector3;
message.arguments.Add("mark", mark);
PostRenderMessage(message);
ChangeState(CrystalCarState.DEATH, fsmDead);
}
private void Fire()
{
DebugUtils.Log(DebugUtils.Type.AI_Tower, "the tower " + id + " begins to fire to target " + target.id);
damage = GetDamageValue();
Projectile projectile = GenerateProjectile(this, projectileId, towerFirePos, target);
projectile.RegisterRenderMessageHandler(PostRenderMessage);
projectile.RegisterDestroyHandler(PostDestroy);
projectile.RegisterRandomMethod(GetRandomNumber);
projectile.RegisterWithinCircleAreaPredicate(WithinCircleAreaPredicate);
projectile.RegisterWithinFrontRectangleAreaPredicate(WithinFrontRectAreaPredicate);
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SpawnProjectile;
rm.ownerId = projectile.id;
rm.position = projectile.position.vector3;
rm.direction = projectile.speed.vector3;
rm.arguments.Add("mark", projectile.mark);
rm.arguments.Add("metaId", projectile.metaId);
rm.arguments.Add("holderType", (int)projectile.owner.type);
rm.arguments.Add("holderId", projectile.owner.id);
PostRenderMessage(rm);
}
private void SpawnProjectile()
{
MoFaBaoLieDanArrow projectile = (MoFaBaoLieDanArrow)GenerateProjectile(owner, carrierId, owner.position, owner.target);
projectile.RegisterRenderMessageHandler(PostRenderMessage);
projectile.RegisterDestroyHandler(PostDestroy);
projectile.RegisterRandomMethod(GetRandomNumber);
projectile.RegisterFindOpponentSoldiers(FindOpponentSoldiers);
projectile.RegisterFindOpponentCrystalCars(FindOpponentCrystalCars);
projectile.RegisterFindOpponentDemolishers(FindOpponentDemolishers);
projectile.RegisterWithinCircleAreaPredicate(WithinCircleAreaPredicate);
projectile.RegisterWithinFrontRectangleAreaPredicate(WithinFrontRectAreaPredicate);
projectile.RegisterGenerateAttributeEffect(GenerateAttributeEffect);
projectile.RegisterFindNeutralUnits(FindNeutralUnits);
projectile.SetRadius(radius);
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SpawnProjectile;
rm.ownerId = projectile.id;
rm.position = projectile.position.vector3;
rm.direction = projectile.speed.vector3;
rm.arguments.Add("mark", projectile.mark);
rm.arguments.Add("metaId", projectile.metaId);
rm.arguments.Add("holderType", (int)projectile.owner.type);
rm.arguments.Add("holderId", projectile.owner.id);
PostRenderMessage(rm);
ReleaseEnd();
DebugUtils.Log(DebugUtils.Type.AI_Projectile, "SpawnProjectile+MoFaBaoLieDanArrow");
}
private void Work()
{
if (carrierType != 2)
{
DebugUtils.LogError(DebugUtils.Type.AI_Skill, "MoFaXianJingSkill carrierType != 2");
return;
}
Trap trap = GenerateTrap(owner, carrierId, owner.position, FixVector3.forward);
trap.RegisterRenderMessageHandler(PostRenderMessage);
trap.RegisterDestroyHandler(PostDestroy);
trap.RegisterBattleAgentMessageHandler(PostBattleMessage);
trap.RegisterFindOpponentSoldiers(FindOpponentSoldiers);
trap.RegisterWithinCircleAreaPredicate(WithinCircleAreaPredicate);
trap.RegisterGenerateAttributeEffect(GenerateAttributeEffect);
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SpawnTrap;
rm.ownerId = trap.id;
rm.position = trap.position.vector3;
rm.direction = trap.rotation.vector3;
rm.arguments.Add("mark", trap.mark);
rm.arguments.Add("metaId", carrierId);
rm.arguments.Add("holderType", (int)trap.owner.type);
rm.arguments.Add("holderId", trap.owner.id);
rm.arguments.Add("model", trap.modelId);
PostRenderMessage(rm);
ReleaseEnd();
}
private void SpawnProjectile()
{
if (owner.target != null && owner.target.Alive() && owner.targetId == owner.target.id)
{
DebugUtils.Log(DebugUtils.Type.AI_Soldier, "the " + owner.type + " soldier " + id + " skill to fire to target " + owner.target.id);
Projectile projectile = GenerateProjectile(owner, carrierId, owner.position, owner.target);
projectile.RegisterRenderMessageHandler(PostRenderMessage);
projectile.RegisterDestroyHandler(PostDestroy);
projectile.RegisterRandomMethod(GetRandomNumber);
projectile.RegisterFindOpponentSoldiers(FindOpponentSoldiers);
projectile.RegisterFindOpponentCrystalCars(FindOpponentCrystalCars);
projectile.RegisterFindOpponentDemolishers(FindOpponentDemolishers);
projectile.RegisterWithinCircleAreaPredicate(WithinCircleAreaPredicate);
projectile.RegisterWithinFrontRectangleAreaPredicate(WithinFrontRectAreaPredicate);
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SpawnProjectile;
rm.ownerId = projectile.id;
rm.position = projectile.position.vector3;
rm.direction = projectile.speed.vector3;
rm.arguments.Add("mark", projectile.mark);
rm.arguments.Add("metaId", projectile.metaId);
rm.arguments.Add("holderType", (int)projectile.owner.type);
rm.arguments.Add("holderId", projectile.owner.id);
PostRenderMessage(rm);
}
ReleaseEnd();
}
protected void HealthRecover(int deltaTime)
{
if (Alive())
{
if (hp < maxHp)
{
if (healthRecoverTimer >= healthRecoverInterval)
{
hp += healthRegen;
healthRecoverTimer = 0;
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SyncHP;
rm.ownerId = id;
rm.arguments.Add("type", (int)type);
rm.arguments.Add("hp", hp);
rm.arguments.Add("maxHp", maxHp);
rm.arguments.Add("mark", mark);
PostRenderMessage(rm);
}
else
{
healthRecoverTimer += deltaTime;
}
}
}
}
public override void Hurt(int hurtValue, AttackPropertyType hurtType, bool isCrit, LogicUnit injurer)
{
if (Alive())
{
int value = GetActualHurtValue(hurtType, hurtValue);
hp -= value;
RenderMessage message = new RenderMessage();
message.type = RenderMessage.Type.NpcHurt;
message.ownerId = id;
message.position = transform.position;
message.arguments.Add("value", value);
PostRenderMessage(message);
if (hp <= 0)
{
injurer.OnKillEnemy(killReward, injurer, this);
Dying();
}
else
{
Attack(injurer);
}
}
}
private void GenerateOneTrap()
{
//--need register TrapGenerator
Trap trap = GenerateTrap(owner, trapMetaId, destination, FixVector3.forward);
trap.RegisterRenderMessageHandler(PostRenderMessage);
trap.RegisterDestroyHandler(PostDestroy);
trap.RegisterBattleAgentMessageHandler(PostBattleMessage);
trap.RegisterFindOpponentSoldiers(FindOpponentSoldiers);
trap.RegisterWithinCircleAreaPredicate(WithinCircleAreaPredicate);
trap.RegisterGenerateAttributeEffect(GenerateAttributeEffect);
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SpawnTrap;
rm.ownerId = trap.id;
rm.position = trap.position.vector3;
rm.direction = trap.rotation.vector3;
rm.arguments.Add("mark", trap.mark);
rm.arguments.Add("metaId", trap.metaId);
rm.arguments.Add("holderType", (int)trap.owner.type);
rm.arguments.Add("holderId", trap.owner.id);
rm.arguments.Add("model", trap.modelId);
PostRenderMessage(rm);
//--TODO
}
private void Dash()
{
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SoldierDash;
rm.ownerId = owner.id;
rm.arguments.Add("state", 2); // Start Dash
PostRenderMessage(rm);
}
public void Destroy()
{
state = BuildingState.DESTROY;
RenderMessage message = new RenderMessage();
message.type = RenderMessage.Type.CrystalDestroy;
message.ownerId = id;
PostRenderMessage(message);
}
public void SpawnUnitOnMap(long playerId, int unitMetaId)
{
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.ShowDeployMouseEffect;
//TODO:There maby add new show effect
//HandleRenderMessage( rm );
logicWorld.SpawnUnit(playerId, unitMetaId);
}
public virtual void Idle()
{
ChangeState(NpcState.IDLE, fsmIdle);
RenderMessage rm = new RenderMessage();
rm.ownerId = id;
rm.type = RenderMessage.Type.NpcIdle;
rm.direction = brithDirection.vector3;
PostRenderMessage(rm);
}
public void Dying()
{
ChangeState(IdolGuardState.DYING, fsmDying);
RenderMessage renderMessage = new RenderMessage();
renderMessage.type = RenderMessage.Type.IdolGuardDeath;
renderMessage.ownerId = id;
PostRenderMessage(renderMessage);
}
public void SyncPosition()
{
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SyncPosition;
rm.ownerId = id;
rm.arguments.Add("type", (int)type);
rm.position = position.vector3;
rm.direction = speed.vector3;
PostRenderMessage(rm);
}
public override void OnEnter()
{
base.OnEnter();
RenderMessage rm = new RenderMessage();
rm.ownerId = owner.id;
rm.direction = owner.direction.vector3;
rm.type = RenderMessage.Type.SummonedUnitDeath;
owner.PostRenderMessage(rm);
}
private void Line2D3D(Line2D3DCommand command, FlatBufferBuilder builder, List <Offset <RenderMessage> > messages)
{
//FlatBuffer doesn't like nesting "create" commands within each other so declare them early instead (vectors are immune for some reason)
var color = command.Color.ToFlatBuffer(builder);
RenderMessage.StartRenderMessage(builder);
RenderMessage.AddRenderType(builder, RenderType.DrawLine2D_3D);
RenderMessage.AddColor(builder, color);
RenderMessage.AddStart(builder, command.Start.ToFlatBuffer(builder));
RenderMessage.AddEnd(builder, command.End.ToFlatBuffer(builder));
messages.Add(RenderMessage.EndRenderMessage(builder));
}
public void Dying()
{
ChangeState(IdolState.DYING, fsmDying);
RenderMessage renderMessage = new RenderMessage();
renderMessage.type = RenderMessage.Type.IdolDeath;
renderMessage.ownerId = id;
PostRenderMessage(renderMessage);
// TODO: maybe release skill
}
public void DistanceOut()
{
DebugUtils.Log(DebugUtils.Type.AI_Projectile, "the projectile " + id + " enter distance out state ");
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.ProjectileHit;
rm.ownerId = id;
PostRenderMessage(rm);
PostDestroy(this);
}
public override void ReleaseEnd()
{
base.ReleaseEnd();
tempEffect.Clear();
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SkillHit;
rm.ownerId = owner.id;
PostRenderMessage(rm);
}
private void DashEnd()
{
// play end animation
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SoldierDash;
rm.ownerId = owner.id;
rm.arguments.Add("state", 3); // Start Dash
PostRenderMessage(rm);
DelayChangeState(GameConstants.UNIT_DASHEND_DURATION, State.ReleaseEnd);
}
public virtual void TrapDestroy()
{
DebugUtils.Log(DebugUtils.Type.AI_Trap, string.Format("Trap has been Release id = {0}", id));
RenderMessage rm = new RenderMessage();
rm.ownerId = id;
rm.type = RenderMessage.Type.TrapDestroy;
PostRenderMessage(rm);
PostDestroy(this);
}
public virtual void Hit()
{
DebugUtils.Log(DebugUtils.Type.AI_Projectile, string.Format("Projectile {0} enter hit state", id));
RenderMessage message = new RenderMessage();
message.type = RenderMessage.Type.ProjectileHit;
message.ownerId = id;
PostRenderMessage(message);
PostDestroy(this);
}
public override void Fire()
{
base.Fire();
RenderMessage rm = new RenderMessage();
rm.ownerId = owner.id;
rm.type = RenderMessage.Type.SoldierReleaseSkill;
rm.arguments.Add("index", index);
rm.arguments.Add("metaId", metaId);
PostRenderMessage(rm);
}
/// <summary>
/// Draws a line in screen space.
/// </summary>
/// <param name="color">The color of the line.</param>
/// <param name="start">The start point of the line.</param>
/// <param name="end">The end point of the line.</param>
public void DrawLine2D(Color color, Vector2 start, Vector2 end)
{
var colorOffset = color.ToOffsetColor(Builder);
RenderMessage.StartRenderMessage(Builder);
RenderMessage.AddRenderType(Builder, RenderType.DrawLine2D);
RenderMessage.AddColor(Builder, colorOffset);
RenderMessage.AddStart(Builder, start.ToOffsetVector(Builder));
RenderMessage.AddEnd(Builder, end.ToOffsetVector(Builder));
var finalOffset = RenderMessage.EndRenderMessage(Builder);
_renderMessageOffsets.Add(finalOffset);
}
public void Idle()
{
ChangeState(CrystalCarState.IDLE, fsmIdle);
direction = speed.normalized;
RenderMessage message = new RenderMessage();
message.type = RenderMessage.Type.CrystalCarIdle;
message.direction = direction.vector3;
message.ownerId = id;
PostRenderMessage(message);
}
public virtual void Reborn()
{
Reset();
Initialize(id, npcProto, brithPosition, brithDirection);
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.NpcReborn;
rm.ownerId = id;
PostRenderMessage(rm);
DebugUtils.Log(DebugUtils.Type.AI_Npc, string.Format(" {0} {1} has been reborn", npcType, id));
}
public virtual void Dying()
{
ChangeState(NpcState.DYING, fsmDying);
debuffHandler.Destory();
buffHandler.Destory();
RenderMessage renderMessage = new RenderMessage();
renderMessage.type = RenderMessage.Type.NpcDeath;
renderMessage.ownerId = id;
PostRenderMessage(renderMessage);
}
public void Fight(LogicUnit building)
{
target = building;
direction = speed.normalized;
ChangeState(DemolisherState.FIGHT, fsmFight);
RenderMessage message = new RenderMessage();
message.type = RenderMessage.Type.DemolisherFight;
message.ownerId = id;
message.direction = direction.vector3;
PostRenderMessage(message);
}
public void Mining(Crystal crystal)
{
target = crystal;
direction = speed.normalized;
ChangeState(CrystalCarState.MINING, fsmMining);
RenderMessage message = new RenderMessage();
message.type = RenderMessage.Type.CrystalCarMining;
message.ownerId = id;
message.direction = direction.vector3;
PostRenderMessage(message);
}
public override void Fire()
{
state = State.Fire;
base.Fire();
RenderMessage rm = new RenderMessage();
rm.type = RenderMessage.Type.SoldierWalk;
rm.ownerId = owner.id;
rm.direction = owner.direction.vector3;
PostRenderMessage(rm);
owner.FindChasePath(owner.target.position);
}
public void OnInitialise(InitialiseMessage msg)
{
// Initialise renderer
Console.WriteLine("Initialising renderer...");
rendermsg = new RenderMessage();
updatemsg = new UpdateMessage();
// Create the window
window = new RenderForm("Castle Renderer - 11030062");
window.Width = 1280;
window.Height = 720;
// Add form events
window.FormClosed += window_FormClosed;
// Defaults
ClearColour = new Color4(1.0f, 0.0f, 0.0f, 1.0f);
// Setup the device
var description = new SwapChainDescription()
{
BufferCount = 1,
Usage = Usage.RenderTargetOutput,
OutputHandle = window.Handle,
IsWindowed = true,
ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
SampleDescription = new SampleDescription(1, 0),
Flags = SwapChainFlags.AllowModeSwitch,
SwapEffect = SwapEffect.Discard
};
Device tmp;
var result = Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, description, out tmp, out swapchain);
if (result.IsFailure)
{
Console.WriteLine("Failed to create Direct3D11 device (" + result.Code.ToString() + ":" + result.Description + ")");
return;
}
Device = tmp;
context = Device.ImmediateContext;
using (var factory = swapchain.GetParent<Factory>())
factory.SetWindowAssociation(window.Handle, WindowAssociationFlags.IgnoreAltEnter);
// Check AA stuff
int q = Device.CheckMultisampleQualityLevels(Format.R8G8B8A8_UNorm, 8);
// Setup the viewport
viewport = new Viewport(0.0f, 0.0f, window.ClientSize.Width, window.ClientSize.Height);
viewport.MinZ = 0.0f;
viewport.MaxZ = 1.0f;
context.Rasterizer.SetViewports(viewport);
// Setup the backbuffer
using (var resource = Resource.FromSwapChain<Texture2D>(swapchain, 0))
rtBackbuffer = new RenderTargetView(Device, resource);
// Setup depth for backbuffer
{
Texture2DDescription texdesc = new Texture2DDescription()
{
ArraySize = 1,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.D32_Float,
Width = (int)viewport.Width,
Height = (int)viewport.Height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
texDepthBuffer = new Texture2D(Device, texdesc);
DepthStencilViewDescription viewdesc = new DepthStencilViewDescription()
{
ArraySize = 0,
Format = Format.D32_Float,
Dimension = DepthStencilViewDimension.Texture2D,
MipSlice = 0,
Flags = 0,
FirstArraySlice = 0
};
vwDepthBuffer = new DepthStencilView(Device, texDepthBuffer, viewdesc);
}
// Setup states
#region Depth States
// Setup depth states
{
DepthStencilStateDescription desc = new DepthStencilStateDescription()
{
IsDepthEnabled = true,
IsStencilEnabled = false,
DepthWriteMask = DepthWriteMask.All,
DepthComparison = Comparison.Less
};
Depth_Enabled = DepthStencilState.FromDescription(Device, desc);
}
{
DepthStencilStateDescription desc = new DepthStencilStateDescription()
{
IsDepthEnabled = false,
IsStencilEnabled = false,
DepthWriteMask = DepthWriteMask.Zero,
DepthComparison = Comparison.Less
};
Depth_Disabled = DepthStencilState.FromDescription(Device, desc);
}
{
DepthStencilStateDescription desc = new DepthStencilStateDescription()
{
IsDepthEnabled = true,
IsStencilEnabled = false,
DepthWriteMask = DepthWriteMask.Zero,
DepthComparison = Comparison.Less
};
Depth_ReadOnly = DepthStencilState.FromDescription(Device, desc);
}
#endregion
#region Sampler States
Sampler_Clamp = SamplerState.FromDescription(Device, new SamplerDescription()
{
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp,
AddressW = TextureAddressMode.Clamp,
Filter = Filter.Anisotropic,
MinimumLod = 0.0f,
MaximumLod = float.MaxValue,
MaximumAnisotropy = 16
});
Sampler_Clamp_Point = SamplerState.FromDescription(Device, new SamplerDescription()
{
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp,
AddressW = TextureAddressMode.Clamp,
Filter = Filter.MinMagMipPoint
});
Sampler_Clamp_Linear = SamplerState.FromDescription(Device, new SamplerDescription()
{
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp,
AddressW = TextureAddressMode.Clamp,
Filter = Filter.MinMagMipLinear
});
Sampler_Wrap = SamplerState.FromDescription(Device, new SamplerDescription()
{
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
Filter = Filter.Anisotropic,
MinimumLod = 0.0f,
MaximumLod = float.MaxValue,
MaximumAnisotropy = 16
});
#endregion
#region Rasterizer States
Culling_Backface = RasterizerState.FromDescription(Device, new RasterizerStateDescription()
{
CullMode = CullMode.Back,
DepthBias = 0,
DepthBiasClamp = 0.0f,
IsDepthClipEnabled = true,
FillMode = FillMode.Solid,
IsAntialiasedLineEnabled = false,
IsFrontCounterclockwise = false,
IsMultisampleEnabled = true,
IsScissorEnabled = false,
SlopeScaledDepthBias = 0.0f
});
Culling_Frontface = RasterizerState.FromDescription(Device, new RasterizerStateDescription()
{
CullMode = CullMode.Front,
DepthBias = 0,
DepthBiasClamp = 0.0f,
IsDepthClipEnabled = true,
FillMode = FillMode.Solid,
IsAntialiasedLineEnabled = false,
IsFrontCounterclockwise = false,
IsMultisampleEnabled = true,
IsScissorEnabled = false,
SlopeScaledDepthBias = 0.0f
});
Culling_None = RasterizerState.FromDescription(Device, new RasterizerStateDescription()
{
CullMode = CullMode.None,
DepthBias = 0,
DepthBiasClamp = 0.0f,
IsDepthClipEnabled = true,
FillMode = FillMode.Solid,
IsAntialiasedLineEnabled = false,
IsFrontCounterclockwise = false,
IsMultisampleEnabled = true,
IsScissorEnabled = false,
SlopeScaledDepthBias = 0.0f
});
#endregion
#region Blend States
{
BlendStateDescription desc = new BlendStateDescription();
desc.RenderTargets[0].BlendEnable = true;
desc.RenderTargets[0].BlendOperation = BlendOperation.Add;
desc.RenderTargets[0].SourceBlend = BlendOption.One;
desc.RenderTargets[0].DestinationBlend = BlendOption.Zero;
desc.RenderTargets[0].BlendOperationAlpha = BlendOperation.Add;
desc.RenderTargets[0].SourceBlendAlpha = BlendOption.One;
desc.RenderTargets[0].DestinationBlendAlpha = BlendOption.Zero;
desc.RenderTargets[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
Blend_Opaque = BlendState.FromDescription(Device, desc);
}
{
BlendStateDescription desc = new BlendStateDescription();
desc.RenderTargets[0].BlendEnable = true;
desc.RenderTargets[0].BlendOperation = BlendOperation.Add;
desc.RenderTargets[0].SourceBlend = BlendOption.SourceAlpha;
desc.RenderTargets[0].DestinationBlend = BlendOption.InverseSourceAlpha;
desc.RenderTargets[0].BlendOperationAlpha = BlendOperation.Add;
desc.RenderTargets[0].SourceBlendAlpha = BlendOption.One;
desc.RenderTargets[0].DestinationBlendAlpha = BlendOption.Zero;
desc.RenderTargets[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
Blend_Alpha = BlendState.FromDescription(Device, desc);
}
{
BlendStateDescription desc = new BlendStateDescription();
desc.RenderTargets[0].BlendEnable = true;
desc.RenderTargets[0].BlendOperation = BlendOperation.Add;
desc.RenderTargets[0].SourceBlend = BlendOption.One;
desc.RenderTargets[0].DestinationBlend = BlendOption.One;
desc.RenderTargets[0].BlendOperationAlpha = BlendOperation.Add;
desc.RenderTargets[0].SourceBlendAlpha = BlendOption.One;
desc.RenderTargets[0].DestinationBlendAlpha = BlendOption.Zero;
desc.RenderTargets[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
Blend_Add = BlendState.FromDescription(Device, desc);
}
{
BlendStateDescription desc = new BlendStateDescription();
desc.RenderTargets[0].BlendEnable = true;
desc.RenderTargets[0].BlendOperation = BlendOperation.Add;
desc.RenderTargets[0].SourceBlend = BlendOption.DestinationColor;
desc.RenderTargets[0].DestinationBlend = BlendOption.Zero;
desc.RenderTargets[0].BlendOperationAlpha = BlendOperation.Add;
desc.RenderTargets[0].SourceBlendAlpha = BlendOption.One;
desc.RenderTargets[0].DestinationBlendAlpha = BlendOption.Zero;
desc.RenderTargets[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
Blend_Multiply = BlendState.FromDescription(Device, desc);
}
#endregion
// Setup default states
Depth = Depth_Enabled;
Culling = Culling_Backface;
Blend = Blend_Opaque;
// Setup other objects
shaderresourcemap = new Dictionary<Resource, ShaderResourceView>();
resourceviewslots = new ShaderResourceViewData[MaxPixelShaderResourceViewSlots];
// Send the window created message
WindowCreatedMessage windowcreatedmsg = new WindowCreatedMessage();
windowcreatedmsg.Form = window;
Owner.MessagePool.SendMessage(windowcreatedmsg);
// Show the form
window.Show();
}
public void OnRender(RenderMessage msg)
{
// Clear the render queue ready for new work
ClearRenderQueue();
// Populate render queue with new work items
Owner.MessagePool.SendMessage(queuemsg);
// Populate camera list with active cameras
cameramsg.Cameras.Clear();
cameramsg.ShadowCasters.Clear();
Owner.MessagePool.SendMessage(cameramsg);
// Populate light list with active lights
lightmsg.Lights.Clear();
Owner.MessagePool.SendMessage(lightmsg);
// Populate psystem list with active particle systems
psysmsg.ParticleSystems.Clear();
Owner.MessagePool.SendMessage(psysmsg);
// Cache the renderer
Renderer renderer = Owner.GetComponent<Renderer>();
// Setup initial state
renderer.Depth = renderer.Depth_Enabled;
renderer.Blend = renderer.Blend_Opaque;
renderer.Culling = renderer.Culling_None;
// Loop each shadow caster
foreach (ShadowCaster caster in cameramsg.ShadowCasters)
{
// Get the projection view matrix and transform
Matrix projview = caster.ProjectionView;
Transform transform = caster.Owner.GetComponent<Transform>();
Vector3 position = transform.Position;
// Does it belong to a directional-light?
/*Light light = caster.Owner.GetComponent<Light>();
if (light.Type == LightType.Directional)
{
// We're responsible for positioning this light such that the shadow maps across the whole scene
}*/
// Bind the caster render target
caster.RT.Bind();
caster.RT.Clear();
// Draw all items in the render queue to the shadowmap
Material activematerial = null;
foreach (RenderWorkItem item in renderqueue)
{
// Set the material
if (activematerial != item.Material)
{
activematerial = item.Material;
if (activematerial.ShadowShader != null)
activematerial.ShadowShader.SetVariable("light_position", position);
renderer.SetActiveMaterial(activematerial, true);
}
// Draw it
renderer.DrawImmediate(item.Mesh, item.SubmeshIndex, projview, item.Transform);
}
}
// Loop each camera
foreach (Camera cam in cameramsg.Cameras)
{
// Get the projection view matrix and transform
Matrix projview = cam.ProjectionView;
Transform transform = cam.Owner.GetComponent<Transform>();
Vector3 position = transform.Position;
Vector3 forward = transform.Forward;
Vector4 clip = new Vector4(cam.ClipPlane.Normal, cam.ClipPlane.D);
// Setup initial state
renderer.Depth = renderer.Depth_Enabled;
renderer.Blend = renderer.Blend_Opaque;
renderer.Culling = renderer.Culling_Backface;
gbuffer.Bind();
gbuffer.Clear();
// TODO (IN THIS ORDER)
// Note: The amount of RTs in use here is quite ridiculous
// 1) Bind GBuffer (and set blend to normal, depth to on)
// 2) Loop each item in the render queue
// 2a) Check for visibility against camera
// 2b) Bind the material
// 2c) Draw the item
// 3) Bind light accum buffer (and set blend to additive, depth to off)
// 4) Loop each light
// 4a) Check for visibility against camera
// 4b) Draw the light layer
// 5) Bind SwapA
// 6) Draw camera background (skybox)
// 7) Using the light blit material (inputs include GBuffer's colour buffer & light accum buffers), blit the image
// 8) Loop each item in the postprocess queue
// 8a) Bind SwapB
// 8b) Draw postprocess effect, use SwapA as input
// 8c) Swap SwapA and SwapB
// 9) Bind camera target (or backbuffer if null)
// 10) Blit SwapA to screen
// Draw all items in the render queue to the GBuffer
foreach (RenderWorkItem item in renderqueue)
{
// Set the material
item.Material.SetParameter("useclip", cam.UseClipping ? 1.0f : 0.0f);
if (cam.UseClipping) item.Material.SetParameter("clip", clip);
renderer.SetActiveMaterial(item.Material);
var desiredculling = item.Material.CullingMode != null ? item.Material.CullingMode : renderer.Culling_Backface;
if (renderer.Culling != desiredculling) renderer.Culling = desiredculling;
// Draw it
renderer.DrawImmediate(item.Mesh, item.SubmeshIndex, projview, item.Transform);
}
// Setup light accum state
lightaccum.Bind();
lightaccum.Clear();
renderer.Depth = renderer.Depth_Disabled;
renderer.Blend = renderer.Blend_Add;
renderer.Culling = renderer.Culling_None;
// Update camera details on all light types
foreach (Material lightmat in mat_lights.Values)
{
lightmat.SetParameter("camera_position", position);
lightmat.SetParameter("camera_forward", forward);
}
// Draw all lights
foreach (Light light in lightmsg.Lights)
{
// Set the material
Material lightmat = mat_lights[light.Type];
light.ApplyLightSettings(lightmat);
lightmat.Apply(false);
renderer.SetActiveMaterial(lightmat);
// Draw it
renderer.DrawImmediate(mesh_fs, 0);
}
// Are there particle systems to draw?
if (psysmsg.ParticleSystems.Count > 0)
{
// Setup state
renderer.Depth = renderer.Depth_ReadOnly;
//renderer.Depth = renderer.Depth_Disabled;
// Bind particle system RT (hybrid of GBuffer depth and RT colour)
particleaccum.BindHybrid(gbuffer.GetDepthView());
//particleaccum.Bind();
particleaccum.Clear();
// Render
for (int i = 0; i < psysmsg.ParticleSystems.Count; i++)
{
ParticleSystem psys = psysmsg.ParticleSystems[i];
if (psys.TransferMode == ParticleTransferMode.Add)
renderer.Blend = renderer.Blend_Add;
else if (psys.TransferMode == ParticleTransferMode.Alpha)
renderer.Blend = renderer.Blend_Alpha;
else
renderer.Blend = renderer.Blend_Opaque;
psys.Material.Shader.SetVariable("view", transform.WorldToObject);
psys.Material.Shader.SetVariable("projection", cam.Projection);
renderer.SetActiveMaterial(psys.Material);
renderer.DrawImmediate(psys.Mesh, 0, projview, Matrix.Identity);
}
}
// Setup blit state
swapA.Bind();
renderer.Blend = renderer.Blend_Alpha;
renderer.Depth = renderer.Depth_Disabled;
// Draw background
if (cam.Background == BackgroundType.Skybox)
{
if (cam.Skybox != null)
{
renderer.SetActiveMaterial(cam.Skybox);
Vector3 campos = transform.Position;
renderer.DrawImmediate(mesh_skybox, 0, cam.ProjectionView, Matrix.Translation(campos.X - 0.5f, campos.Y - 0.5f, campos.Z - 0.5f));
}
}
// Blit lighting
renderer.SetActiveMaterial(mat_blitlight);
renderer.DrawImmediate(mesh_fs, 0);
// Are there particle systems to draw?
if (psysmsg.ParticleSystems.Count > 0)
{
// Blit particles
renderer.Blend = renderer.Blend_Add;
mat_blit.SetParameter("texSource", particleaccum.GetTexture(particleaccum_colour));
renderer.SetActiveMaterial(mat_blit);
renderer.DrawImmediate(mesh_fs, 0);
}
// Setup state
renderer.Blend = renderer.Blend_Opaque;
// Loop each postprocess
RenderTarget pp_source = swapA;
RenderTarget pp_target = swapB;
foreach (PostProcessEffect effect in effectqueue)
{
// Bind target
pp_target.Bind();
// Apply material
effect.Material.SetParameter("texImage", pp_source.GetTexture(0));
effect.Material.SetParameter("imagesize", new Vector2(pp_source.Width, pp_source.Height));
renderer.SetActiveMaterial(effect.Material, false, true);
// Blit
renderer.DrawImmediate(mesh_fs, 0);
// Swap
Util.Swap(ref pp_source, ref pp_target);
}
// Bind camera target
if (cam.Target != null)
cam.Target.Bind();
else
renderer.BindBackbuffer();
// Blit final result
mat_blit.SetParameter("texSource", pp_source.GetTexture(0));
renderer.SetActiveMaterial(mat_blit, false, true);
renderer.DrawImmediate(mesh_fs, 0);
}
}
public RCS_Render_Job_Message(RenderMessage message, Guid concernedRenderJobID, RemoteType remote) : base(remote)
{
this.Message = message;
this.ConcernedRenderJobID = concernedRenderJobID;
}
