public void RenderText(IRenderContext context, IEffect effect, IEffectParameterSet effectParameterSet, Matrix matrix,
string text, FontAsset font, HorizontalAlignment horizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment verticalAlignment = VerticalAlignment.Top, Color? textColor = null, bool renderShadow = true,
Color? shadowColor = null)
{
throw new NotSupportedException();
}
private bool IsEffectPrevented(IEffect effect)
{
foreach (EffectSupport support in effectSupports)
if (support(effect))
return true;
return false;
}
public IRenderRequest CreateInstancedRequest(IRenderContext renderContext, RasterizerState rasterizerState,
BlendState blendState, DepthStencilState depthStencilState, IEffect effect, IEffectParameterSet effectParameterSet,
VertexBuffer meshVertexBuffer, IndexBuffer meshIndexBuffer, PrimitiveType primitiveType,
Matrix[] instanceWorldTransforms, Action<List<Matrix>, VertexBuffer, IndexBuffer> computeCombinedBuffers)
{
throw new NotImplementedException();
}
public Sprite( ITexture2D texture, IEffect effect )
{
if ( effect == null )
{
if ( baseSpriteEffect == null )
baseSpriteEffect = new SpriteEffect ();
effect = baseSpriteEffect;
}
Texture = texture;
Effect = effect;
int width = 1, height = 1;
if ( texture != null ) { width = texture.Width; height = texture.Height; }
vertexBuffer = LiqueurSystem.GraphicsDevice.CreateVertexBuffer<SpriteVertex> ( SpriteVertexFormat, new SpriteVertex []
{
new SpriteVertex ( new Vector2 ( 0.001f, 0.001f ), Color.White, new Vector2 ( 0.001f, 0.001f ) ),
new SpriteVertex ( new Vector2 ( width, 0.001f ), Color.White, new Vector2 ( 1, 0.001f ) ),
new SpriteVertex ( new Vector2 ( 0.001f, height ), Color.White, new Vector2 ( 0.001f, 1 ) ),
new SpriteVertex ( new Vector2 ( width, height ), Color.White, new Vector2 ( 1, 1 ) ),
} );
if ( indexBuffer == null )
indexBuffer = LiqueurSystem.GraphicsDevice.CreateIndexBuffer ( new int [] { 0, 1, 2, 1, 3, 2 } );
indexReference++;
clippingArea = new Rectangle ( 0, 0, width, height );
TextureFilter = Liqueur.Graphics.TextureFilter.Nearest;
}
public void AddEffect(IEffect effect)
{
if (effect == null)
throw new ArgumentNullException("effect");
game.AddEffect(effect);
}
public Transition(Effect cEffectSource, Effect cEffectTarget)
: this()
{
try
{
if (null == cEffectSource) // TODO проверять видео или только аудио.....
_cEffectSource = new Composite(1, 1);
else
_cEffectSource = cEffectSource;
if (null == cEffectTarget)
_cEffectTarget = new Composite(1, 1);
else
_cEffectTarget = cEffectTarget;
#region z-layer
if (_cEffectSource.nLayer > _cEffectTarget.nLayer)
((IEffect)this).nLayer = _cEffectTarget.nLayer;
else
((IEffect)this).nLayer = _cEffectSource.nLayer;
#endregion
}
catch
{
Fail();
throw;
}
}
public void Render(ModelInstance modelInstance, IEffect effect)
{
foreach (var meshInstance in modelInstance.MeshInstances)
{
var renderer = GetRendererFor(meshInstance);
var dataStream = renderer.LockVertexBuffer();
dataStream.WriteRange(meshInstance.VertexBuffer);
renderer.UnlockVertexBuffer();
if (meshInstance.TextureArea == null)
{
meshInstance.TextureArea = _graphicsContext.GetTexture(meshInstance.TextureName);
}
if (meshInstance.TextureName != _lastTextureName)
{
_lastTextureName = meshInstance.TextureName;
effect.SetTexture("tex0", meshInstance.TextureArea);
effect.CommitChanges();
}
renderer.RenderForShader(PrimitiveType.TriangleList, 0, meshInstance.TriangleCount);
}
}
public DefaultDebugRenderPass(IAssetManagerProvider assetManagerProvider)
{
_basicEffect = assetManagerProvider.GetAssetManager().Get<UberEffectAsset>("effect.BuiltinSurface").Effects["Color"];
Lines = new List<VertexPositionNormalColor>();
Triangles = new List<VertexPositionNormalColor>();
EnabledLayers = new List<IDebugLayer>();
}
public Sprite( ITexture2D texture, IEffect effect )
{
if ( effect == null )
{
if ( baseSpriteEffect == null )
baseSpriteEffect = new SpriteEffect ();
effect = baseSpriteEffect;
}
if ( projectionMatrix == null )
projectionMatrix = new OrthographicOffCenterProjection ( 0, 800, 600, 0, 0.001f, 1000.0f );
Effect = effect;
if ( vertexDeclaration == null )
{
vertexDeclaration = Core.GraphicsDevice.CreateVertexDeclaration ( Utilities.CreateVertexElementArray<SpriteVertex> () );
}
indexReference++;
vertexBuffer = Core.GraphicsDevice.CreateBuffer ( BufferType.VertexBuffer, typeof ( SpriteVertex ), 4 );
textureArgument = new SamplerState ( texture, Graphics.TextureFilter.Nearest, TextureAddressing.Clamp, 0 );
Reset ( texture );
innerWorld = new World2();
}
public Sprite(SpriteDef def)
{
var tex = XNADevicesManager.Instance.ContentManager.Load<Texture2D>(def.TexName);
_texture = tex;
_effect = EffectManager.Instance.CurrentEffect;
for (int i = 0; i < 4; i++)
{
_vertexPosition[i].Normal = Vector3.Backward;
}
for (int i = 4; i < 8; i++)
{
_vertexPosition[i].Normal = Vector3.Forward;
}
DrawRectangle = def.DrawRectangle;
Alpha = def.Alpha;
ScaleX = def.ScaleX;
ScaleY = def.ScaleY;
RotateX = def.RotateX;
RotateY = def.RotateY;
RotateZ = def.RotateZ;
R = def.R;
G = def.G;
B = def.B;
X = def.X;
Y = def.Y;
Z = def.Z;
TransformOrigin = def.TransformOrigin;
ZWriteEnable = def.ZWriteEnable;
}
public void Render(IEffect effect)
{
effect.SetTexture("tex0", _noTexture);
effect.CommitChanges();
_vertexRenderer.RenderForShader(PrimitiveType.LineList, 0, 3);
}
private void ResolveEffectName(Table.Table Table)
{
if (!TargetEffectName.IsNullOrWhiteSpace() && Table.Effects.Contains(TargetEffectName))
{
TargetEffect = Table.Effects[TargetEffectName];
};
}
public void Setup()
{
stubWeapons = MockRepository.GenerateStub<IWeapons>();
stubWeapons.Stub(me => me[WeaponType.RocketLauncher]).Return(new RocketLauncher(null));
((RocketLauncher)stubWeapons[WeaponType.RocketLauncher]).Rockets.Add(new Rocket(Vector2.Zero, Vector2.Zero, new Frenetic.Physics.DummyPhysicsComponent()));
mockEffects = MockRepository.GenerateStub<IEffect>();
view = new RocketLauncherView(mockEffects);
}
public Item(IEffect iEffect, Transition.TypeVideo cTransitionVideo, Transition.TypeAudio cTransitionAudio, ushort nTransitionDuration)
{
this.iEffect = iEffect;
this.bIsActive = true;
this.cTransitionVideo = cTransitionVideo;
this.cTransitionAudio = cTransitionAudio;
this.nTransitionDuration = nTransitionDuration;
}
public void Raise(IEffect effect)
{
effect.TimeToStart= mCurrentTime + effect.Delay;
effect.TimeToEnd = effect.TimeToStart + effect.Length;
mQueuedEffects.Add(effect);
++mNoOfQueuedEffects;
}
public EffectHandle(IEffect effect, IChoice choice, ILimit limit)
{
if (effect == null)
throw new ArgumentNullException("effect");
this.effect = effect;
this.choice = choice;
this.limit = limit;
}
public override bool Equals(IEffect other)
{
var otherEffect = other as RestoreEnergyEffect;
if (otherEffect == null)
{
return false;
}
return Magnitude.Equals(otherEffect.Magnitude);
}
public bool Equals(IEffect other)
{
var otherEffect = other as DamageHealthEffect;
if (otherEffect == null)
{
return false;
}
return Magnitude.Equals(otherEffect.Magnitude);
}
public override bool AddEffect(IEffect effect)
{
if (IsEffectPrevented(effect))
return false;
effectList.AddEffect(effect);
Invalidate();
if (effect.ID.Priority == EffectPriority.IMMEDIATE)
Validate();
return true;
}
/// <summary>
/// パラメータ無しの画像処理をおこなう
/// </summary>
/// <param name="bmp">元になるWriteableBitmapオブジェクト</param>
/// <param name="effector">処理させるIEffectオブジェクト</param>
/// <returns>処理後のWriteableBitmapオブジェクト</returns>
private static WriteableBitmap ProcessEffect(WriteableBitmap bmp, IEffect effector)
{
// WriteableBitmapのピクセルデータをバイト配列に変換する
var srcPixels = bmp.GetPixels();
// パラメータ無しの画像処理をおこなう
var dstPixels = effector.Effect(bmp.PixelWidth, bmp.PixelHeight, srcPixels);
// バイト配列からピクセルを作成する
return WriteableBitmapLoadExtensions.FromArray(bmp.PixelWidth, bmp.PixelHeight, dstPixels);
}
private Ability(IEffect effect, bool isActivatable, string name, bool isUnique, string description,
TimeSpan? cooldown = null)
{
Effect = effect;
IsActivatable = isActivatable;
Name = name;
IsUnique = isUnique;
Description = description;
Cooldown = cooldown;
CooldownTimer = Cooldown.HasValue ? new Stopwatch() : null;
}
public void AddEffect(IEffect effect)
{
if (effect != null)
{
if (listEffect.ContainsKey(effect.GetType())) // If effect exist
{
listEffect.Remove(effect.GetType());
}
effect.Owner = this;
listEffect.Add(effect.GetType(), effect);
}
}
public void Initialize(Device1 device)
{
if (IsInitialized) return;
ObjectList = new ObservableCollection<GameObject>();
SelectedShader = new PosNormColEffect();
SelectedShader.Initialize(device);
SelectedShader.Technique = SelectedShader.Effect.GetTechniqueByName("WireTech");
IsInitialized = true;
}
public void Attach( IEffect effect )
{
GL.AttachShader ( ( effect as Effect ).programId, shaderId );
if ( Option != null )
{
int count = 0;
foreach ( ShaderOption.AttributeOrder attr in from a in Option.AttributeOrdering orderby a.VertexType select a )
{
GL.BindAttribLocation ( ( int ) effect.Handle, count, attr.Name );
count++;
}
}
}
public Sprite(Texture2D texture, IEffect effect = null)
{
_texture = texture;
_effect = effect ?? EffectManager.Instance.CurrentEffect;
for (int i = 0; i < 4; i++)
{
_vertexPosition[i].Normal = Vector3.Backward;
}
for (int i = 4; i < 8; i++)
{
_vertexPosition[i].Normal = Vector3.Forward;
}
}
public override void Intro( params object [] args )
{
Core.Window.Title = "Cube";
contentManager = new ResourceTable ( FileSystemManager.GetFileSystem ( "ManifestFileSystem" ) );
cubeEffect = contentManager.Load<IEffect> ( "Resources/Cube/CubeShader.xml", "i_pos", "i_col" );
cubeVertices = Core.GraphicsDevice.CreateBuffer<CubeVertex>( BufferType.VertexBuffer, new CubeVertex []
{
new CubeVertex () { Position = new Vector3 ( -1, -1, -1 ), Diffuse = Color.Red },
new CubeVertex () { Position = new Vector3 ( +1, -1, -1 ), Diffuse = Color.Blue },
new CubeVertex () { Position = new Vector3 ( -1, -1, +1 ), Diffuse = Color.Green },
new CubeVertex () { Position = new Vector3 ( +1, -1, +1 ), Diffuse = Color.White },
new CubeVertex () { Position = new Vector3 ( -1, +1, -1 ), Diffuse = Color.Magenta },
new CubeVertex () { Position = new Vector3 ( -1, +1, +1 ), Diffuse = Color.Cyan },
new CubeVertex () { Position = new Vector3 ( +1, +1, -1 ), Diffuse = Color.Yellow },
new CubeVertex () { Position = new Vector3 ( +1, +1, +1 ), Diffuse = Color.White },
} );
cubeIndices = Core.GraphicsDevice.CreateBuffer<CubeIndex> ( BufferType.IndexBuffer, new CubeIndex []
{
// TOP
new CubeIndex () { I0 = 0, I1 = 1, I2 = 2 },
new CubeIndex () { I0 = 1, I1 = 3, I2 = 2 },
// LEFT
new CubeIndex () { I0 = 0, I1 = 2, I2 = 4 },
new CubeIndex () { I0 = 2, I1 = 5, I2 = 4 },
// FRONT
new CubeIndex () { I0 = 2, I1 = 3, I2 = 5 },
new CubeIndex () { I0 = 3, I1 = 7, I2 = 5 },
// RIGHT
new CubeIndex () { I0 = 3, I1 = 1, I2 = 7 },
new CubeIndex () { I0 = 1, I1 = 6, I2 = 7 },
// BACK
new CubeIndex () { I0 = 1, I1 = 0, I2 = 6 },
new CubeIndex () { I0 = 6, I1 = 0, I2 = 4 },
// BOTTOM
new CubeIndex () { I0 = 5, I1 = 6, I2 = 4 },
new CubeIndex () { I0 = 5, I1 = 7, I2 = 6 },
} );
vertexDeclarataion = Core.GraphicsDevice.CreateVertexDeclaration ( Utilities.CreateVertexElementArray<CubeVertex> () );
proj = new PerspectiveFieldOfViewProjection ();
lookAt = new LookAt ( new Vector3 ( 5, 5, 5 ), new Vector3 ( 0, 0, 0 ), new Vector3 ( 0, 1, 0 ) );
world = World3.Identity;
base.Intro ( args );
}
public override void StartEffect(EffectSequenceID effectSeqID) {
//D.Log("{0}.{1}.StartEffect({2}) called.", _effectsClient.DebugName, typeof(MortalEffectsManager).Name, effectSeqID.GetValueName());
if (effectSeqID == EffectSequenceID.Dying) {
// separate explosionSFXGo from ItemGo so destruction of ItemGo does not destroy explosionSFX before it is completed
GameObject explosionSFXGo = _generalFactory.MakeAutoDestruct3DAudioSFXInstance("ExplosionSFX", _effectsClient.Position);
References.SFXManager.PlaySFX(explosionSFXGo, SfxGroupID.Explosions);
_explosionEffect = _myPoolMgr.Spawn(EffectID.Explosion, _effectsClient.Position);
_explosionEffect.effectFinishedOneShot += (source, args) => {
_effectsClient.HandleEffectSequenceFinished(effectSeqID);
};
_explosionEffect.Play(_effectsClient.Radius);
return;
}
base.StartEffect(effectSeqID); // currently just calls HandleEffectFinished
}
/// <summary>
/// Sets up the terrain rendering effect
/// </summary>
protected virtual void SetupTerrainEffect( IEffect effect, IPlanet planet )
{
IPlanetTerrainPackTextureModel textureModel = ( IPlanetTerrainPackTextureModel )planet.PlanetModel.TerrainModel;
ITexture2d packTexture = textureModel.TerrainPackTexture;
ITexture2d typesTexture = textureModel.TerrainTypesTexture;
effect.Parameters[ "PlanetMaximumTerrainHeight" ].Set( planet.PlanetModel.TerrainModel.MaximumHeight.ToRenderUnits );
effect.Parameters[ "TerrainPackTexture" ].Set( packTexture );
effect.Parameters[ "TerrainTypeTexture" ].Set( typesTexture );
effect.Parameters[ "NoiseTexture" ].Set( m_NoiseTexture );
IPlanetAtmosphereRenderer atmosphereRenderer = planet.PlanetRenderer.AtmosphereRenderer;
if ( atmosphereRenderer != null )
{
atmosphereRenderer.SetupAtmosphereEffectParameters( effect, true, false );
}
}
public DefaultRenderRequest(
IRenderContext renderContext,
RasterizerState rasterizerState,
BlendState blendState,
DepthStencilState depthStencilState,
IEffect effect,
string techniqueName,
IEffectParameterSet effectParameterSet,
VertexBuffer meshVertexBuffer,
IndexBuffer meshIndexBuffer,
PrimitiveType primitiveType,
Matrix[] instances,
Action<List<Matrix>, VertexBuffer, IndexBuffer> computeCombinedBuffers)
{
#if DEBUG
GraphicsMetricsProfilerVisualiser.RenderRequestsCreated++;
#endif
RasterizerState = rasterizerState;
BlendState = blendState;
DepthStencilState = depthStencilState;
Effect = effect;
TechniqueName = techniqueName;
EffectParameterSet = effectParameterSet;
MeshVertexBuffer = meshVertexBuffer;
MeshIndexBuffer = meshIndexBuffer;
PrimitiveType = primitiveType;
Instances = instances;
_computeCombinedBuffers = computeCombinedBuffers;
// Now that the parameter set has been used in a request, prevent it
// from being changed.
EffectParameterSet.Lock(renderContext);
StateHash =
RasterizerState.GetHashCode() ^ 397 +
BlendState.GetHashCode() ^ 397 +
DepthStencilState.GetHashCode() ^ 397 +
Effect.GetHashCode() ^ 397 +
TechniqueName.GetHashCode() ^ 397 +
EffectParameterSet.GetStateHash() ^ 397 +
MeshVertexBuffer.GetHashCode() ^ 397 +
MeshIndexBuffer.GetHashCode() ^ 397 +
PrimitiveType.GetHashCode() ^ 397;
}
public void RenderLine(IRenderContext context, IEffect effect, IEffectParameterSet effectParameterSet, Vector3 start, Vector3 end, TextureAsset texture, Vector2 startUV, Vector2 endUV)
{
if (!context.IsCurrentRenderPass<I3DRenderPass>())
{
throw new InvalidOperationException("Can't use 3D rendering utilities in 2D context.");
}
var vertexes = _renderCache.GetOrSet(
"renderlinetex3dvb:" + start + ":" + end + ":" + startUV + ":" + endUV,
() =>
{
var vb = new VertexBuffer(context.GraphicsDevice, VertexPositionTexture.VertexDeclaration, 2,
BufferUsage.WriteOnly);
vb.SetData(new[] { new VertexPositionTexture(start, startUV), new VertexPositionTexture(end, endUV) });
return vb;
});
var indicies = _renderCache.GetOrSet(
"renderline3dib",
() =>
{
var ib = new IndexBuffer(context.GraphicsDevice, IndexElementSize.SixteenBits, 2,
BufferUsage.WriteOnly);
ib.SetData(new short[] { 0, 1 });
return ib;
});
context.GraphicsDevice.SetVertexBuffer(vertexes);
context.GraphicsDevice.Indices = indicies;
var semantic = effectParameterSet.GetSemantic<ITextureEffectSemantic>();
if (semantic.Texture != texture.Texture)
{
semantic.Texture = texture.Texture;
}
effect.LoadParameterSet(context, effectParameterSet);
foreach (var pass in effect.NativeEffect.CurrentTechnique.Passes)
{
pass.Apply();
context.GraphicsDevice.DrawPrimitives(PrimitiveType.LineList, 0, 1);
}
}
/// <summary>
/// Act method.
/// </summary>
/// <param name="value"> Value to execute behavior on. </param>
/// <param name="cancellationToken"> Cancellation token. </param>
public override void Act(IEffect value, CancellationToken cancellationToken)
{
try
{
this.InnerBehavior.Act(value, cancellationToken);
}
catch (OperationCanceledException)
{
throw;
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception ex)
{
this.log.ErrorFormat(
"Error occurred during execution of '{0}' behavior. Exception details: {1}",
this.ToString(),
ex);
}
}
public async Task AddEffect(IEffect effect, params IFilter[] filters)
{
await effect.Init(_outputSize);
var transformOptions = new ExecutionDataflowBlockOptions {
BoundedCapacity = 20, MaxDegreeOfParallelism = 8
};
var filterBlocks = filters.Select(x => new TransformBlock <OutputFrame, OutputFrame>(x.ApplyFilter, transformOptions)).ToList();
ITargetBlock <OutputFrame> firstBlock;
if (filterBlocks.Any())
{
var linkOptions = new DataflowLinkOptions {
PropagateCompletion = true
};
for (int i = 0; i < filterBlocks.Count; i++)
{
var thisBlock = (ISourceBlock <OutputFrame>)filterBlocks[i];
var nextBlock = (i + 1) >= filterBlocks.Count ? (ITargetBlock <OutputFrame>)_renderTransformBlock : filterBlocks[i + 1];
thisBlock.LinkTo(nextBlock, linkOptions);
}
firstBlock = filterBlocks[0];
}
else
{
firstBlock = _renderTransformBlock;
}
_ = Task.Run(async() =>
{
while (!_cts.IsCancellationRequested)
{
var frame = await effect.GetPixels();
await firstBlock.SendAsync(frame);
}
firstBlock.Complete();
});
}
public void RemoveEffect(IEffect effect)
{
switch (effect)
{
case IActiveEffect activeEffect:
_activeEffects.Remove(activeEffect);
break;
case IOnHitEffect onHitEffect:
_onHitBuffs.Remove(onHitEffect);
break;
case IStatBuff statBuff:
{
if (_statBuffs.TryGetValue(statBuff.StatType, out var buffList))
{
buffList.Remove(statBuff);
}
break;
}
}
}
protected override void DrawToBuffer(Graphics g)
{
g.Clear(SystemColors.Control);
if (EffectManager == null)
{
return;
}
int itemcount = vScrollBar1.Value == vScrollBar1.Maximum ? ShownItemNumber : ShownItemNumber + 1;
DrawGrid(g, itemcount);
int iter = -vScrollBar1.Value;
for (int i = EffectManager.Effects.Count - 1; i >= 0; i--)
{
IEffect effect = EffectManager.Effects[i];
if (effect is BaseEffect be)
{
bool first = true;
if (iter >= 0)
{
foreach (EffectStateRatioSet set in be.Sets.Values)
{
if (first)
{
DrawKey(new Point((set.StartFrame - hScrollBar1.Value) * KeyWidth, iter * ItemHeight + TimeLineAreaHeight), g, set.StartState == SelectedManager.State, true);
}
DrawKey(new Point((set.EndFrame - hScrollBar1.Value) * KeyWidth, iter * ItemHeight + TimeLineAreaHeight), g, set.EndState == SelectedManager.State, IsKey(set));
var rec = new Rectangle((set.StartFrame + 1 - hScrollBar1.Value) * KeyWidth, iter * ItemHeight + TimeLineAreaHeight, (set.EndFrame - set.StartFrame - 1) * KeyWidth, ItemHeight);
g.FillRectangle(Brushes.White, rec);
g.DrawRectangle(Pens.Black, rec);
first = false;
}
}
iter++;
}
}
DrawTimeLine(g, itemcount);
}
public Transition(Effect cEffectSource, Effect cEffectTarget)
: this()
{
try
{
if (null == cEffectSource) // TODO проверять видео или только аудио.....
{
_cEffectSource = new Composite(1, 1);
}
else
{
_cEffectSource = cEffectSource;
}
if (null == cEffectTarget)
{
_cEffectTarget = new Composite(1, 1);
}
else
{
_cEffectTarget = cEffectTarget;
}
#region z-layer
if (_cEffectSource.nLayer > _cEffectTarget.nLayer)
{
((IEffect)this).nLayer = _cEffectTarget.nLayer;
}
else
{
((IEffect)this).nLayer = _cEffectSource.nLayer;
}
#endregion
}
catch
{
Fail();
throw;
}
}
protected HashSet <Color> GetDiscreteColors(Object component)
{
HashSet <Color> validColors = new HashSet <Color>();
if (component is IEffect)
{
IEffect effect = (IEffect)component;
validColors.AddRange(effect.TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true)));
}
else if (component is Array)
{
foreach (var item in (Array)component)
{
if (item is IEffect)
{
IEffect effect = (IEffect)item;
validColors.AddRange(effect.TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true)));
}
}
}
return(validColors);
}
public void AddEffect()
{
using (ITimeline timeline = new DefaultTimeline())
{
IGroup group = timeline.AddVideoGroup(24, 100, 100);
IComposition composition = group.AddComposition();
bool firedBefore = false;
bool firedAfter = false;
composition.AddingEffect += delegate { firedBefore = true; };
composition.AddedEffect += delegate { firedAfter = true; };
IEffect effect = composition.AddEffect("test", -1, 1, 2, StandardEffects.CreateBlurEffect(2, 2, 10));
Assert.AreEqual("test", effect.Name);
Assert.AreEqual(1, effect.Offset);
Assert.AreEqual(2, effect.Duration);
Assert.AreEqual(1, composition.Effects.Count);
Assert.IsTrue(firedBefore);
Assert.IsTrue(firedAfter);
}
}
public void RenderTexture(
IRenderContext context,
IEffect effect,
IEffectParameterSet effectParameterSet,
Matrix matrix,
IAssetReference <TextureAsset> texture,
Color?color,
bool flipHorizontally,
bool flipVertically,
Rectangle?sourceArea)
{
if (!context.IsCurrentRenderPass <I3DRenderPass>())
{
throw new InvalidOperationException("Can't use 3D rendering utilities in 2D context.");
}
if (!texture.IsReady)
{
return;
}
RenderTexture(context, effect, effectParameterSet, matrix, texture.Asset.Texture, color, flipHorizontally, flipVertically, sourceArea);
}
public IRenderRequest CreateInstancedRequestFromState(
IRenderContext renderContext,
IEffect effect,
IEffectParameterSet effectParameterSet,
VertexBuffer meshVertexBuffer,
IndexBuffer meshIndexBuffer,
PrimitiveType primitiveType,
Matrix[] instancedWorldTransforms,
Action <List <Matrix>, VertexBuffer, IndexBuffer> computeCombinedBuffers)
{
return(CreateInstancedRequest(
renderContext,
renderContext.GraphicsDevice.RasterizerState,
renderContext.GraphicsDevice.BlendState,
renderContext.GraphicsDevice.DepthStencilState,
effect,
effectParameterSet,
meshVertexBuffer,
meshIndexBuffer,
primitiveType,
instancedWorldTransforms,
computeCombinedBuffers));
}
public static void Run()
{
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_Text();
//ExStart:AnimationEffectinParagraph
using (Presentation presentation = new Presentation(dataDir + "Presentation1.pptx"))
{
// select paragraph to add effect
IAutoShape autoShape = (IAutoShape)presentation.Slides[0].Shapes[0];
IParagraph paragraph = autoShape.TextFrame.Paragraphs[0];
// add Fly animation effect to selected paragraph
IEffect effect = presentation.Slides[0].Timeline.MainSequence.AddEffect(paragraph, EffectType.Fly, EffectSubtype.Left, EffectTriggerType.OnClick);
presentation.Save(dataDir + "AnimationEffectinParagraph.pptx", SaveFormat.Pptx);
}
//ExEnd:AnimationEffectinParagraph
}
public override void OnCollision(CollisionEvent e)
{
base.OnCollision(e);
//if(e.OtherSolid.UserData == null)
// GraphicalConsole.GetSingleton(game).WriteLine("Collision!!!");
//else
// GraphicalConsole.GetSingleton(game).WriteLine("Collision mit " + e.OtherSolid.UserData.ToString());
// do not burst in flames on collisions with own projectiles :)
if (!game.Physics.CanSolidsCollide(e.ThisSolid, e.OtherSolid))
{
return;
}
if (!Helper.Lock("Player1.Collision", TimeSpan.FromSeconds(1)))
{
game.Sounds.CreateSound("Desruptor").Play();
IEffect fx = game.Effects.CreateEffect("Explosion");
fx.Play(TimeSpan.FromSeconds(2), true);
game.World.AddEffect(fx);
}
}
void FullPaste()
{
DataFormats.Format format = DataFormats.GetFormat("mhdEffectBIN");
if (!Clipboard.ContainsData(format.Name))
{
Interaction.MsgBox("No effect data on the clipboard!", MsgBoxStyle.Information, "Unable to Paste");
}
else
{
using (MemoryStream memoryStream = new MemoryStream((byte[])Clipboard.GetDataObject().GetData(format.Name)))
using (BinaryReader reader = new BinaryReader(memoryStream))
{
string powerFullName = this.myFX.PowerFullName;
IPower power = this.myFX.GetPower();
IEnhancement enhancement = this.myFX.Enhancement;
this.myFX = new Effect(reader);
this.myFX.PowerFullName = powerFullName;
this.myFX.SetPower(power);
this.myFX.Enhancement = enhancement;
this.DisplayEffectData();
}
}
}
public static void LoadAll()
{
Res.Mark("LoadAll begins");
persistentLibrary = SimpleStorage.EditGroup(persistentLibraryName);
spellNames = persistentLibrary.Get <List <string> >(masterIndexName);
if (spellNames == null)
{
spellNames = new List <string>();
}
if (spellNames.Count == 0)
{
Inscribe(Spell.None); // Weird errors get thrown up with an empty master index.
}
LoadAllSpellSFX(Application.Context);
SpellFeedbackSFX = SpellSFX[defaultFeedbackSFXName];
SpellProgressSFX = SpellSFX[defaultProgressSFXName];
SpellSuccessSFX = SpellSFX[defaultSuccessSFXName];
Res.Mark("Spell SFX loaded");
SetUpResultFunctions();
}
public virtual void Update() // 클라이언트에서 기타 잡 기능을 없애고 이 업데이트로 자동으로 할당되게 했다. !
{ // 흑흑흑 너무 어렵다. 그러면 이펙트를 넣어주는것은 클라이언트가 아닌 캐릭터에서 해주는 것이 학계의 정론
if (effect == null)
{
return;
}
if (effect.OnExecute())
{
for (int i = 0, ii = effect.Transition.Length; ii > i; ++i)
{
IEffect Next = Get(effect.Transition[i]);
if (Next.IsTransition())
{
effect.OnExit();
effect = Next;
effect.OnEnter();
}
}
}
}
public async Task Log(Exception ex, IEffect effect)
{
var log =
new ExceptionLog
{
CallerFilePath = effect.CallerFilePath,
CallerLineNumber = effect.CallerLineNumber,
CallerMemberName = effect.CallerMemberName,
Exception = ex,
Parameters = Eff.Core.Utils.GetParametersValues(effect.State),
LocalVariables = Eff.Core.Utils.GetLocalVariablesValues(effect.State),
};
if (!ex.Data.Contains("StackTraceLog"))
{
var queue = new Queue <ExceptionLog>();
queue.Enqueue(log);
ex.Data["StackTraceLog"] = queue;
return;
}
((Queue <ExceptionLog>)ex.Data["StackTraceLog"]).Enqueue(log);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.BypassTools);
SetUpToolButtons();
OutputText = FindViewById <TextView>(Resource.Id.display_bypass_info_detailtext);
//SetTagRemovalResult(() => { }); // Has to exist or else we omit that whole infrastructure. Will get *changed* later.
// See if the current kit is already in our (local, for now) library, and load it if so.
var tkString = Res.SpecificTags.Get(InteractionLibrary.CurrentSpecificTag);
if (tkString != null)
{
ThePlayersToolkit = Toolkit.FromString(tkString, InteractionLibrary.CurrentSpecificTag);
}
else if (InteractionLibrary.CurrentSpecificTag == null) // I.E. this is a "launch directly" order.
{
ThePlayersToolkit = new MemorylessToolkit();
}
else
{
ThePlayersToolkit = new Toolkit(InteractionLibrary.CurrentSpecificTag);
}
SecurityPanel.Initialize(this);
InfoPanel = new BypassInfoPanel(this, SecurityPanel.CurrentPanel);
SetTypeface(Resource.Id.display_bypass_info_headertext, "FTLTLT.TTF");
CurrentStage = GestureRecognizerStage.NullStage;
WhistleFX = new Effect("Whistle", Resource.Raw._98195_whistling);
FindViewById(Resource.Id.choice_bypass_examine).CallOnClick();
OnBypassSuccessful += (o, e) => { OnBypassCompleted.Raise(e.Value); };
OnBypassFailed += (o, e) => { OnBypassCompleted.Raise(e.Value); };
}
/// <summary>
/// Explode this player if health is zero
/// </summary>
public override void Explode()
{
base.Explode();
this.Velocity = Vector3.Zero;
this.BoosterHeat = 0;
//Explosion
if (!respawn)
{
Helper.ResetWait("PlayerRespawn");
game.Sounds.CreateSound("Explosion").Play();
IEffect fx = game.Effects.CreateEffect("ExplosionBig");
fx.Play(TimeSpan.FromSeconds(2.5), true);
fx.Parent = this;
game.World.AddEffect(fx);
Visible = false;
Weapons.WeaponsVisible = false;
lifes--;
if (lifes <= 0)
{
base.Explode();
gameOver = true;
game.GameStates.Hud.DisplayScrollingText("G A M E O V E R ! !", time);
game.GameStates.Gameplayed = true;
if (Helper.Lock("ByeByeandie", TimeSpan.FromSeconds(7)))
{
Finish();
}
}
else
{
respawn = true;
}
}
}
public void RenderLine(IRenderContext context, IEffect effect, IEffectParameterSet effectParameterSet, Vector3 start, Vector3 end, Color color)
{
if (!context.IsCurrentRenderPass <I3DRenderPass>())
{
throw new InvalidOperationException("Can't use 3D rendering utilities in 2D context.");
}
var vertexes = _renderCache.GetOrSet(
"renderline3dvb:" + start + ":" + end + ":" + color,
() =>
{
var vb = new VertexBuffer(context.GraphicsDevice, VertexPositionColor.VertexDeclaration, 2,
BufferUsage.WriteOnly);
vb.SetData(new[] { new VertexPositionColor(start, color), new VertexPositionColor(end, color) });
return(vb);
});
var indicies = _renderCache.GetOrSet(
"renderline3dib",
() =>
{
var ib = new IndexBuffer(context.GraphicsDevice, IndexElementSize.SixteenBits, 2,
BufferUsage.WriteOnly);
ib.SetData(new short[] { 0, 1 });
return(ib);
});
context.GraphicsDevice.SetVertexBuffer(vertexes);
context.GraphicsDevice.Indices = indicies;
effect.LoadParameterSet(context, effectParameterSet);
foreach (var pass in effect.NativeEffect.CurrentTechnique.Passes)
{
pass.Apply();
context.GraphicsDevice.DrawPrimitives(PrimitiveType.LineList, 0, 1);
}
}
private async Task RunConnect()
{
var ct = ProcessCancel.Token;
var taskSet = new HashSet <Task>();
var blockSize = (int)(Param.SamplingRate * Param.SampleLength);
Logger.LogInformation($"[loop3] blockSize {blockSize}");
var audioInterval = (long)(10_000_000.0 * Param.SampleLength);
Logger.LogInformation($"[loop3] audioInterval {audioInterval}");
var videoInterval = (long)(10_000_000.0 / Param.MaxFrameRate);
Logger.LogInformation($"[loop3] videoInterval {videoInterval}");
var counter = new ElapsedTimeCounter();
using var audioWaiter = new Waiter(counter, audioInterval);
using var videoWaiter = new Waiter(counter, videoInterval);
using var buf = new IPCBuffer <float>(Param.EffectName, blockSize * 2 * Param.BufferCount, LoggerFactory);
using var vstBufferPool = new BufferPool <VstBuffer2 <float> >(Param.BufferCount, () => new VstBuffer2 <float>(blockSize, 2, buf), LoggerFactory);
using var pcmPool = new BufferPool <PcmBuffer <float> >(Param.BufferCount, () => new PcmBuffer <float>(blockSize, 2), LoggerFactory);
using var audioPool = new BufferPool <OpusOutputBuffer>(Param.BufferCount, () => new OpusOutputBuffer(5000), LoggerFactory);
using var pcmDrowPool = new BufferPool <PcmBuffer <float> >(Param.BufferCount, () => new PcmBuffer <float>(blockSize, 2), LoggerFactory);
using var bmpPool = new BufferPool <H264InputBuffer>(Param.BufferCount, () => new H264InputBuffer(Param.Width, Param.Height), LoggerFactory);
using var videoPool = new BufferPool <H264OutputBuffer>(Param.BufferCount, () => new H264OutputBuffer(200000), LoggerFactory);
using var vst = new AudioMaster <float>(Param.SamplingRate, blockSize, LoggerFactory, counter, DllManager);
using var toPcm = new ToPcm <float>(LoggerFactory, counter);
using var opus = new OpusEncoder(SamplingRate.Sampling48000, Channels.Stereo, LoggerFactory, counter);
using var fft = new FFTEncoder(Param.Width, Param.Height, Param.MaxFrameRate, LoggerFactory, counter);
using var h264 = new H264Encoder(Param.Width, Param.Height, Param.TargetBitrate, Param.MaxFrameRate, LoggerFactory, counter);
effect = vst.AddEffect(Param.EffectName);
//effect.OpenEditor();
using var ftl = new FtlIngest(StreamKey, IngestHostname, LoggerFactory, counter, audioInterval, videoInterval, default, CaInfoPath);
/// <summary>
/// Act method.
/// </summary>
/// <param name="value"> Value to execute behavior on. </param>
/// <param name="cancellationToken"> Cancellation token. </param>
public void Act(IEffect value, CancellationToken cancellationToken)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (this.firstChainLink == null)
{
throw new InvalidOperationException("No chain links were added");
}
List <IEffect> list;
if (this.effectIsBatch)
{
var enumerable = value as IEnumerable;
if (enumerable == null)
{
throw new ArgumentNullException("value", "effect is not collection");
}
list = enumerable.OfType <IEffect>().ToList();
}
else
{
list = new List <IEffect> {
value
};
}
foreach (var effect in list)
{
this.firstChainLink.Act(effect, cancellationToken);
}
}
public AttackInfo(IReach reach = null, IEffect effect = null, ITargetFilter filter = null, IAnimation animation = null)
{
this.Reach = reach;
this.Effect = effect;
this.Filter = filter;
AttackAnimation = animation;
if (reach == null)
{
this.Reach = new Melee();
}
if (effect == null)
{
this.Effect = new Damage();
}
if (filter == null)
{
this.Filter = new TargetEnemy();
}
if (animation == null)
{
AttackAnimation = new Tackle();
}
}
public override void Execute()
{
IEffect effect = manager.Effects[itemindex];
for (int i = 0; i < effect.Sets.Count; i++)
{
EffectStateRatioSet set = effect.Sets.Values[i];
if (set.StartFrame == keyindex)
{
previousset1 = (EffectStateRatioSet)set.CloneExceptState();
effect.Sets.RemoveAt(i);
break;
}
else if (set.EndFrame == keyindex)
{
if (i == effect.Sets.Count - 1)
{
previousset1 = (EffectStateRatioSet)set.CloneExceptState();
effect.Sets.RemoveAt(i);
}
else
{
EffectStateRatioSet nextset = effect.Sets.Values[i + 1];
previousset1 = (EffectStateRatioSet)set.CloneExceptState();
previousset2 = (EffectStateRatioSet)nextset.CloneExceptState();
effect.Sets.RemoveAt(i);
effect.Sets.RemoveAt(i);
nextset.StartFrame = set.StartFrame;
nextset.StartState = set.StartState;
effect.Sets.Add(nextset.StartFrame, nextset);
insertindex = i;
}
break;
}
}
}
public void UpdateSubSubList()
{
int index1 = 0;
lvSubSub.BeginUpdate();
lvSubSub.Items.Clear();
string[] strArray = new string[0];
IEffect fx = myFX;
if ((fx.EffectType == Enums.eEffectType.Enhancement | fx.EffectType == Enums.eEffectType.ResEffect) & fx.ETModifies == Enums.eEffectType.Mez)
{
lvSubSub.Columns[0].Text = "Mez Type";
strArray = Enum.GetNames(fx.MezType.GetType());
index1 = (int)fx.MezType;
}
if (strArray.Length > 0)
{
int num = strArray.Length - 1;
for (int index2 = 0; index2 <= num; ++index2)
{
lvSubSub.Items.Add(strArray[index2]);
}
lvSubSub.Enabled = true;
}
else
{
lvSubSub.Enabled = false;
lvSubSub.Columns[0].Text = "";
}
if (lvSubSub.Items.Count > index1)
{
lvSubSub.Items[index1].Selected = true;
lvSubSub.Items[index1].EnsureVisible();
}
lvSubSub.EndUpdate();
}
/// <summary>
/// Returns a new <see cref="Image"/> with the specified effect.
/// </summary>
/// <param name="image">Image object to which the effect is applied.</param>
/// <param name="effect">Effect type.</param>
/// <returns>
/// Returns a new <see cref="Image"/>, result of applying the effect to specified image .
/// </returns>
public static Image ApplyEffect(this Image image, IEffect effect)
{
SentinelHelper.ArgumentNull(image, nameof(image));
Image imageWithEffect;
using (var bmp = new Bitmap(image.Width, image.Height))
using (var graphics = Graphics.FromImage(bmp))
{
bmp.SetResolution(image.HorizontalResolution, image.VerticalResolution);
graphics.DrawImage(
image,
new Rectangle(0, 0, bmp.Width, bmp.Height),
0,
0,
bmp.Width,
bmp.Height,
GraphicsUnit.Pixel,
effect.Apply());
imageWithEffect = (Image)bmp.Clone();
}
return(imageWithEffect);
}
/// <summary>
/// Render the object.
/// </summary>
/// <param name="effect">The current effect that is used for rendering.</param>
public void Render(IEffect effect)
{
/*// animate skeleton
* if (skeleton != null && skeletonAnimation != null)
* player.Interpolate(skeleton, skeletonAnimation);*/
mesh.Render(effect);
// Render all attached models.
foreach (ModelBinding b in modelBindings)
{
Matrix4 world = Device.Instance.Transformations.World;
if (b.JointNum == -1)
{
b.Model.Render(effect);
}
else
{
Device.Instance.Transformations.World = skeleton.PreBound[b.JointNum] * world;
b.Model.Render(effect);
Device.Instance.Transformations.World = world;
}
}
}
public void AddEffectsToTrack()
{
using (ITimeline timeline = new DefaultTimeline())
{
IGroup group = timeline.AddVideoGroup(24, 320, 200);
ITrack track = group.AddTrack();
IEffect effect = track.AddEffect("test", -1, 1, 3, StandardEffects.CreateBlurEffect(2, 2, 15));
Assert.AreEqual(1, track.Effects.Count);
Assert.AreSame(effect, track.Effects[0]);
PrepareToExecute(timeline,
@"<timeline framerate=""30.0000000"">
<group type=""video"" bitdepth=""24"" height=""200"" framerate=""30.0000000"" previewmode=""0"">
<track>
<effect clsid=""{7312498D-E87A-11D1-81E0-0000F87557DB}"" username=""test"">
<param name=""PixelRadius"" value=""2"">
<linear time=""2"" value=""15"" />
</param>
</effect>
</track>
</group>
</timeline>");
}
}
public static SimplifiedEffect createSimplifiedEffect(IEffect effect, WriterInfo info)
{
if (effect is IMultiEffect)
{
info.createSimplifiedMultiEffect(effect as IMultiEffect);
}
else if (effect is PalmMute)
{
return(new SimplifiedPalmMute());
}
else if (effect is Bend)
{
return(new SimplifiedBend(effect as Bend));
}
else if (effect is PinchHarmonic)
{
return(new SimplifiedPinchHarmonic());
}
else if (effect is Vibrato)
{
return(new SimplifiedVibrato(effect as Vibrato));
}
return(null);
}
public void CheckStatus()
{
float flatValue = 0f;
float percentage = 0f;
for (int i = 0; i < this.effects.Count; i++)
{
IEffect effect = (IEffect)this.effects [i];
if (effect.GetType() == typeof(CrippleEffect))
{
CrippleEffect ce = (CrippleEffect)effect;
flatValue += ce.GetFlatValue();
percentage += ce.GetPercentage();
}
}
this.currentSpeed = (this.speed - flatValue) * (1 - percentage);
if (currentSpeed < 0)
{
this.currentSpeed = 0;
}
print("Current speed is " + this.currentSpeed);
}
public static Card TestCard(List <IEffect> buffs)
{
IEffect head = CardFactory.MakeEffect(EffecID.MagicDamage, 5);
IEffect nowEffect = head;
foreach (var buff in buffs)
{
setAction(buff);
}
return(new Card()
{
guid = Guid.NewGuid(),
id = 1,
type = Type.attack,
cost = 5,
cardAction = head
});
void setAction(IEffect effect)
{
nowEffect.SetNextAction(effect);
nowEffect = effect;
}
}
void _timer_Tick(object sender, EventArgs e)
{
if (!(bool)AppContext.Instance.LearningMode.Value)
{
SetProgresBarValue(this.TimeProgress.Value - 1); //nije najsretniji način za pratiti vrijeme griješi tu i tamo..:)
}
if (this.TimeProgress.Value <= this.TimeProgress.Minimum)
{
StopLevel();
}
//prvih 5 sec nema niti jednog efekta
double elapsed = (DateTime.Now - _taskStartTime).TotalSeconds;
if (elapsed > 5 && (_lastEffect == null || !_lastEffect.Active))
{
IEffect effect = LevelManager.GetRandomEffect(_currentLevel);
if (effect != null)
{
effect.Execute();
_lastEffect = effect;
}
}
}
