/// <summary>
/// Recursively populates a transform data array from this shadow, with
/// a potential whitelist or blacklist
/// </summary>
/// <param name="data">The array to populate</param>
/// <param name="t">The current subtree root</param>
/// <param name="coordinator">The coordinator</param>
/// <param name="nameFilter">The filter for names</param>
/// <param name="bypass">Used for whitelists to take children of
/// whitelisted transforms</param>
public static void WriteShadowData(
ShadowTransform[] data,
Transform t,
ShadowCoordinator coordinator,
FilterList <string> nameFilter,
bool bypass = false)
{
bool allowed = (bypass == true || nameFilter.Allowed(t.name) == true);
bool whitelist = (nameFilter.IsWhitelist() == true);
bypass = (allowed == true && whitelist == true);
// If we're permitting this bone through the filter
if (allowed == true)
{
data[coordinator.GetBoneKey(t.name)].ReadFrom(t);
}
// See if we need to keep searching
if (whitelist == true || allowed == true)
{
foreach (Transform child in t)
{
WriteShadowData(data, child, coordinator, nameFilter, bypass);
}
}
}
/// <summary>
/// Recursively applies an encoded skeleton, or part of it, to the shadow
/// </summary>
/// <param name="data">The encoded skeleton data</param>
/// <param name="t">The current transform to apply to</param>
/// <param name="nameFilter">The filter for names</param>
/// <param name="bypass">Used for whitelists to take children of
/// whitelisted transforms</param>
public static void ReadShadowData(
ShadowTransform[] data,
Transform t,
ShadowCoordinator coordinator,
FilterList <string> nameFilter,
bool bypass = false)
{
bool allowed = (bypass == true || nameFilter.Allowed(t.name) == true);
bool whitelist = (nameFilter.IsWhitelist() == true);
bypass = (allowed == true && whitelist == true);
// If this is a valid bone, and is allowed, read it to the skeleton
int key = coordinator.GetBoneKey(t.name);
if (allowed == true && ShadowTransform.IsValid(data[key]) == true)
{
data[key].WriteTo(t);
}
// See if we need to keep searching
if (whitelist == true || allowed == true)
{
foreach (Transform child in t)
{
ReadShadowData(data, child, coordinator, nameFilter, bypass);
}
}
}
void Awake()
{
if (this.enabled == true)
{
this._coordinator =
this.gameObject.GetComponent <ShadowCoordinator>();
this._coordinator.RegisterController(this);
}
}
/// <summary>
/// Creates an encoded skeleton array from this shadow hierarchy
/// </summary>
/// <returns>A potentially sparse array describing this shadow</returns>
public ShadowTransform[] Encode(ShadowTransform[] buffer)
{
ShadowCoordinator coordinator = this.controller.Coordinator;
Shadow.WriteShadowData(
buffer,
this._rootHips,
coordinator);
return(buffer);
}
/// <summary>
/// Creates an encoded skeleton array from this shadow hierarchy
/// </summary>
/// <returns>A potentially sparse array describing this shadow</returns>
public ShadowTransform[] Encode(ShadowTransform[] buffer)
{
ShadowCoordinator coordinator = this.controller.Coordinator;
Shadow.WriteShadowData(
buffer,
this._rootObject.transform.GetChild(0),
coordinator);
return(buffer);
}
/// <summary>
/// Recursively populates a transform data array from this shadow
/// </summary>
/// <param name="data">The array to populate</param>
/// <param name="t">The current subtree root</param>
/// <param name="coordinator">The coordinator</param>
public static void WriteShadowData(
ShadowTransform[] buffer,
Transform t,
ShadowCoordinator coordinator)
{
int key = coordinator.GetBoneKey(t.name);
buffer[key].ReadFrom(t);
foreach (Transform child in t)
{
WriteShadowData(buffer, child, coordinator);
}
}
/// <summary>
/// Recursively applies an encoded skeleton, or part of it, to the shadow
/// </summary>
/// <param name="data">The encoded skeleton data</param>
/// <param name="t">The current transform to apply to</param>
public static void ReadShadowData(
ShadowTransform[] data,
Transform t,
ShadowCoordinator coordinator)
{
int key = coordinator.GetBoneKey(t.name);
if (ShadowTransform.IsValid(data[key]) == true)
{
data[key].WriteTo(t);
}
foreach (Transform child in t)
{
ReadShadowData(data, child, coordinator);
}
}
void Awake()
{
if (this.enabled == true)
{
this._coordinator =
this.gameObject.GetComponent<ShadowCoordinator>();
this._coordinator.RegisterController(this);
}
}
// Use this for initialization
void Start()
{
this.coordinator = rootObject.GetComponent<ShadowCoordinator>();
this.controller = coordinator.GetController(shadowName);
}
/// <summary>
/// Recursively populates a transform data array from this shadow, with
/// a potential whitelist or blacklist
/// </summary>
/// <param name="data">The array to populate</param>
/// <param name="t">The current subtree root</param>
/// <param name="coordinator">The coordinator</param>
/// <param name="nameFilter">The filter for names</param>
/// <param name="bypass">Used for whitelists to take children of
/// whitelisted transforms</param>
public static void WriteShadowData(
ShadowTransform[] data,
Transform t,
ShadowCoordinator coordinator,
FilterList<string> nameFilter,
bool bypass = false)
{
bool allowed = (bypass == true || nameFilter.Allowed(t.name) == true);
bool whitelist = (nameFilter.IsWhitelist() == true);
bypass = (allowed == true && whitelist == true);
// If we're permitting this bone through the filter
if (allowed == true)
data[coordinator.GetBoneKey(t.name)].ReadFrom(t);
// See if we need to keep searching
if (whitelist == true || allowed == true)
foreach (Transform child in t)
WriteShadowData(data, child, coordinator, nameFilter, bypass);
}
/// <summary>
/// Recursively populates a transform data array from this shadow
/// </summary>
/// <param name="data">The array to populate</param>
/// <param name="t">The current subtree root</param>
/// <param name="coordinator">The coordinator</param>
public static void WriteShadowData(
ShadowTransform[] buffer,
Transform t,
ShadowCoordinator coordinator)
{
int key = coordinator.GetBoneKey(t.name);
buffer[key].ReadFrom(t);
foreach (Transform child in t)
WriteShadowData(buffer, child, coordinator);
}
/// <summary>
/// Recursively applies an encoded skeleton, or part of it, to the shadow
/// </summary>
/// <param name="data">The encoded skeleton data</param>
/// <param name="t">The current transform to apply to</param>
/// <param name="nameFilter">The filter for names</param>
/// <param name="bypass">Used for whitelists to take children of
/// whitelisted transforms</param>
public static void ReadShadowData(
ShadowTransform[] data,
Transform t,
ShadowCoordinator coordinator,
FilterList<string> nameFilter,
bool bypass = false)
{
bool allowed = (bypass == true || nameFilter.Allowed(t.name) == true);
bool whitelist = (nameFilter.IsWhitelist() == true);
bypass = (allowed == true && whitelist == true);
// If this is a valid bone, and is allowed, read it to the skeleton
int key = coordinator.GetBoneKey(t.name);
if (allowed == true && ShadowTransform.IsValid(data[key]) == true)
data[key].WriteTo(t);
// See if we need to keep searching
if (whitelist == true || allowed == true)
foreach (Transform child in t)
ReadShadowData(data, child, coordinator, nameFilter, bypass);
}
/// <summary>
/// Recursively applies an encoded skeleton, or part of it, to the shadow
/// </summary>
/// <param name="data">The encoded skeleton data</param>
/// <param name="t">The current transform to apply to</param>
public static void ReadShadowData(
ShadowTransform[] data,
Transform t,
ShadowCoordinator coordinator)
{
int key = coordinator.GetBoneKey(t.name);
if (ShadowTransform.IsValid(data[key]) == true)
data[key].WriteTo(t);
foreach (Transform child in t)
ReadShadowData(data, child, coordinator);
}
// Use this for initialization
void Start()
{
this.coordinator = rootObject.GetComponent <ShadowCoordinator>();
this.controller = coordinator.GetController(shadowName);
}
