public override bool RunComponent(RendererComponent.IOutputContext context)
{
// Calculate the perturbation ranges for position, location and field of view.
float fov_min = -fov_radius_ / 2.0f;
float fov_max = fov_radius_ / 2.0f;
float pos_min = -position_radius_ / 2.0f;
float pos_max = position_radius_ / 2.0f;
float rot_min = -quat_radius_ / 2.0f;
float rot_max = quat_radius_ / 2.0f;
if (mode_ == Mode.Jitter || mode_ == Mode.Both)
{
// In 'Jitter' mode, apply random local perturbations on top of the
// original cached state.
foreach (CameraState camera_state in initial_camera_states_)
{
camera_state.camera.fieldOfView = camera_state.fov + Random.Range(fov_min, fov_max);
camera_state.camera.transform.localPosition = camera_state.pos + new Vector3(Random.Range(pos_min, pos_max), Random.Range(pos_min, pos_max), Random.Range(pos_min, pos_max));
Vector3 axis = Random.rotationUniform * Vector3.up;
camera_state.camera.transform.localRotation = camera_state.rot * Quaternion.AngleAxis(Random.Range(rot_min, rot_max) * Mathf.Rad2Deg, axis);
}
}
if (mode_ == Mode.Orbit || mode_ == Mode.Both)
{
// In 'Orbit' mode rotate the camera around a line, going straight
// up from the 'orbit_center' point.
foreach (CameraState camera_state in initial_camera_states_)
{
camera_state.camera.transform.RotateAround(orbit_center_, Vector3.up, Random.Range(0.0f, 360.0f));
}
}
return(true);
}
public override bool RunComponent(RendererComponent.IOutputContext context)
{
JointController[] joint_controllers = GetComponentsInChildren <JointController>();
foreach (JointController joint_controller in joint_controllers)
{
switch (joint_controller.joint_type_)
{
case JointController.JointType.Ball:
// Assign a random quaternion sampled uniformly from a
// sphere to a ball joint.
joint_controller.UpdateJoint(Random.rotationUniform);
break;
case JointController.JointType.Hinge:
// Assign a random value from the joint limit range to
// a hinge joint.
float range_min = joint_controller.range_[0];
float range_max = joint_controller.range_[1];
if (range_min > float.MinValue && range_max < float.MaxValue)
{
joint_controller.UpdateJoint(Random.Range(joint_controller.range_[0], joint_controller.range_[1]));
}
break;
case JointController.JointType.Slide:
// Slide joints don't have ranges, ignore for now.
break;
}
;
}
return(true);
}
public override bool RunComponent(RendererComponent.IOutputContext context)
{
if (camera_ == null)
{
return(false);
}
camera_.nearClipPlane = near_clip_;
camera_.farClipPlane = far_clip_;
camera_.fieldOfView = field_of_view_;
return(true);
}
public override bool RunComponent(RendererComponent.IOutputContext context)
{
// Apply the local transformation to the cached original values.
transform.localPosition = original_translate_ + translate_;
transform.localRotation = original_rotate_ * rotate_;
Vector3 new_scale = original_scale_;
new_scale.Scale(scale_);
transform.localScale = new_scale;
return(true);
}
public override bool RunComponent(RendererComponent.IOutputContext context)
{
foreach (LightHead light_head in light_heads_)
{
// Randomize orbit angle [0.0, 360.0) degrees, and use
// randomization ranges to determine mounting distance
// and mounting height.
light_head.SetUp(target_, Random.Range(0.0f, 360.0f), Random.Range(min_light_height_, max_light_height_),
Random.Range(min_light_distance_, max_light_distance_));
}
return(true);
}
public override bool RunComponent(RendererComponent.IOutputContext context)
{
foreach (HSVMaterial hsvm in initial_colors_)
{
// Calculate the clamped randomization ranges.
float hue = Mathf.Repeat(Random.Range(hsvm.h - hue_radius_, hsvm.h + hue_radius_), 1.0f);
float min_s = Mathf.Max(min_saturation_, hsvm.s - saturation_radius_);
float max_s = Mathf.Min(max_saturation_, hsvm.s + saturation_radius_);
float min_v = Mathf.Max(min_value_, hsvm.v - value_radius_);
float max_v = Mathf.Min(max_value_, hsvm.v + value_radius_);
float min_e = Mathf.Max(min_emission_, hsvm.e - emission_radius_);
float max_e = Mathf.Min(max_emission_, hsvm.e + emission_radius_);
// We will keep the alpha exactly as original, do not randomize
// transparency.
float alpha = hsvm.m.color.a;
// Randomize basic properties.
if (hsvm.m.HasProperty("_Color"))
{
hsvm.m.color = Random.ColorHSV(hue, hue, min_s, max_s, min_v, max_v, alpha, alpha);
}
if (hsvm.m.HasProperty("_Metallic"))
{
hsvm.m.SetFloat("_Metallic", Random.Range(min_metallic_, max_metallic_));
}
if (hsvm.m.HasProperty("_Glossiness"))
{
hsvm.m.SetFloat("_Glossiness", Random.Range(min_glossiness_, max_glossiness_));
}
// If the material was originally emissive, randomize emission
// with some probability (blinkenlights).
if (hsvm.m.IsKeywordEnabled("_EMISSION") && hsvm.m.HasProperty("_EmissionColor"))
{
if (emission_probability_ > Random.Range(0.0f, 1.0f))
{
hsvm.m.SetColor(
"_EmissionColor",
Random.ColorHSV(hue, hue, min_s, max_s, min_v, max_v, alpha, alpha) * Random.Range(min_e, max_e));
}
else
{
hsvm.m.SetColor("_EmissionColor", Color.black);
}
}
}
return(true);
}
public bool RunComponents(RendererComponent.IOutputContext context)
{
foreach (ComponentInstance component_instance in components_)
{
if (component_instance.enabled)
{
if (!component_instance.renderer_component.RunComponent(context))
{
Logger.Warning("ComponentManager::RunComponents::Failed running: {0}.", component_instance.name);
}
}
}
return(true);
}
public override bool RunComponent(RendererComponent.IOutputContext context)
{
MeshRenderer[] renderers = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer mesh_renderer in renderers)
{
foreach (Material material in mesh_renderer.materials)
{
RandomizeMaterial(material);
}
}
return(true);
}
public override bool RunComponent(RendererComponent.IOutputContext context)
{
// Find all child light emitters.
Light[] lights = GetComponentsInChildren <Light>();
// Draw a total scene light intensity number.
float scene_intensity = Random.Range(min_scene_intensity_, max_scene_intensity_);
float sum_intensity_denorm = 0.0f;
// Go through all lights, and accumulate random weights.
foreach (Light current_light in lights)
{
if (randomize_hue_)
{
current_light.color = Random.ColorHSV(0.0f, 1.0f, 0.0f, 0.3f, 0.9f, 1.0f);
}
else
{
current_light.color = Color.white;
}
// Randomize spot angle.
current_light.spotAngle = Random.Range(min_spotlight_angle_, max_spotlight_angle_);
// Draw a random light intensity weight, from the configured
// range.
current_light.intensity = Random.Range(min_light_intensity_, max_light_intensity_);
sum_intensity_denorm += current_light.intensity;
}
// Distribute total scene intensity between lights, use:
// weight / sum(weights) as factor.
foreach (Light current_light in lights)
{
current_light.intensity = current_light.intensity * scene_intensity / sum_intensity_denorm;
}
return(true);
}
// This component does nothing each frame. The actual hiding happens on initialization / update.
public override bool RunComponent(RendererComponent.IOutputContext context)
{
return(true);
}
public override bool RunComponent(RendererComponent.IOutputContext context)
{
transform.LookAt(target_offset_, Vector3.up);
return(true);
}
