Reactor Controller

Make an object respond to the proximity of another object. The essence of parametric modeling is the definition of object properties in terms of the properties of upstream objects. A problem arises, if the relation between the object and its upstream precedents is based on proximity. The new location for the object becomes based on the old location for the object, making the object definition become circular! And circularity is not allowed in a propagation graph. Use this pattern when you want to make an object respond to the presence of another object. Designers often use the metaphor of response in which one part of a design depends upon the state of another. Reversing the perspective, is as if part of a design becomes a tool for shaping the other. This situation is very much like that encountered in the Controller pattern, but with a key difference---the controlling property is proximity. The essential idea is simple: connect an interactor to a result through a reference. The trick is to join the interactor and the result with an intermediary and usually fixed object, which we call a reference. The interactor and the reference interact to produce the result. For example (see sample "Circle Radii below"), you might have a point and a circle, and you want the circle to get bigger (or smaller or elliptical) as you move the point closer. This can be done by using the Reactor pattern. As you might have guessed, the point is an interactor and the circle is a result (which can be replicated to give us an array of circles). The circles have to be somewhere. This somewhere is the reference. The reference is usually hidden in a Reactor. Position is a complex property that can manifest in many ways through a Reactor. Position is any combination of location and direction, for instance, the length or direction of lines, parameter or number or position of points, direction of planes, radius of circles and even additional properties such as color if they are made to depend on position. Circle Radii and Point Interactor Control the size of a set of circles by proximity to a point. Perhaps the simplest definition of a circle\index{circle} requires just its

centre

and

radius

. The

centre

(a point) is the reference and the

radius

is the result. The free point is the interactor. Making the

radius

a function\index{function} of the distance between the

centre

and the controlling point\index{point} completes this instance of the Reactor pattern. In this case, the function is a direct relationship--its value shrinks as distance shrinks. As the interactor moves closer to the circle, the circle gets smaller. Replicating the reference causes all of the circles to react to the movement of the interactor. Hiding the reference, creates an illusion of direct control from interactor to result. Click to download ReacCirclesRadius.gct Circle Radii and Curve Interactor Control the size of a set of circles by proximity to a curve. In modeling terms, this sample hardly differs from the previous one. In both, the radii of circles\index{circle} arranged in an array change with proximity to an interactor. The only differences are that the interactor here is a curve\index{curve} and the radii grow with proximity rather than shrink. The distance from a reference point\index{point} to the curve is the distance between the point and its projection onto the curve -- this is the shortest distance between the point and curve. Hiding the reference removes the explicit visual fixed point of each circle. The eye focus on the displayed part, which is changing, rather than the fixed, hidden part. \begin{bodyNote} \pbOneCol[r] {\pbIncludeGraphics[\extImagesPath/NASA/nilebend_etm_2000293_lrg.jpg]{width=\currentWidth}\\ \source{NASA Earth Observatory image created by Jesse Allen, using Landsat data provided by the University of Maryland's Global Land Cover Facility.}} \end{bodyNote} Click to download ReacCirclesRadiusToCurve.gct Lift Make a line's length increase as you move a point\index{point} closer to its start point. Define two points; call one the reference and one the interactor. On the reference define a vertical line\index{line}: the result. The length of the result is given by any two argument function that increases as its distance between the reference and its interactor shrinks, for example

1/(Distance(interactor,
	  reference)+0.1)

. The small amount of

0.1

that is added to the Distance function result prevents the line from becoming infinitely long as the distance between the points approaches zero. The Mapping pattern gives several better, but more complex functions that can be used here. Replicate the start point and hide it. Now you have a set of lines that react to the movement of the interactor. In turn, use the line endpoints to define the shape of another object using the lines, such as a roof surface. Click to download ReacLift.gct \renewcommand{\sampleNewPage}[0]{false} Repeller Make a point move away from a controlling point. Define two points\index{point}; call one the reference and one the interactor. The result will lie on the infinite line defined by the reference and the interactor. The result is the sum of the reference and a vector\index{vector}. The vector's direction is the same as the vector between the interactor and the reference. Its length is an inverse function of the distance between the interactor and the reference: as the interactor moves towards the reference, the length increases. The particular function\index{function} used in this sample is \[SD/(\afFunc{distance}{\afTMath{interactor},\afTMath{reference}}+\afTMath{SD}*0.01)\] (SD/(Distance(interactor,reference)+SD/100) where

SD

stands for Standard Distance and measures the size of the modeled object. As

SD

grows, so does the effective distance over which the pattern operates. The small amount

SD*0.01

added to the distance prevents the result from moving infinitely as the interactor approaches the reference. Replicate and hide the reference. The result points now appear to respond to the interactor. In turn, use the result to define other objects, such as a surface. Click to download ReacRepeller.gct Vector Field Rotate a bound vector\index{vector!bound} as a controlling point\index{point} moves, so that it always has the same angle to the point. Replicate to define a vector field\index{vector!field}. Define two points\index{point}: an interactor and a reference. The goal is to define a bound vector from the reference such that it is always right-handedly perpendicular to the imaginary line that connects the two points. Create a coordinate system\index{frame} on the reference point by using the interactor point to locate its

X

axis. Making the result vector on the

y

axis of this coordinate system, ensures that it will always be perpendicular to the

x

axis and consequently to the connecting line. Note that the reference can be more than one object. In this case both the start point of the vector and the coordinate system comprise the reference. The coordinate system could replace the reference point, simplifying back to a single reference, but such reduction is not always possible. Replicate\index{replication} the reference point in 1, 2 or 3 dimensions and hide it. All of the result vectors will react to the position of the interactor and portray a continuous vector field.

Click to download ReacVectorField.gct Dimple Make the local shape of a closed curve react to a nearby point. Define a circle\index{circle} and two points\index{point} on the circle. Call one of these points the reference and the other the interactor. Draw a radius of the circle from the reference point to the circle's centre. Place the result, a parametric point on this line, that moves toward the center if the interactor gets too close to it. The trick is to use a condition that sets the parameter of the result point to some value (here

0.4

) if the distance between the interactor and the reference (which is measured by the modular distance between their parameters) becomes less than a value

d

(explained later), otherwise sets it to another value (here

0.2

). This distance condition can be defined as follows:

function modular01Distance (double t0, double t1)
 {
  object result = t0-t1;
  return 
   result > 0.5 ? 
    1 - result : 
    result >= 0 ? 
     result : 
     result > -0.5 ? 
      Abs(result) : 
      result + 1.0; 
 }

The parameter

d

here can be a number less than or equal to

0.5

and greater than or equal to half of the distance between each two references. The latter condition is needed so that the test is always true for at least one point. With

count

reference objects equally distributed by parametric distance, a minimal value for

d

d = 1 / (2 * \afVar{count})

. After replicating the reference, create a closed curve\index{curve} interpolating the result points. This curve will look like a circle deformed by the interactor. \begin{bodyNote} \pbOneCol {\input{\GCFigsPath/Patterns/ReactorDimpleExplain0.tex}} \end{bodyNote} Click to download ReacCircle.gct