public PositionPathTweenProperty(GoSpline path, bool isRelative = false, bool useLocalPosition = false, LookAtType lookAtType = LookAtType.None, Transform lookTarget = null) : base(isRelative)
{
_path = path;
_useLocalPosition = useLocalPosition;
_lookAtType = lookAtType;
_lookTarget = lookTarget;
}
public override int GetHashCode()
{
int hash = 1;
hash ^= offsetFromHeadBone_.GetHashCode();
if (LookAtType != global::VrmProtobuf.LookAt.Types.LookAtType.Bone)
{
hash ^= LookAtType.GetHashCode();
}
if (lookAtHorizontalInner_ != null)
{
hash ^= LookAtHorizontalInner.GetHashCode();
}
if (lookAtHorizontalOuter_ != null)
{
hash ^= LookAtHorizontalOuter.GetHashCode();
}
if (lookAtVerticalDown_ != null)
{
hash ^= LookAtVerticalDown.GetHashCode();
}
if (lookAtVerticalUp_ != null)
{
hash ^= LookAtVerticalUp.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public PositionPathTweenProperty( GoSpline path, bool isRelative = false, bool useLocalPosition = false, LookAtType lookAtType = LookAtType.None, Transform lookTarget = null )
: base(isRelative)
{
_path = path;
_useLocalPosition = useLocalPosition;
_lookAtType = lookAtType;
_lookTarget = lookTarget;
}
/// <summary>
/// position path tween
/// </summary>
public TweenConfig positionPath(GoSpline path, bool isRelative = false, LookAtType lookAtType = LookAtType.None, Transform lookTarget = null)
{
var prop = new PositionPathTweenProperty(path, isRelative, false, lookAtType, lookTarget);
_tweenProperties.Add(prop);
return(this);
}
private void Avatars_OnLookAt(LLUUID sourceID, LLUUID targetID, LLVector3d targetPos,
LookAtType lookType, float duration, LLUUID id)
{
if (ShowEffects)
Console.WriteLine(
"ViewerEffect [LookAt]: SourceID: {0} TargetID: {1} TargetPos: {2} Type: {3} Duration: {4} ID: {5}",
sourceID.ToString(), targetID.ToString(), targetPos, lookType, duration,
id.ToString());
}
private void Avatars_OnLookAt(LLUUID sourceID, LLUUID targetID, LLVector3d targetPos,
LookAtType lookType, float duration, LLUUID id)
{
if (ShowEffects)
{
Console.WriteLine(
"ViewerEffect [LookAt]: SourceID: {0} TargetID: {1} TargetPos: {2} Type: {3} Duration: {4} ID: {5}",
sourceID.ToString(), targetID.ToString(), targetPos, lookType, duration,
id.ToString());
}
}
public TweenCaseTransfomLookAt2D(Transform tweenObject, Vector3 resultValue, LookAtType type) : base(tweenObject, resultValue)
{
this.type = type;
startValue = tweenObject.eulerAngles;
Vector3 different = (resultValue - tweenObject.position);
different.Normalize();
rotationZ = (Mathf.Atan2(different.y, different.x) * Mathf.Rad2Deg);
if (type == LookAtType.Up)
{
rotationZ -= 90;
}
}
public override void prepareForUse()
{
_target = _ownerTween.target as Transform;
// if this is a from tween first reverse the path then build it
if (_ownerTween.isFrom)
{
_path.reverseNodes();
}
else
{
_path.unreverseNodes();
}
_path.buildPath();
// a from tween means the start value is the last node
if (_ownerTween.isFrom)
{
_startValue = _path.getLastNode();
}
else
{
if (_useLocalPosition)
{
_startValue = _target.localPosition;
}
else
{
_startValue = _target.position;
}
}
// validate the lookTarget if we are set to look at it
if (_lookAtType == LookAtType.TargetTransform)
{
if (_lookTarget == null)
{
_lookAtType = LookAtType.None;
}
}
// prep our smoothed rotation
_smoothedRotation = _target.rotation;
}
public ViewerEffectLookAtEventArgs(UUID sourceID, UUID targetID, Vector3d targetPos, LookAtType lookType, float duration, UUID id)
{
this.m_SourceID = sourceID;
this.m_TargetID = targetID;
this.m_TargetPosition = targetPos;
this.m_LookType = lookType;
this.m_Duration = duration;
this.m_EffectID = id;
}
public void SetLookatType(LookAtType type)
{
m_LookAtType = type;
}
public static void WriteLookAtType(this PacketWriter writer, LookAtType data)
{
writer.WriteByte((byte)data);
}
/// <summary>
/// position path tween
/// </summary>
public TweenConfig positionPath( GoSpline path, bool isRelative = false, LookAtType lookAtType = LookAtType.None, Transform lookTarget = null )
{
var prop = new PositionPathTweenProperty( path, isRelative, false, lookAtType, lookTarget );
_tweenProperties.Add( prop );
return this;
}
private void LookForOtherModifiers(QNT_Timestamp startTick, QNT_Timestamp endTick, LookAtType type)
{
startTick.tick -= 120;
QNT_Timestamp _endTick = endTick;
if (endTick.tick == 0)
{
_endTick = startTick;
}
_endTick.tick += 120;
int lowestLevelFound = 0;
for (int i = 0; i < Enum.GetNames(typeof(ModifierType)).Length; i++)
{
bool skip = false;
foreach (Modifier mod in ModifierHandler.Instance.modifiers)
{
if (mod == this)
{
continue;
}
if (mod.startTime <= startTick && mod.endTime >= _endTick)
{
if (mod.level == i)
{
skip = true;
break;
}
}
else if (startTick <= mod.startTime && _endTick >= mod.startTime)
{
if (mod.level == i)
{
skip = true;
break;
}
}
else if (startTick == mod.endTime && startTick.tick != 0)
{
if (mod.level == i)
{
skip = true;
break;
}
}
else if (startTick > mod.startTime && startTick < mod.endTime && _endTick > mod.endTime)
{
if (mod.level == i)
{
skip = true;
break;
}
}
}
if (skip)
{
continue;
}
lowestLevelFound = i;
break;
}
if (type == LookAtType.End)
{
if (lowestLevelFound < level)
{
return;
}
}
level = lowestLevelFound;
float addY = level * .3f;
ModifierSelectionHandler.Instance.posGetter.localPosition = pStartPos;
Vector3 newPos = ModifierSelectionHandler.Instance.posGetter.localPosition;
newPos.y -= addY;
if (startMarkExists)
{
newPos.x = startMark.transform.localPosition.x;
startMark.transform.localPosition = newPos;
}
if (endMarkExists)
{
newPos.x = endMark.transform.localPosition.x;
endMark.transform.localPosition = newPos;
}
}
public override void prepareForUse()
{
_target = _ownerTween.target as Transform;
// if this is a from tween first reverse the path then build it
if( _ownerTween.isFrom )
_path.reverseNodes();
else
_path.unreverseNodes();
_path.buildPath();
// a from tween means the start value is the last node
if( _ownerTween.isFrom )
{
_startValue = _path.getLastNode();
}
else
{
if( _useLocalPosition )
_startValue = _target.localPosition;
else
_startValue = _target.position;
}
// validate the lookTarget if we are set to look at it
if( _lookAtType == LookAtType.TargetTransform )
{
if( _lookTarget == null )
_lookAtType = LookAtType.None;
}
// prep our smoothed rotation
_smoothedRotation = _target.rotation;
}
/// <summary>
/// Process an incoming effect
/// </summary>
private void ViewerEffectHandler(Packet packet, Simulator simulator)
{
ViewerEffectPacket effect = (ViewerEffectPacket)packet;
foreach (ViewerEffectPacket.EffectBlock block in effect.Effect)
{
EffectType type = (EffectType)block.Type;
//LLColor color;
//if (block.Color.Length == 4)
//{
// color = new LLColor(block.Color, 0);
//}
//else
//{
// Client.Log("Received a ViewerEffect.EffectBlock.Color array with " + block.Color.Length +
// " bytes", Helpers.LogLevel.Warning);
// color = LLColor.Black;
//}
// Each ViewerEffect type uses it's own custom binary format for additional data. Fun eh?
switch (type)
{
case EffectType.Text:
Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
Helpers.LogLevel.Warning, Client);
break;
case EffectType.Icon:
Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
Helpers.LogLevel.Warning, Client);
break;
case EffectType.Connector:
Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
Helpers.LogLevel.Warning, Client);
break;
case EffectType.FlexibleObject:
Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
Helpers.LogLevel.Warning, Client);
break;
case EffectType.AnimalControls:
Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
Helpers.LogLevel.Warning, Client);
break;
case EffectType.AnimationObject:
Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
Helpers.LogLevel.Warning, Client);
break;
case EffectType.Cloth:
Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
Helpers.LogLevel.Warning, Client);
break;
case EffectType.Glow:
Logger.Log("Received a Glow ViewerEffect which is not implemented yet",
Helpers.LogLevel.Warning, Client);
break;
case EffectType.Beam:
case EffectType.Point:
case EffectType.Trail:
case EffectType.Sphere:
case EffectType.Spiral:
case EffectType.Edit:
if (OnEffect != null)
{
if (block.TypeData.Length == 56)
{
LLUUID sourceAvatar = new LLUUID(block.TypeData, 0);
LLUUID targetObject = new LLUUID(block.TypeData, 16);
LLVector3d targetPos = new LLVector3d(block.TypeData, 32);
try { OnEffect(type, sourceAvatar, targetObject, targetPos, block.Duration, block.ID); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
else
{
Logger.Log("Received a " + type.ToString() +
" ViewerEffect with an incorrect TypeData size of " +
block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
}
}
break;
case EffectType.LookAt:
if (OnLookAt != null)
{
if (block.TypeData.Length == 57)
{
LLUUID sourceAvatar = new LLUUID(block.TypeData, 0);
LLUUID targetObject = new LLUUID(block.TypeData, 16);
LLVector3d targetPos = new LLVector3d(block.TypeData, 32);
LookAtType lookAt = (LookAtType)block.TypeData[56];
try { OnLookAt(sourceAvatar, targetObject, targetPos, lookAt, block.Duration,
block.ID); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
else
{
Logger.Log("Received a LookAt ViewerEffect with an incorrect TypeData size of " +
block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
}
}
break;
case EffectType.PointAt:
if (OnPointAt != null)
{
if (block.TypeData.Length == 57)
{
LLUUID sourceAvatar = new LLUUID(block.TypeData, 0);
LLUUID targetObject = new LLUUID(block.TypeData, 16);
LLVector3d targetPos = new LLVector3d(block.TypeData, 32);
PointAtType pointAt = (PointAtType)block.TypeData[56];
try { OnPointAt(sourceAvatar, targetObject, targetPos, pointAt, block.Duration,
block.ID); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
else
{
Logger.Log("Received a PointAt ViewerEffect with an incorrect TypeData size of " +
block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
}
}
break;
default:
Logger.Log("Received a ViewerEffect with an unknown type " + type, Helpers.LogLevel.Warning, Client);
break;
}
}
}
/// <summary>
/// Start a particle stream between an agent and an object
/// </summary>
/// <param name="sourceAvatar"><seealso cref="UUID"/> Key of the source agent</param>
/// <param name="targetObject"><seealso cref="UUID"/> Key of the target object</param>
/// <param name="globalOffset">A <seealso cref="Vector3d"/> representing the beams offset from the source</param>
/// <param name="type">A <seealso cref="T:PointAtType"/> which sets the avatars lookat animation</param>
/// <param name="effectID"><seealso cref="UUID"/> of the Effect</param>
public void LookAtEffect(UUID sourceAvatar, UUID targetObject, Vector3d globalOffset, LookAtType type,
UUID effectID)
{
ViewerEffectPacket effect = new ViewerEffectPacket();
effect.AgentData.AgentID = Client.Self.AgentID;
effect.AgentData.SessionID = Client.Self.SessionID;
float duration;
switch (type)
{
case LookAtType.Clear:
duration = 2.0f;
break;
case LookAtType.Hover:
duration = 1.0f;
break;
case LookAtType.FreeLook:
duration = 2.0f;
break;
case LookAtType.Idle:
duration = 3.0f;
break;
case LookAtType.AutoListen:
case LookAtType.Respond:
duration = 4.0f;
break;
case LookAtType.None:
case LookAtType.Select:
case LookAtType.Focus:
case LookAtType.Mouselook:
duration = Single.MaxValue / 2.0f;
break;
default:
duration = 0.0f;
break;
}
effect.Effect = new ViewerEffectPacket.EffectBlock[1];
effect.Effect[0] = new ViewerEffectPacket.EffectBlock();
effect.Effect[0].AgentID = Client.Self.AgentID;
effect.Effect[0].Color = new byte[4];
effect.Effect[0].Duration = duration;
effect.Effect[0].ID = effectID;
effect.Effect[0].Type = (byte)EffectType.LookAt;
byte[] typeData = new byte[57];
Buffer.BlockCopy(sourceAvatar.GetBytes(), 0, typeData, 0, 16);
Buffer.BlockCopy(targetObject.GetBytes(), 0, typeData, 16, 16);
Buffer.BlockCopy(globalOffset.GetBytes(), 0, typeData, 32, 24);
typeData[56] = (byte)type;
effect.Effect[0].TypeData = typeData;
Client.Network.SendPacket(effect);
}
/// <summary>
/// Process an incoming effect
/// </summary>
private void ViewerEffectHandler(object sender, PacketReceivedEventArgs e)
{
Simulator simulator = e.Simulator;
var packet = e.Packet;
if (!IsMaster(simulator))
{
return;
}
if (simulator != client.Network.CurrentSim)
{
//Debug("ViewerEffectHandler: from a differnt sim than current " + simulator);
}
if (!MaintainEffects)
{
return;
}
ViewerEffectPacket effect = (ViewerEffectPacket)packet;
GridClient Client = client;
foreach (ViewerEffectPacket.EffectBlock block in effect.Effect)
{
EffectType type = (EffectType)block.Type;
// most effect types have at least these properties
UUID sourceAvatar = CogbotHelpers.GetUUID(block.TypeData, 0);
UUID targetObject = CogbotHelpers.GetUUID(block.TypeData, 16);
Vector3d targetPos = new Vector3d(block.TypeData, 32);
//Color4 color;
//if (block.Color.Length == 4)
//{
// color = new Color4(block.Color, 0);
//}
//else
//{
// Client.Log("Received a ViewerEffect.EffectBlock.Color array with " + block.Color.Length +
// " bytes", Helpers.LogLevel.Warning);
// color = Color4.Black;
//}
if (sourceAvatar == UUID.Zero)
{
var ag1 = Client.Self.AgentID;
var ag2 = block.AgentID;
var ag3 = effect.AgentData.AgentID;
Debug("Received a " + type.ToString() + " ViewerEffect sourceAvatar==NULL " + targetObject + " " + GetObject(ag1) + " " + GetObject(ag2) + " " + GetObject(ag3), Helpers.LogLevel.Warning, Client);
}
// Each ViewerEffect type uses it's own custom binary format for additional BVHData. Fun eh?
switch (type)
{
case EffectType.Beam:
case EffectType.Point:
case EffectType.Trail:
case EffectType.Sphere:
case EffectType.Spiral:
case EffectType.Edit:
// if (Avatars_OnEffect != null)
{
if (block.TypeData.Length == 56)
{
PCode sourceType = PCode.Avatar;
if (type == EffectType.Edit || type == EffectType.Point || type == EffectType.Beam)
{
sourceType = PCode.Avatar;
}
try
{
SendEffect(simulator, sourceAvatar, targetObject, targetPos,
"EffectType-" + type.ToString(), block.Duration, block.ID, sourceType);
}
catch (Exception ex)
{
Logger.Log(ex.Message, Helpers.LogLevel.Error, Client, ex);
}
}
else
{
Debug("ERROR: Received a " + type.ToString() +
" ViewerEffect with an incorrect TypeData size of " +
block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
}
return;
}
break;
case EffectType.LookAt:
//if (OnLookAt != null)
{
if (block.TypeData.Length == 57)
{
LookAtType lookAt = (LookAtType)block.TypeData[56];
try
{
SendEffect(simulator, sourceAvatar, targetObject, targetPos,
"LookAtType-" + lookAt.ToString(), block.Duration, block.ID, PCode.Avatar);
}
catch (Exception ex)
{
Debug(ex.Message, Helpers.LogLevel.Error, Client, ex);
}
return;
}
else
{
Debug("Received a LookAt ViewerEffect with an incorrect TypeData size of " +
block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
}
}
break;
case EffectType.PointAt:
// if (Avatars_OnPointAt != null)
{
if (block.TypeData.Length == 57)
{
PointAtType pointAt = (PointAtType)block.TypeData[56];
try
{
SendEffect(simulator, sourceAvatar, targetObject, targetPos,
"PointAtType-" + pointAt.ToString(), block.Duration, block.ID,
PCode.Avatar);
}
catch (Exception ex)
{
Debug(ex.Message, Helpers.LogLevel.Error, Client, ex);
}
return;
}
else
{
Debug("Received a PointAt ViewerEffect with an incorrect TypeData size of " +
block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
}
}
break;
case EffectType.Text:
case EffectType.Icon:
case EffectType.Connector:
case EffectType.FlexibleObject:
case EffectType.AnimalControls:
case EffectType.AnimationObject:
case EffectType.Cloth:
case EffectType.Glow:
default:
SendNewRegionEvent(SimEventType.EFFECT, "OnViewerEffect", type, sourceAvatar, targetObject,
targetPos);
break;
}
SendEffect(simulator, sourceAvatar, targetObject, targetPos, "EffectType." + type, 0.1f, block.ID,
PCode.None);
}
}
