Canvas 3d JS Library

My initial interface for the PointList and LineList classes needed to be changed as there were some problems.

Points and Depth

There was a lack of a sense of depth when rendering a PointList as all points were rendered with the same size. To fix this, I replaced setSize(float) with setAttenuation([float, float, float]) which accepts constant, linear and quadratic attenuation factors. This gives the user the flexibility to define how they want the size of the points to be calculated. Every time the vertex shader processes a point, it will determine the appropriate size for each point from the attenuation factors provided. This function can do the same thing as setSize(float), except it provides greater control. But, will it be enough to create the illusion of depth or do other techniques need to be used such as depth cueing?

PointList Visibility and Attenuation

PointLists can have their visibility toggled, but this functionality must be available for individual points as well. To address this, I added another component with each vertex which serves as a visibility flag which can be set with setPointVisible(index, boolean). When the vertex is passed into the shader and the flag is zero, gl_PointSize is set to zero, otherwise it is calculated using the attenuation factors provided by the user. This works well, however the specification says assigning zero to gl_PointSize results in undefined behaviour or errors in rendering. So it works, but I shouldn’t be doing it. ‘Undefined behaviour’ is enough incentive for me to come up with another solution.

LineList Visibility and Attenuation

Since PointLists can change visibility at the point level, I decided to add the same functionality to the LineList. Albeit, the LineList does not have a setAttenuation() function. The reason for this is lineWidth() seems to ignore any values larger than five, so I don’t see a reason to waste calculations trying to determine if a line should be four or five pixels in width. It would be imperceptible.

Since vertices are processed individually by the vertex shader, I had to add two visibility flags for every line. One for each end of the line segment. When the LineList shader sees that one end of the line segment should not be visible, it draws that vertex at [0,0,0]. Then the next vertex is processed. Again, the shader sees this vertex should not be visible and does the same thing. This results in a degenerate line which the GPU is quite good at detecting. Thus nothing is rendered for that line. There is some redundancy in this solution, but adding one component instead of two for a line means I would have to play with array offsets somewhere increasing the complexity of the solution. It seemed easier to just make each vertex 4 components instead.

Point Rendering Bug

A bug relevant to points has been filed: OS X crashes when rendering points and playing a DVD using “DVD Player”. Cathy says when attempting to play a DVD and rendering points, the system runs into conflicts trying to share CPU cycles. On my system, OS X just crashes. At first, it appeared the C3DL library was to blame, but I managed to reproduce the problem without any C3DL code.

Next Steps

I’m now in the process of implementing point picking after which I can re-focus my attention to implement support for multi-textured models. I have been reading the COLLADA book and spec and it seems there are more changes which need to be done than I anticipated.