Return to PointMesh.m CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Graph

Annotation of Examples/AppKit/Graph/PointMesh.m, revision 1.1.1.1

1.1       root        1: 
                      2: /*
                      3:     PointMesh.m
                      4: 
                      5:     A PointMesh takes an array of points in three dimensional space and renders
                      6:     them as surface in space space using a Renderman bilinear patch mesh.
                      7: 
                      8:     You may freely copy, distribute, and reuse the code in this example.
                      9:     NeXT disclaims any warranty of any kind, expressed or implied, as to its
                     10:     fitness for any particular use.
                     11: */
                     12: 
                     13: #import "Graph.h"
                     14: 
                     15: @implementation PointMesh
                     16: 
                     17: - init {
                     18:     self = [super init];
                     19:     color = NX_COLORWHITE;
                     20:     return self;
                     21: }
                     22: 
                     23: - free {
                     24:     free(points);
                     25:     return [super free];
                     26: }
                     27: 
                     28: /*
                     29:  * This copies ther given points into a 2D array that is formatted correctly
                     30:  * for the RiPatchMesh() call we use to render the patch (below).
                     31:  */
                     32: - setPointsX:(float *)x y:(float *)y z:(float *)z
                     33:        minX:(float)minX minY:(float)minY minZ:(float)minZ
                     34:        maxX:(float)maxX maxY:(float)maxY maxZ:(float)maxZ
                     35:        numU:(int)numU numV:(int)numV {
                     36:     int i;
                     37:     int totalPoints = numU * numV;
                     38: 
                     39:     uCount = numU;
                     40:     vCount = numV;
                     41:     free(points);
                     42:     points = NXZoneMalloc([self zone], totalPoints * sizeof(RtPoint));
                     43: 
                     44:     for (i = 0; i < totalPoints; i++) {
                     45:        points[i][0] = x[i];
                     46:        points[i][1] = y[i];
                     47:        points[i][2] = z[i];
                     48:     }
                     49:     return self;
                     50: }
                     51: 
                     52: /*
                     53:  * This method is called whenever the shape needs to render itself (its
                     54:  * analogous to View's drawSelf:: method).  The patch renders itself by
                     55:  * setting the surface type and the color, and then emitting one big bilinear
                     56:  * patch mesh containing all our data points.
                     57:  */
                     58: - renderSelf:(RtToken)context {
                     59:     static RtColor rgbColor;
                     60:     
                     61:     RiSurface("plastic", RI_NULL);
                     62:     NXConvertColorToRGB(color, &rgbColor[0], &rgbColor[1], &rgbColor[2]);
                     63:     RiColor(rgbColor);
                     64:     RiPatchMesh(RI_BILINEAR, uCount, RI_NONPERIODIC, vCount, RI_NONPERIODIC, RI_P, points, RI_NULL);
                     65:     return self;
                     66: }
                     67: 
                     68: - setColor:(NXColor)newColor {
                     69:     color = newColor;
                     70:     return self;
                     71: }
                     72: 
                     73: - (NXColor)color {
                     74:     return color;
                     75: }
                     76: 
                     77: @end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.