public void Start()
{
meshRenderer = GetComponent <MeshRenderer>();
material = Object.Instantiate(meshRenderer.sharedMaterial);
meshRenderer.material = material;
effectComponent = transform.parent.gameObject.GetComponent <EffectComponent>();
}
public void Add(ActType actType)
{
if (actComponet.ContainsKey(actType))
{
return;
}
ActComponent act = null;
switch (actType)
{
case ActType.Null:
break;
case ActType.Anim:
act = new AnimComponent(this);
break;
case ActType.Audio:
act = new AudioComponent(this);
break;
case ActType.Effect:
act = new EffectComponent(this);
break;
default:
break;
}
if (act != null)
{
actComponet.Add(actType, act);
}
}
public void Start()
{
EffectComponent effectComp = this.GetComponent <EffectComponent>();
EffectData data = effectComp.effectData;
this.useTarget = data.genericBool;
this.duration = data.genericFloat;
this.start = data.origin;
this.end = data.start;
if (this.useTarget)
{
this.target = data.ResolveHurtBoxReference().transform;
this.startDist = Vector3.Distance(this.start, this.target.position);
}
else
{
this.startDist = Vector3.Distance(this.start, this.end);
}
this.timeLeft = this.duration;
this.prevPos = this.start;
var startVelocity = (this.end - this.start) / this.duration;
var direction = startVelocity.normalized;
base.transform.forward = direction;
this.transform.position = this.start;
this.rb = base.GetComponent <Rigidbody>();
this.rb.velocity = startVelocity;
RoR2.Util.PlayScaledSound(this.startSound, this.gameObject, 2.0f);
}
protected override void Hook()
{
if (!toBeDisabled)
{
toBeDisabled = Resources.Load <GameObject>("prefabs/effects/GrandparentGroundSwipeTrailEffect").AddComponent <EffectComponent>();
}
}
private void addPixelShaderButton_Click(object sender, EventArgs e)
{
EffectComponent component = new EffectComponent();
component.Name = "NewPixelShader";
component.IsInline = false;
HlslSemantic outputSemantic = Semantics.Find("COLOR", true, false);
outputSemantic.ResourceNumber = 0;
component.ReturnType.Add(new EffectParameterDefinition(
"Color",
outputSemantic.Type,
outputSemantic));
mEffectDefinition.PixelShaders.Add(component);
effectEdit_pixelShaderListChanged(sender, e);
pixelShadersList.SelectedItem = component;
if (mEffectDefinition.PixelShaders.Count > 0)
{
pixelShaderEditor.Enabled = true;
}
}
public void Recycle(EffectComponent component)
{
component.GameObject.SetActive(false);
component.SpriteRenderer.sprite = null;
component.transform.position = Origin;
EffectPool.Push(component);
}
private void addVertexShaderButton_Click(object sender, EventArgs e)
{
EffectComponent component = new EffectComponent();
component.Name = "NewVertexShader";
component.IsInline = false;
HlslSemantic inputSemantic = Semantics.Find("POSITION", true, true);
inputSemantic.ResourceNumber = 0;
component.Parameters.Add(new EffectParameterDefinition(
"Position",
inputSemantic.Type,
inputSemantic));
HlslSemantic outputSemantic = Semantics.Find("POSITION", true, false);
outputSemantic.ResourceNumber = 0;
component.ReturnType.Add(new EffectParameterDefinition(
"Position",
outputSemantic.Type,
outputSemantic));
mEffectDefinition.VertexShaders.Add(component);
effectEdit_vertexShaderListChanged(sender, e);
vertexShadersList.SelectedItem = component;
if (mEffectDefinition.VertexShaders.Count > 0)
{
vertexShaderEditor.Enabled = true;
}
}
public static Entity NewBlock(Vector3 positionValues, Texture2D texture, string typeName)
{
Entity block = EntityFactory.NewEntity(typeName);
TransformComponent transformComponent = new TransformComponent(block, new Vector3(x: positionValues.X, y: positionValues.Y, z: positionValues.Z));
ModelComponent modelComponent = new ModelComponent(block, AssetManager.Instance.GetContent <Model>("Models/block2"));
modelComponent.World = Matrix.CreateWorld(transformComponent.Position, Vector3.Forward, Vector3.Up);
TextureComponent textureComponent = new TextureComponent(block, texture);
CollisionComponent collisionComponent = new CollisionComponent(block, new BoxVolume(EntityFactory.CreateBoundingBox(modelComponent.Model)));
LightComponent lightComponent = new LightComponent(block, new Vector3(0, 7, -5), Color.White.ToVector4(), 10f, Color.Blue.ToVector4(), 0.2f, Color.White.ToVector4(), 1000f);
EffectComponent effectComponent = new EffectComponent(block, AssetManager.Instance.GetContent <Effect>("Shading"));
BlockComponent blockComponent = new BlockComponent(block);
ComponentManager.Instance.AddComponentToEntity(block, transformComponent);
ComponentManager.Instance.AddComponentToEntity(block, modelComponent);
ComponentManager.Instance.AddComponentToEntity(block, textureComponent);
ComponentManager.Instance.AddComponentToEntity(block, collisionComponent, typeof(CollisionComponent));
ComponentManager.Instance.AddComponentToEntity(block, blockComponent);
ComponentManager.Instance.AddComponentToEntity(block, effectComponent);
ComponentManager.Instance.AddComponentToEntity(block, lightComponent);
TransformHelper.SetInitialModelPos(modelComponent, transformComponent);
TransformHelper.SetBoundingBoxPos(collisionComponent, transformComponent);
//EntityFactory.AddBoundingBoxChildren((BoxVolume)collisionComponent);
return(block);
}
public static Entity NewBasePlayer(String model, int gamePadIndex, Vector3 transformPos, Texture2D texture, String typeName)
{
Entity player = EntityFactory.NewEntity(typeName);
TransformComponent transformComponent = new TransformComponent(player, transformPos);
ModelComponent modelComponent = new ModelComponent(player, AssetManager.Instance.GetContent <Model>(model));
VelocityComponent velocityComponent = new VelocityComponent(player);
CollisionComponent collisionComponent = new CollisionComponent(player, new BoxVolume(EntityFactory.CreateBoundingBox(modelComponent.Model)));
PlayerComponent playerComponent = new PlayerComponent(player);
FrictionComponent frictionComponent = new FrictionComponent(player);
TextureComponent textureComponent = new TextureComponent(player, texture);
GravityComponent gravityComponent = new GravityComponent(player);
EffectComponent effectComponent = new EffectComponent(player, AssetManager.Instance.GetContent <Effect>("Shading"));
ComponentManager.Instance.AddComponentToEntity(player, modelComponent);
ComponentManager.Instance.AddComponentToEntity(player, transformComponent);
ComponentManager.Instance.AddComponentToEntity(player, velocityComponent);
ComponentManager.Instance.AddComponentToEntity(player, collisionComponent, typeof(CollisionComponent));
ComponentManager.Instance.AddComponentToEntity(player, playerComponent);
ComponentManager.Instance.AddComponentToEntity(player, frictionComponent);
ComponentManager.Instance.AddComponentToEntity(player, textureComponent);
ComponentManager.Instance.AddComponentToEntity(player, gravityComponent);
ComponentManager.Instance.AddComponentToEntity(player, effectComponent);
TransformHelper.SetInitialModelPos(modelComponent, transformComponent);
TransformHelper.SetBoundingBoxPos(collisionComponent, transformComponent);
//TransformHelper.SetInitialModelPos(modelComponent, transformComponent);
//TransformHelper.SetInitialBoundingSpherePos(collisionComponent, transformComponent);
return(player);
}
public static void AddEffect(GameObject effect)
{
if (!loaded)
{
throw new CoreNotLoadedException(nameof(EffectsCore));
}
if (effect == null)
{
throw new ArgumentNullException("effect");
}
EffectComponent effectComp = effect.GetComponent <EffectComponent>();
if (effectComp == null)
{
throw new ArgumentException("must have an EffectComponent", "effect");
}
VFXAttributes vfx = effect.GetComponent <VFXAttributes>();
if (vfx == null)
{
throw new ArgumentException("must have a VFXAttributesComponent", "effect");
}
AddEffect(new EffectDef
{
prefab = effect,
prefabEffectComponent = effectComp,
prefabVfxAttributes = vfx,
prefabName = effect.name,
spawnSoundEventName = effectComp.soundName,
});
}
private void newComponentToolStripMenuItem_Click(object sender, EventArgs e)
{
EffectComponent component = new EffectComponent();
component.Name = "NewComponent";
componentEditor.SetComponent(component);
}
protected override void ConfigureEffect(EffectComponent effect)
{
base.ConfigureEffect(effect);
effect.EffectType = EffectType.PhysicalDamage;
effect.SecondaryAmount = ArmorPenetration;
}
public ComponentEditor()
{
InitializeComponent();
// Populate Vertex and Pixel Shader profiles
this.SuspendLayout();
mShaderProfileNames = Enum.GetNames(typeof(Microsoft.Xna.Framework.Graphics.ShaderProfile));
vertexShaderProfileSelector.Items.Clear();
pixelShaderProfileSelector.Items.Clear();
for (int i = 0; i < mShaderProfileNames.Length; i++)
{
if (mShaderProfileNames[i].Contains("VS"))
{
vertexShaderProfileSelector.Items.Add(mShaderProfileNames[i]);
}
if (mShaderProfileNames[i].Contains("PS"))
{
pixelShaderProfileSelector.Items.Add(mShaderProfileNames[i]);
}
}
this.ResumeLayout(true);
// Create a new component
EffectComponent newComponent = new EffectComponent();
newComponent.Name = "NewComponent";
SetComponent(newComponent);
}
/*
* Draws all Models in ModelComponents.
* Requires a CameraComponent to exist on some Entity.
*/
private void DrawModelsWithEffects(GameTime gameTime)
{
//Undoes any changes from using the spritebatch
graphicsDevice.BlendState = BlendState.Opaque;
graphicsDevice.DepthStencilState = DepthStencilState.Default;
graphicsDevice.SamplerStates[0] = SamplerState.LinearWrap;
ConcurrentDictionary <Entity, Component> modelComponents = ComponentManager.Instance.GetConcurrentDictionary <ModelComponent>();
ConcurrentDictionary <Entity, Component> cameraComponentPairs = ComponentManager.Instance.GetConcurrentDictionary <CameraComponent>();
if (cameraComponentPairs.Count == 0)
{
return;
}
CameraComponent cameraComponent = (CameraComponent)cameraComponentPairs.First().Value; //get the cameracomponent for the local player
foreach (var modelComponentPair in modelComponents)
{
ModelComponent model = modelComponentPair.Value as ModelComponent;
var collisionComponent = ComponentManager.Instance.ConcurrentGetComponentOfEntity <CollisionComponent>(modelComponentPair.Key);
if (cameraComponent.BoundingFrustum.Intersects(collisionComponent.BoundingVolume.BoundingSphere) || cameraComponent.BoundingFrustum.Intersects(collisionComponent.BoundingVolume.BoundingBox))
{
TextureComponent textureComponent = ComponentManager.Instance.ConcurrentGetComponentOfEntity <TextureComponent>(modelComponentPair.Key);
EffectComponent effectComponent = ComponentManager.Instance.ConcurrentGetComponentOfEntity <EffectComponent>(modelComponentPair.Key);
TransformComponent transformcComponent = ComponentManager.Instance.ConcurrentGetComponentOfEntity <TransformComponent>(modelComponentPair.Key);
var viewVector = Vector3.Transform(cameraComponent.Target - cameraComponent.Position, Matrix.CreateRotationY(0));
viewVector.Normalize();
model.BoneTransformations[0] = model.World;
foreach (var modelMesh in model.Model.Meshes)
{
foreach (ModelMeshPart part in modelMesh.MeshParts)
{
part.Effect = effectComponent.Effect;
part.Effect.Parameters["DiffuseLightDirection"].SetValue(transformcComponent.Position + Vector3.Up);
part.Effect.Parameters["World"].SetValue(model.BoneTransformations[modelMesh.ParentBone.Index] * EngineHelper.Instance().WorldMatrix);
part.Effect.Parameters["View"].SetValue(cameraComponent.ViewMatrix);
part.Effect.Parameters["Projection"].SetValue(cameraComponent.ProjectionMatrix);
part.Effect.Parameters["ViewVector"].SetValue(viewVector);
part.Effect.Parameters["CameraPosition"].SetValue(cameraComponent.Position);
var worldInverseTransposeMatrix = Matrix.Transpose(Matrix.Invert(modelMesh.ParentBone.Transform * EngineHelper.Instance().WorldMatrix));
part.Effect.Parameters["WorldInverseTranspose"].SetValue(worldInverseTransposeMatrix);
if (textureComponent != null)
{
part.Effect.Parameters["ModelTexture"].SetValue(textureComponent.Texture);
}
}
modelMesh.Draw();
}
}
}
}
public void EquipEffectComponent(EffectComponent effect)
{
effectComponent = effect;
GameManager.Instance.UiManager.GameOverlay.SetEffectImage(effect.icon);
GameManager.Instance.UiManager.PanelSkills.SetEffectImage(effect.icon);
_spellMaterial.SetColor("Color_CD32963E", effect.Color);
}
protected override void UnHook()
{
if (toBeDisabled)
{
UnityEngine.GameObject.Destroy(toBeDisabled);
}
toBeDisabled = null;
}
private void loadComponentToolStripMenuItem_Click(object sender, EventArgs e)
{
if (openComponentDialog.ShowDialog() == DialogResult.OK)
{
EffectComponent component = EffectComponent.FromFile(openComponentDialog.FileName);
componentEditor.SetComponent(component);
}
}
protected override void ConfigureEffect(EffectComponent effect)
{
base.ConfigureEffect(effect);
effect.EffectType = EffectType.ChangeRace;
effect.TargetName = RaceName;
effect.Amount = Remove ? -1 : 1;
}
private void EffectComponent_Start(On.RoR2.EffectComponent.orig_Start orig, EffectComponent self)
{
orig(self);
if (frameRateHazard)
{
DestroyImmediate(self.gameObject);
}
}
protected override void ConfigureEffect(EffectComponent effect)
{
Debug.Assert(DurationAmount == null ||
Duration == EffectDuration.UntilTimeout ||
Duration == EffectDuration.UntilXPGained);
effect.Duration = Duration;
effect.DurationAmount = DurationAmount;
}
private void pixelShadersList_SelectedIndexChanged(object sender, EventArgs e)
{
if (pixelShadersList.SelectedIndex != -1 &&
pixelShadersList.Items.Count > 0)
{
EffectComponent component = (EffectComponent)pixelShadersList.SelectedItem;
pixelShaderEditor.SetComponent(component);
}
}
protected override void ConfigureEffect(EffectComponent effect)
{
base.ConfigureEffect(effect);
effect.EffectType = EffectType.ChangeProperty;
effect.TargetName = PropertyName;
effect.Amount = Value.ToInt32(CultureInfo.InvariantCulture);
effect.Function = Function;
}
public void Start()
{
EffectComponent effectComp = this.GetComponent <EffectComponent>();
EffectData data = effectComp.effectData;
this.timeLeft = data.genericFloat;
this.StartCoroutine(this.DestroyOnTimer(this.timeLeft));
}
public virtual void ApplyEffect(EffectComponent effectComponent)
{
_effectComponent = effectComponent;
if (!IsInvoking("TriggerEffect"))
{
_effectTimer = effectComponent.Duration;
InvokeRepeating("TriggerEffect", effectComponent.Duration, 1f);
}
}
// Token: 0x06001EEB RID: 7915 RVA: 0x00091D90 File Offset: 0x0008FF90
private void Start()
{
EffectComponent component = base.GetComponent <EffectComponent>();
Color color = (component.effectData != null) ? component.effectData.color : Color.white;
for (int i = 0; i < this.particleSystems.Length; i++)
{
this.particleSystems[i].main.startColor = color;
this.particleSystems[i].Play();
}
}
private static void FixGrandParentSwipeEffect()
{
if (!swipeEffect.HasComponent <EffectComponent>())
{
EffectComponent effectComponent = swipeEffect.AddComponent <EffectComponent>();
effectComponent.positionAtReferencedTransform = true;
effectComponent.parentToReferencedTransform = false;
effectComponent.applyScale = false;
effectComponent.disregardZScale = false;
}
}
protected override void ConfigureEffect(EffectComponent effect)
{
base.ConfigureEffect(effect);
effect.EffectType = EffectType.Activate;
if (Projectile != null)
{
var item = Item.Loader.Get(Projectile).AddToEntity(effect.Entity);
effect.TargetEntityId = item.EntityId;
}
}
private void UpdateAvailableComponents()
{
mLoadedComponents.Clear();
foreach (string componentFileName in mEffectDefinition.Components)
{
mLoadedComponents.Add(EffectComponent.FromFile(componentFileName));
}
vertexShaderEditor.AvailableComponents = mLoadedComponents;
pixelShaderEditor.AvailableComponents = mLoadedComponents;
}
protected override Task Handle(AddEffectEvent e, CancellationToken cancellation)
{
var effects = e.Sender.GetComponent <EffectComponent>();
if (effects == null)
{
effects = new EffectComponent(e.Sender);
e.Sender.AddComponent(effects);
}
effects.Effects.Add(new EffectComponent.Effect(e.EffectId, e.Cooldown));
return(Task.CompletedTask);
}
public void Update(Identity identity, EffectComponent effect, GameobjectComponent gameobjectComponent)
{
if (effect.enable == false)
{
return;
}
Animator animator = gameobjectComponent.animator;
AnimatorStateInfo info = animator.GetCurrentAnimatorStateInfo(0);
if (info.normalizedTime >= 1.0f)
{
world.entitySystem.DestroyEntity(identity.entity);
}
}
