The `pointcloud`

location is the simplest geometry ty=
pe in Katana, and in addition to the standard `geometry.arbitrary.* and `

`geometry.point.P`

handling KtoA extends it with quite =
a few attributes to make it useful in a variety of situations.

```
```#### Added Attributes

`arnoldStatements.*`

point attributes: there are various poi=
nt rendering controls that can be set via the `ArnoldObjectSettings node. Of particular note are ``point_mode`

(which dete=
rmines the use of some of the other attributes) and `min_pixel_width.`

```
````geometry.point.aspect`

: one float per point, this controls =
the aspect ratio of each point to make them appear non-square. This o=
nly applies to certain `point_mode`

choices.
`geometry.point.rotation`

: one float per point, this control=
s the rotation away from the camera for each point. This only applies=
to certain `point_mode`

choices.
`geometry.point.width`

: the width (diameter) of each point, =
one float per point. This is in object-space coordinates.
`geometry.constantwidth`

: if per-point width is not required=
, this can be set with a single float to have all points use the same width=
. This is preferred over using `geometry.point.constantwidth.`

```
````geometry.point.constantwidth`

: if per-point width is not re=
quired, this can be set with a single float to have all points use the same=
width.
- (deprecated)
```
ge=
ometry.constantWidth
```

: note the capitalized 'W'. If per-point width i=
s not required, this can be set with a single float to have all points use =
the same width.
- (deprecated)
```
geometr=
y.point.constantwidth
```

: note the capitalized 'W'. If per-point =
width is not required, this can be set with a single float to have all poin=
ts use the same width.

```
```#### Point-based ins=
tancing

If the attribute `geometry.point.instanceSource`

or ```
geo=
metry.instanceSource
```

is present, the pointcloud switches to generati=
ng point-based instances. The additional attributes that are honored =
in this mode:

`geometry.point.instanceSource`

: a string per point indicati=
ng the `instance source`

location to be instanced at each point.=
`geometry.instanceSource`

: a string indicating the ```
ins=
tance source
```

location to be instanced for all points.
`geometry.point.matrix`

: one per point, a 16-float matrix pe=
r-point indicating a transformation to be applied to each instance.
`geometry.point.rotate`

: one per point, three floats indicat=
ing the Euler rotation about Z-axis, then Y-axis, then X-axis for each inst=
ance.
`geometry.point.quaternion`

: one per point, four floats indi=
cating quaternion rotation for each instance in order of (real, i, j, k) co=
mponents.
`geometry.point.scale`

: one per point, three floats indicati=
ng X, Y, and Z scale per instance.
`geometry.point.instanceSkipIndex`

or ```
geometry.instanc=
eSkipIndex
```

: an array with int indices referring to points to skip.&n=
bsp; This is similar to `instance array`

locations.

```
Note that the per-instance transformations are applied in the following =
order: scale, quaternion rotation, rotation (in XYZ order), translation (
```geometry.point.P

), and finally the matrix. All of th=
ese (except for `geometry.point.P`

) can be omitted.

#### Instance Arrays

Point-based instancing can also be accomplished using ```
instance arr=
ay
```

locations, which has a different attribute layout than ```
poin=
tcloud
```

instancing. The following attributes are honored:

`geometry.instanceSource`

: a string array with ```
instanc=
e source
```

locations, which is indexed by each entry in ```
geometry=
.instanceIndex
```

if there is more than one instance source.
`geometry.instanceIndex`

: optional, if there is more than on=
e location string in `geometry.instanceSource`

, then this needs =
to have one integer index (into `geometry.instanceSource`

) per i=
nstance.
`geometry.instanceSkipIndex`

: optional, an integer list of i=
ndices to skip and not generate instances.
`geometry.instanceMatrix`

: a transformation matrix (4x4, or =
16 double values) with one matrix per instance. Note, at least one tr=
ansform attribute needs to be present.
`geometry.instanceTranslate`

: translation (3 doubles) per in=
stance. Note, at least one transform attribute needs to be present.
`geometry.instanceRotateX`

: a rotation amount and axis, 4 do=
ubles (angle, axis-x, axis-y, axis-z), presumably with the axis as (1, 0, 0=
). Note, at least one transform attribute needs to be present.
`geometry.instanceRotateY`

: a rotation amount and axis, 4 do=
ubles (angle, axis-x, axis-y, axis-z), presumably with the axis as (0, 1, 0=
). Note, at least one transform attribute needs to be present.
`geometry.instanceRotateZ`

: a rotation amount and axis, 4 do=
ubles (angle, axis-x, axis-y, axis-z), presumably with the axis as (0, 0, 1=
). Note, at least one transform attribute needs to be present.
`geometry.instanceScale`

: a scale amount (3 doubles) per ins=
tance. Note, at least one transform attribute needs to be present.

Note that the per-instance transformations are applied in the following =
order: scaling, X rotation, Y rotation, Z rotation, translation, and finall=
y the matrix. At least one per-instance transformation attribute need=
s to be included.

#### Common Ins=
tancing Attributes

`Finally, arbitrary user data (``geometry.arbitrary.*`

) attribu=
te groups are also applied. If the scope is `point`

(Arnol=
d `varying`

) then it will apply each varying value as ```
prim=
itive
```

scope (Arnold `constant`

) user data on each instanc=
e. In this way, arbitrary data can be doled out to each individual in=
stance to customize them. Abitrary data can be explicitly restricted =
to one (or more) of the instance source children by specifying the ```
ge=
ometry.arbitrary.paramname.match
```

string array, where each string is =
a subpath to the particular instance source child you want the arbitrary da=
ta to apply to. E.g. if the instance source has children ```
prim, =
primgroup/prim1 and primgroup/prim2
```

, and the `pointcloud`

=
location has `geometry.arbitrary.myAttr.match`

with a string primgroup/prim1

in it, that arbitrary data will only be applied =
to the instance created from `primgroup/prim1`

.