TweetFollow Us on Twitter

Nov 99 Challenge

Volume Number: 15 (1999)
Issue Number: 11
Column Tag: Programmer's Challenge

Programmer's Challenge

by Bob Boonstra, Westford, MA

Putting Green

I'll confess. While I'm as much of a sports fan as the next guy, I've never been able to get excited about golf. Not playing it, except maybe a round of miniature golf while on vacation each summer. Not watching it, which is the closest thing to watching grass grow that I can imagine. In fact, I have a hard time even thinking of golf as a sport. Real sports involve perspiration. Real sports involve being exhausted. Golf doesn't have either, as near as I have been able to tell, and therefore couldn't be worth getting involved in. Or so I thought.

Feeling this way, I didn't pay very much attention to the news that the 1999 Ryder Cup was going to be held relatively close by. And, when a ticket to the first day of matches came my way, I thought about passing it on to someone else. For a few days, that is. Until I started reading some of the growing volume of newspaper coverage and got an appreciation for what a really big deal people were making of this. It seemed even bigger than the baseball All Star game, also held in Boston this year. Baseball, also not the most intense sport, involves some amount of running and perspiration. So if the Ryder Cup was as big as the All Star game, it must be worth watching. So I decided to attend.

What, you must be asking, does any of this have to do with the Programmer's Challenge? Did someone substitute an issue of Sports Illustrated under the cover? No, it's just that the Ryder Cup provided the inspiration for this month's Challenge. Watching Tiger Woods make a birdie putt on the 10th, watching three teams miss essentially the same putt on the 14th, my mind turned to - why, physics, of course. How did they read (or misread) those breaks? Your Challenge will be to figure it out.

The Challenge this month is going to be to put some simulated balls into simulated holes on simulated greens. The greens will be provided to you as an array of three dimensional points, divided into an array of adjoining triangles. You will "putt" the ball by imparting a velocity. The ball will move according to a black box propagation model that incorporates the effects of gravity and drag. How are you supposed to know how the ball will move if you don't have the propagation code? The same way Tiger and Monty do it, of course - practice!

The prototype for the code you should write is:

#if defined(__cplusplus)
extern "C" {
#endif

#include <MacTypes.h>

typedef struct Point3DDouble {
 double x;
 double y;
 double z;
} Point3DDouble;

typedef struct Velocity2DDouble {
 double x;
 double y;
} Velocity2DDouble;

typedef struct MyTriangle {
  long pointIndices[3];   /* index of points comprising the triangle */
} MyTriangle;

typedef struct BallPosition {
  double time;
  Point3DDouble pt;
} BallPosition;

void InitGreen(
  Point3DDouble points[], /* green terrain description */
  long numPoints,         /* number of points */
  MyTriangle triangles[], /* triangles comprising the green */
  int numTriangles,       /* number of triangles */
  long pinTriangle,       /* index in triangles[] of the pin on this green */
  long numPracticeHoles,
            /* number of unscored (but timed) holes to practice on this green */
  long numScoredHoles       /* number of holes to be scored on this green */
);
  
void StartHole(   /* called to start play on this hole */
  Point3DDouble ballPosition, /* initial ball position on the green */
  Boolean practice   /* TRUE if this hole is practice */
);

Boolean /* quit */ MakePutt(
  Velocity2DDouble *xyVelocity
   /* return initial ball velocity in the z==0 plane */
);

void BallMovement(
  BallPosition ballPositions[],
                     /* provides ball movement in response to MakePutt */
  int numBallPositions, /* number of ballPositions provided */
  Boolean inHole   /* true if the ball went into the hole */
);

#if defined(__cplusplus)
}
#endif

For each green you play on, your InitGreen routine will be called. It will be provided with the coordinates of numPoints points and with the numTriangles triangles that describe the topography of the green. One of the triangles (triangles[pinTriangle]) will represent the pin position on this hole - you need to move the ball from the starting ballPosition so that it enters this triangle in order to complete the hole. InitGreen will also be given the number of practice holes and the number of scored holes to be played on this green, each with a different initial ballPosition. The practice holes will all be played before any of the nonpractice holes, and the number of practice holes will always be at least as great as the number of nonpractice holes.

For each hole, your StartHole routine will be called with the initial ballPosition for that hole. The practice indicator will be set to TRUE if this is a practice hole. Next, your MakePutt and BallMovement routines will be called repeatedly until you put the ball in the hole (inHole==TRUE) or until you quit (MakePutt returns TRUE). You might quit on a practice hole if you decide you don't need any more practice (saving execution time). You might quit on a nonpractice hole if you decide that the cost of completing the hole exceeds the benefit (see the notes on scoring below).

MakePutt returns the velocity vector you want to impart for this shot. It is important to remember that your stroke velocity is specified in the x-y plane. That velocity will be increased (by 1/cos(slope)) to compensate for terrain angle. As the ball moves, the velocity will accelerated due to the effect of gravity, and decelerated due to the effect of drag.

BallMovement provides you with the results of your shot as a sequence of numBallPositions BallPositions. Each BallPosition has a three-dimensional position and a time tag (in seconds relative to the start of this shot). The inHole flag will tell you whether the ball went into the hole, indicating that the hole is over.

Solutions will be scored based on the number of holes successfully completed, the number of strokes required to complete those holes, and the amount of execution time expended. Each completed nonpractice hole earns 100 points. Each nonpractice stroke reduces the score by 10 points, and each second of execution time (including practice time) costs 10 points. The winner will be the solution that earns the greatest number of total points.

This will be a native PowerPC Challenge, using the latest CodeWarrior environment. Solutions may be coded in C, C++, or Pascal. Solutions in Java will also be accepted this month. Java entries must be accompanied by a test driver that uses the interface provided in the problem statement.

Three Months Ago Winner

Congratulations to Rob Shearer (location unknown) for submitting the fastest solution to the August FlyBy Challenge. The objective was to repeatedly render a scene from a sequence of viewpoints and viewing angles. Both Rob and first-time contestant Joe Strout used QuickDraw3D to do the rendering, and both described their solutions as straightforward. Rob converted the triangles that describe the scene to be rendered into a trimesh. He gained a speed advantage by turning off double buffering in QuickDraw3D, which makes the quality of the animation poor, but which was not prohibited by the problem statement. Restoring double buffering is a one-line code change. As a final comment, I'll note that Rob's code demonstrates some good coding techniques (e.g., modularization, use of assert)

I tested the two programs using a single scene with ~3200 points and ~6000 triangles, rendered from a sequence of ~260 viewpoints. The table below lists, for both of the solutions submitted, the total execution time in milliseconds, the code and data size, and the programming language used. As usual, the number in parentheses after the entrant's name is the total number of Challenge points earned in all Challenges prior to this one..

Name Time (msec) Code SizeData Size Lang
Rob Shearer (14) 232035540 1366 C++
Joe Strout 23873 1632 76 C++

Top Contestants

Listed here are the Top Contestants for the Programmer's Challenge, including everyone who has accumulated 10 or more points during the past two years. The numbers below include points awarded over the 24 most recent contests, including points earned by this month's entrants.

RankNamePoints
1.Munter, Ernst217
2.Saxton, Tom106
3.Maurer, Sebastian70
4.Boring, Randy66
5.Rieken, Willeke51
6.Heithcock, JG39
7.Shearer, Rob34
8.Brown, Pat20
9.Hostetter, Mat20
10. Mallett, Jeff20
11.Nicolle, Ludovic20
12.Murphy, ACC14
13.Jones, Dennis12
14.Hart, Alan11
15.Hewett, Kevin10
16.Selengut, Jared10
17.Smith, Brad10
18.Strout, Joe10
19.Varilly, Patrick10

There are three ways to earn points: (1) scoring in the top 5 of any Challenge, (2) being the first person to find a bug in a published winning solution or, (3) being the first person to suggest a Challenge that I use. The points you can win are:

1st place20 points
2nd place10 points
3rd place7 points
4th place4 points
5th place2 points
finding bug2 points
suggesting Challenge2 points

Here is Rob's winning CHALLENGENAME solution:

FlyBy.cp
Copyright © 1999 Rob Shearer

//  Very simple and straightforward implementation. It was
//  coded beginning to end in under three hours and worked
//  pretty much perfectly on the first build (only bug was
//  (1), below). It won't win any prizes for speed, though.
//
//  Only two caveats:
//  1)  As is documented in FlyByCamera.h, Quickdraw3D has
//    trouble with camera range with very low hither
//    values in relation to their yon values. This code
//    fixes that by pinning hither to a lower bound.
//  2)  FlyByView.h line 37 turns off double buffering.
//    This gives a tiny speed boost, but obviously makes
//    the animation not so nice. If you need pretty
//    animation, turn double buffering on.

#include "GuardedFlyBy.h"
#include <assert.h>
#include "Terrain.h"
#include "FlyByCamera.h"
#include "FlyByView.h"
#include <memory> // for auto_ptr
#include <Types.h>

// Globals are bad.
namespace FlyBy {
  auto_ptr<Terrain>       theTerrain;
  auto_ptr<FlyByCamera> theCamera;
  auto_ptr<FlyByView>     theView;
}

// -----------------------------
//    * InitFlyBy
// -----------------------------
//  Set up our globals and init Quickdraw3D

void
InitFlyBy(  CWindowPtr      theWindow,
      long      numPoints,
      const   TQ3Point3D  thePoints[],
      long      numTriangles,
      const   MyTriangles theTriangles[],
      const   TQ3ViewAngleAspectCameraData
                perspectiveData,
      const   TQ3ColorRGB backgroundColor ) {
  
  assert( (long) Q3Initialize !=
      kUnresolvedCFragSymbolAddress );
  TQ3Status theStatus(Q3Initialize());
  assert(theStatus != kQ3Failure);
  
  using namespace FlyBy;
  theTerrain.reset(new Terrain(numPoints,
                  thePoints,
                  numTriangles,
                  theTriangles ));
  assert(theTerrain.get());
  theCamera.reset(new FlyByCamera(perspectiveData));
  assert(theCamera.get());
  theView.reset(new FlyByView(theWindow,
                theCamera->GetQ3Camera(),
                backgroundColor));
  assert(theView.get());
}

// -----------------------------
//    * GenerateView
// -----------------------------
//  Update the camera placement and render

void
GenerateView(TQ3CameraPlacement viewPoint) {
  using namespace FlyBy;
  assert(theTerrain.get());
  assert(theCamera.get());
  assert(theView.get());
  theCamera->SetPlacement(viewPoint);
  
  theView->RenderModel(theTerrain->GetQ3Group());
}

// -----------------------------
//    * TermFlyBy
// -----------------------------
//  Delete our globals and exit Quickdraw3D

void
TermFlyBy() {
  using namespace FlyBy;
  theTerrain.reset();
  theCamera.reset();
  theView.reset();
  TQ3Status theStatus(Q3Exit());
  assert(theStatus != kQ3Failure);
}

Terrain.h

#ifndef _H_Terrain
#define _H_Terrain

#include <QD3DGeometry.h>
#include <QD3DGroup.h>
#include <QD3DMath.h>
#include "auto_array_ptr.cp"
#include <assert.h>
#include "GuardedFlyBy.h"

class Terrain {
public:
  Terrain(  long        inNumPoints,
        const TQ3Point3D  inPoints[],
        long        inNumTriangles,
        const MyTriangles inTriangles[] )
    : mModel(Q3OrderedDisplayGroup_New()) {
    
    // Allocate arrays for triangles and attributes
    auto_array_ptr<TQ3TriMeshTriangleData> theTriangles(
      new TQ3TriMeshTriangleData[inNumTriangles]
    );
    assert(theTriangles.get() != nil);
    auto_array_ptr<TQ3ColorRGB> theTriColors(
      new TQ3ColorRGB[inNumTriangles]
    );
    assert(theTriColors.get() != nil);
    auto_array_ptr<TQ3Vector3D> theNormals(
      new TQ3Vector3D[inNumTriangles]
    );
    assert(theNormals.get() != nil);
    
    // Init attributes
    TQ3TriMeshAttributeData theTriAttributes[2];
    theTriAttributes[0].attributeType =
      kQ3AttributeTypeDiffuseColor;
    theTriAttributes[0].data = theTriColors.get();
    theTriAttributes[0].attributeUseArray = nil;
    theTriAttributes[1].attributeType =
      kQ3AttributeTypeNormal;
    theTriAttributes[1].data = theNormals.get();
    theTriAttributes[1].attributeUseArray = nil;
    // Loop over inTriangles, filling in triangle
    // and attribute values in TriMesh structures.
    for (long i(0); i < inNumTriangles; ++i) {
      theTriangles[i].pointIndices[0] =
        inTriangles[i].pointIndices[0];
      theTriangles[i].pointIndices[1] =
        inTriangles[i].pointIndices[1];
      theTriangles[i].pointIndices[2] =
        inTriangles[i].pointIndices[2];
      theTriColors[i] =
        inTriangles[i].triangleColor;
      TQ3Vector3D theFirstEdge;
      Q3Point3D_Subtract(
        &(inPoints[inTriangles[i].pointIndices[0]]),
        &(inPoints[inTriangles[i].pointIndices[1]]),
        &theFirstEdge
      );
      TQ3Vector3D theSecondEdge;
      Q3Point3D_Subtract(
        &(inPoints[inTriangles[i].pointIndices[0]]),
        &(inPoints[inTriangles[i].pointIndices[2]]),
        &theSecondEdge
      );
      Q3Vector3D_Cross( &theFirstEdge,
                &theSecondEdge,
                &(theNormals[i]) );
      Q3Vector3D_Normalize( &(theNormals[i]),
                  &(theNormals[i]) );
    }
    
    // Compute bounding box
    TQ3BoundingBox theBox;
    if (inNumPoints > 0) {
      theBox.min = theBox.max = inPoints[0];
      theBox.isEmpty = kQ3False;
    } else {
      theBox.isEmpty = kQ3True;
    }
    for (long i(1); i < inNumPoints; ++i) {
      if (inPoints[i].x < theBox.min.x) {
        theBox.min.x = inPoints[i].x;
      } else if (inPoints[i].x > theBox.max.x) {
        theBox.max.x = inPoints[i].x;
      }
      if (inPoints[i].y < theBox.min.y) {
        theBox.min.y = inPoints[i].y;
      } else if (inPoints[i].y > theBox.max.y) {
        theBox.max.y = inPoints[i].y;
      }
      if (inPoints[i].z < theBox.min.z) {
        theBox.min.z = inPoints[i].z;
      } else if (inPoints[i].z > theBox.max.z) {
        theBox.max.z = inPoints[i].z;
      }
    }
    
    // Init TriMesh data
    TQ3TriMeshData theData;
    theData.triMeshAttributeSet = nil;
    theData.numTriangles = inNumTriangles;
    theData.triangles = theTriangles.get();
    theData.numTriangleAttributeTypes = 2;
    theData.triangleAttributeTypes = theTriAttributes;
    theData.numEdges = 0;
    theData.edges = nil;
    theData.numEdgeAttributeTypes = 0;
    theData.edgeAttributeTypes = nil;
    theData.numPoints = inNumPoints;
    theData.points = const_cast<TQ3Point3D*>(inPoints);
      // Yes, I know: bad form.
    theData.numVertexAttributeTypes = 0;
    theData.vertexAttributeTypes = nil;
    theData.bBox = theBox;
    
    // Create the TriMesh and add it to our model group
    TQ3GeometryObject theGeometry(Q3TriMesh_New(&theData));
    try {
      assert(theGeometry);
      assert(mModel);
      TQ3GroupPosition thePos =
        Q3Group_AddObject(mModel, theGeometry);
      assert(thePos);
    } catch (...) { // Wish for C++ "finally" block...
      Q3Object_Dispose(theGeometry);
      throw;
    }
    Q3Object_Dispose(theGeometry);
  };
  
  ~Terrain() {
    Q3Object_Dispose(mModel);
  };
  
  TQ3GroupObject GetQ3Group() { return mModel; };

private:
  TQ3GroupObject mModel;

  Terrain(const Terrain& rhs);
  Terrain& operator=(const Terrain& rhs);
};

#endif

FlyByCamera.h

#ifndef _H_FlyByCamera
#define _H_FlyByCamera

#include <QD3DCamera.h>
#include <assert.h>

class FlyByCamera {
public:
  FlyByCamera(const TQ3ViewAngleAspectCameraData& inData)
    : mCamera(Q3ViewAngleAspectCamera_New(&inData)) {
    assert(mCamera);
    // Quickdraw3D gets confused when the ratio of
    // hither to yon drops too low. All documentation
    // for this Challenge indicates that 0 will be
    // passed for hither, which causes significant
    // artifacts to appear. We pin hither to a lower
    // limit to prevent this (although the better
    // solution is probably to simply have a more
    // reasonable value of hither passed in).
    if (inData.cameraData.range.hither <
      inData.cameraData.range.yon/10000000) {
      TQ3CameraRange newRange;
      newRange.hither =
        inData.cameraData.range.yon/10000000;
      newRange.yon = inData.cameraData.range.yon;
      TQ3Status theStatus =
        Q3Camera_SetRange(mCamera, &newRange);
      assert(theStatus != kQ3Failure);
    }
  };
  ~FlyByCamera() {
    Q3Object_Dispose(mCamera);
  };
  TQ3CameraObject GetQ3Camera() { return mCamera; };
  void SetPlacement(const TQ3CameraPlacement& inWhere) {
    TQ3Status theStatus =
      Q3Camera_SetPlacement(mCamera, &inWhere);
    assert(theStatus != kQ3Failure);
  };
private:
  TQ3CameraObject mCamera;
  FlyByCamera(const FlyByCamera& rhs);
  FlyByCamera& operator=(const FlyByCamera& rhs);
};

#endif

FlyByView.h

#ifndef _H_FlyByView
#define _H_FlyByView

#include <QD3DView.h>
#include <QD3DDrawContext.h>
#include <QD3DRenderer.h>
#include <assert.h>

class FlyByView {
public:
  FlyByView(  CWindowPtr    inWindow,
        TQ3CameraObject inCamera,
        TQ3ColorRGB   inBGColor )
    : mView(Q3View_New()) {
    assert(mView);
    // Set up the draw context
    // This doesn't seem like the most efficient way
    // to fill in these data structures, but hey...
    TQ3DrawContextData theDrawData;
    theDrawData.clearImageMethod =
      kQ3ClearMethodWithColor;
    theDrawData.clearImageColor.a = 1;
    theDrawData.clearImageColor.r = inBGColor.r;
    theDrawData.clearImageColor.g = inBGColor.g;
    theDrawData.clearImageColor.b = inBGColor.b;
    theDrawData.paneState = kQ3False;
    theDrawData.maskState = kQ3False;
    // NOTE: We explicitly turn off double  buffering
    // for purposes of speed. This makes the animation
    // very ugly. If you want nicer animation then turn
    // double buffering back on.
    theDrawData.doubleBufferState = kQ3False;
    TQ3MacDrawContextData theMacData;
    theMacData.drawContextData = theDrawData;
    theMacData.window = (CWindowPtr) inWindow;
    theMacData.library = kQ3Mac2DLibraryNone;
    theMacData.viewPort = nil;
    theMacData.grafPort = nil;
    TQ3DrawContextObject theContext =
      Q3MacDrawContext_New(&theMacData);
    try {
      assert(theContext);
      TQ3Status theStatus =
        Q3View_SetDrawContext(mView, theContext);
      assert(theStatus != kQ3Failure);
    } catch (...) {
      Q3Object_Dispose(theContext);
      throw;
    }
    Q3Object_Dispose(theContext);
    // Set up the renderer
    TQ3RendererObject theRenderer =
    Q3Renderer_NewFromType(kQ3RendererTypeInteractive);
    try {
      assert(theRenderer);
      TQ3Status theStatus =
        Q3View_SetRenderer(mView, theRenderer);
      assert(theStatus != kQ3Failure);
    } catch (...) {
      Q3Object_Dispose(theRenderer);
      throw;
    }
    Q3Object_Dispose(theRenderer);
    // Set up the camera (which was passed in)
    assert(inCamera);
    TQ3Status theStatus =
      Q3View_SetCamera(mView, inCamera);
    assert(theStatus != kQ3Failure);
    
    // Set up the lighting
    TQ3LightData theData;
    theData.isOn = kQ3True;
    theData.brightness = 1;
    theData.color.r = 1;
    theData.color.g = 1;
    theData.color.b = 1;
    TQ3LightObject theLight =
      Q3AmbientLight_New(&theData);
    try {
      assert(theLight);
      TQ3GroupObject theLights(Q3LightGroup_New());
      try {
        assert(theLights);
        TQ3GroupPosition thePos =
          Q3Group_AddObject(theLights, theLight);
        assert(thePos);
        TQ3Status theStatus =
          Q3View_SetLightGroup(mView, theLights);
        assert(theStatus != kQ3Failure);
      } catch (...) {
        Q3Object_Dispose(theLights);
        throw;
      }
      Q3Object_Dispose(theLights);
    } catch (...) {
      Q3Object_Dispose(theLight);
      throw;
    }
    Q3Object_Dispose(theLight);
  };
  ~FlyByView() {
    Q3Object_Dispose(mView);
  };
  
  void RenderModel(TQ3GroupObject inModel) {
    Q3View_StartRendering(mView);
    do {
      Q3DisplayGroup_Submit(inModel, mView);
    } while ( Q3View_EndRendering(mView)
          == kQ3ViewStatusRetraverse );
  };
private:
  TQ3ViewObject mView;

  FlyByView(const FlyByView& rhs);
  FlyByView& operator=(const FlyByView& rhs);
};
#endif

auto_array_ptr.h

// A "smart pointer" template very similar to the standard
// auto_ptr but using array deletion to delete its pointee.

#ifndef _H_auto_array_ptr
#define _H_auto_array_ptr

#include <size_t.h>
template<class T>
class auto_array_ptr {

public:
  explicit auto_array_ptr(T* p = nil);  
          // Create an auto pointer with
          // ownership of the given object.
  auto_array_ptr(auto_array_ptr<T>& rhs);   
          // Copy constructor sets pointer
          // passed in to nil; new auto pointer
          // assumes ownership of its pointee.
  ~auto_array_ptr();
          // Destructor deletes pointee (with
          // delete[]).
  auto_array_ptr<T>&  operator=(auto_array_ptr<T>& rhs);  
          // Assignment sets pointer passed in
          // to nil, deletes current pointee,
          // and assumes ownership of rhs's old
          // pointee.
  // Emulate pointer/array behavior.
  T&      operator*() const;
  T*      operator->() const;
  T&      operator[](std::size_t inIndex);
  const T&  operator[](std::size_t inIndex) const;
  T*      get() const;
          // Return value of current dumb
          // pointer (for the purpose of
          // comparison).
  T*      release();
          // Relinquish ownership of pointee
          // and return value of current dumb
          // pointer.
  void    reset(T* p = nil);
          // Delete current pointee and assume
          // ownership of the given array.
        
private:
  T*      pointee;
};

#endif

auto_array_ptr.cp

// Code for auto_array_ptr template.
// This file must be #include -ed somewhere in your project
// in order to instantiate the template code.

// This is an #include file, so add guard macros.
#ifndef _CP_auto_array_ptr
#define _CP_auto_array_ptr

#include "auto_array_ptr.h"

// -----------------------------
//    * auto_array_ptr
// -----------------------------
//  Constructor

template<class T>
inline
auto_array_ptr<T>::auto_array_ptr(T* p)
  : pointee(p) {
}

// -----------------------------
//    * auto_array_ptr
// -----------------------------
//  Copy constructor
template<class T>
inline
auto_array_ptr<T>::auto_array_ptr(auto_array_ptr<T>& rhs)
  : pointee(rhs.release()) {
}

// -----------------------------
//    * ~auto_array_ptr
// -----------------------------
//  Destructor calls array delete on pointee

template<class T>
inline
auto_array_ptr<T>::~auto_array_ptr() {
  delete[] pointee;
}

// -----------------------------
//    * operator=
// -----------------------------
//  Assignment operator
template<class T>
inline
auto_array_ptr<T>&
auto_array_ptr<T>::operator=(auto_array_ptr<T>& rhs) {
  if (this != &rhs) reset(rhs.release());
  return *this;
}
// -----------------------------
//    * operator*
// -----------------------------
//  Dereference operator

template<class T>
inline
T&
auto_array_ptr<T>::operator*() const {
  // We could check for nil and throw an exception if
  // necessary, but we don't because (1) it's more
  // efficient not to do so and (2) if we do this array
  // won't act exactly as real arrays do when
  // dereferenced.
  return *pointee;
}

// -----------------------------
//    * operator->
// -----------------------------
//  Member selection operator
template<class T>
inline
T*
auto_array_ptr<T>::operator->() const {
  return pointee;
}

// -----------------------------
//    * operator[]
// -----------------------------
//  Element access operator (non-const version)
template<class T>
inline
T&
auto_array_ptr<T>::operator[](std::size_t inIndex) {
  // We could check for nil and throw an exception if
  // necessary, but we don't because (1) it's more
  // efficient not to do so and (2) if we do this array
  // won't act exactly as real array do when
  // accessed.
  return pointee[inIndex];
}

// -----------------------------
//    * operator[]
// -----------------------------
//  Element access operator (const version)
template<class T>
inline
const T&
auto_array_ptr<T>::operator[](std::size_t inIndex) const {
  // We could check for nil and throw an exception if
  // necessary, but we don't because (1) it's more
  // efficient not to do so and (2) if we do this array
  // won't act exactly as real array do when
  // accessed.
  return pointee[inIndex];
}
// -----------------------------
//    * get
// -----------------------------
//  Returns dumb pointer to pointee

template<class T>
inline
T*
auto_array_ptr<T>::get() const {
  return pointee;
}

// -----------------------------
//    * release
// -----------------------------
//  Relinquish ownership of pointee

template<class T>
inline
T*
auto_array_ptr<T>::release() {
  T* oldPointee(pointee);
  pointee = nil;
  return oldPointee;
}

// -----------------------------
//    * reset
// -----------------------------
//  Delete pointee and assume ownership of the given object

template<class T>
inline
void
auto_array_ptr<T>::reset(T* p) {
  delete[] pointee;
  pointee = p;  
}

#endif

FlyBy.h

#include <QD3D.h>
#include <QD3DLight.h>
#include <QD3DCamera.h>
#include <Windows.h>

#if defined(__cplusplus)
extern "C" {
#endif

typedef struct MyTriangles {
  long pointIndices[3];
  TQ3ColorRGB triangleColor;
} MyTriangles;

void InitFlyBy(
  CWindowPtr theWindow,
  long numPoints,
  const TQ3Point3D thePoints[],
  long numTriangles,
  const MyTriangles theTriangles[],
  const TQ3ViewAngleAspectCameraData  perspectiveData,
    // perspectiveData.cameraData.range.hither  = 0.0;
    // perspectiveData.cameraData.range.yon   = 1000.0
    // perspectiveData.cameraData.viewPort.origin.x = -1.0
    // perspectiveData.cameraData.viewPort.origin.y = 1.0
    // perspectiveData.cameraData.viewPort.width = 2.0
    // perspectiveData.cameraData.viewPort.height = 2.0
    // perspectiveData.fov        = 1.0
    // perspectiveData.aspectRatioXToY  =
    //   (float) (theWindow->portRect.right - theWindow->portRect.left) / 
    //   (float) (theWindow->portRect.bottom - theWindow->portRect.top)
  const TQ3ColorRGB backgroundColor
    // color of background
);
void GenerateView(
  TQ3CameraPlacement    viewPoint
);
void TermFlyBy(
);
#if defined(__cplusplus)
}
#endif

GuardedFlyBy.h

//  Added guard macros to "FlyBy.h"
#ifndef _H_GuardedFlyBy
#define _H_GuardedFlyBy
#include "FlyBy.h"
#endif
 

Community Search:
MacTech Search:

Software Updates via MacUpdate

FileZilla 3.27.1 - Fast and reliable FTP...
FileZilla (ported from Windows) is a fast and reliable FTP client and server with lots of useful features and an intuitive interface. Version 3.27.1: Fixed Vulnerabilities: Change client... Read more
Merlin Project 4.2.7 - $289.00
Merlin Project is the leading professional project management software for OS X. If you plan complex projects on your Mac, you won’t get far with a simple list of tasks. Good planning raises... Read more
Dashlane 4.8.4 - Password manager and se...
Dashlane is an award-winning service that revolutionizes the online experience by replacing the drudgery of everyday transactional processes with convenient, automated simplicity - in other words,... Read more
f.lux 39.984 - Adjusts the color of your...
f.lux makes the color of your computer's display adapt to the time of day, warm at night and like sunlight during the day. Ever notice how people texting at night have that eerie blue glow? Or wake... Read more
Sketch 46.2 - Design app for UX/UI for i...
Sketch is an innovative and fresh look at vector drawing. Its intentionally minimalist design is based upon a drawing space of unlimited size and layers, free of palettes, panels, menus, windows, and... Read more
Microsoft Office 2016 15.37 - Popular pr...
Microsoft Office 2016 - Unmistakably Office, designed for Mac. The new versions of Word, Excel, PowerPoint, Outlook and OneNote provide the best of both worlds for Mac users - the familiar Office... Read more
Slack 2.7.1 - Collaborative communicatio...
Slack is a collaborative communication app that simplifies real-time messaging, archiving, and search for modern working teams. Version 2.7.1: You're nearly finished signing in when suddenly – bonk... Read more
Google Chrome 60.0.3112.101 - Modern and...
Google Chrome is a Web browser by Google, created to be a modern platform for Web pages and applications. It utilizes very fast loading of Web pages and has a V8 engine, which is a custom built... Read more
Sound Studio 4.8.10 - Robust audio recor...
Sound Studio lets you easily record and professionally edit audio on your Mac. Easily rip vinyls and digitize cassette tapes, or record lectures and voice memos. Prepare for live shows with live... Read more
Slack 2.7.1 - Collaborative communicatio...
Slack is a collaborative communication app that simplifies real-time messaging, archiving, and search for modern working teams. Version 2.7.1: You're nearly finished signing in when suddenly – bonk... Read more

Bottom of the 9th (Games)
Bottom of the 9th 1.0.1 Device: iOS iPhone Category: Games Price: $4.99, Version: 1.0.1 (iTunes) Description: Play the most exciting moment of baseball in this fast-paced dice and card game! | Read more »
The best apps for viewing the solar ecli...
If you somehow missed the news, many parts of the United States will be witness to a total solar eclipse on August 21 for the first time in over 90 years. It'll be possible to see the eclipse in at least some capacity throughout the continental U... | Read more »
The 5 best mobile survival games
Games like ARK: Survival Evolved and Conan Exiles have taken the world of gaming by storm. The market is now flooded with hardcore survival games that send players off into the game's world with nothing but maybe the clothes on their back. Never... | Read more »
Portal Walk (Games)
Portal Walk 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: Portal Walk is adventure and relaxing platform game about Eugene. Eugene stuck between worlds and trying to find way back home.... | Read more »
Technobabylon (Games)
Technobabylon 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: City of Newton, 2087. Genetic engineering is the norm, the addictive Trance has replaced almost any need for human interaction,... | Read more »
5 reasons why 2v2 is the best mode in Cl...
Supercell has been teasing fans with 2v2 windows that allow players to team up for limited periods of time. The Summer of 2v2 was just this past July, but players are already clamoring for more of that sweet, sweet team-based action. The fans have... | Read more »
The best deals on the App Store this wee...
It seems like the week's only just started, and yet here we are with a huge pile of discounted games to sort through. There are some real doozies on sale this week. We're talking some truly stellar titles. Let's take a look at four of the best... | Read more »
Cat Quest Guide - How to become a purrfe...
Cat Quest is an absolutely charming open-world RPG that's taken the gaming world quite by storm. This game about a world populated by furry kitty warriors is actually a full-length RPG with sturdy mechanics and a lovely little story. It's certainly... | Read more »
Silly Walks Guide - How to strut your st...
Silly Walks is an all new adventure game that lives up to its name. It sees you playing as a variety of snack foods as you teeter-totter your way to rescue your friends from the evil blender and his villainous minions. It's all very . . . well... | Read more »
The best mobile point-and-click adventur...
Nostalgia for classic point-and-click adventure games has reached an all-time high in recent years, and the rise of mobile games have provided a perfect platform for this old-school genre. This week we're going to take a look at some of the best... | Read more »

Price Scanner via MacPrices.net

New iOS 11 Productivity Features Welcome But...
The iOS community is in late summer holding mode awaiting the September arrival of the iPhone 8 and iOS 11. iOS 11 public betas have been available for months — number six was released this week —... Read more
Samsung Electronics Launches New Portable SSD...
Samsung Electronics America, Inc. has announced the launch of Samsung Portable SSD T5 – its newest portable solid state drive (PSSD) that raises the bar for the performance of external memory... Read more
TrendForce Reports YoY Gain of 3.6% for 2Q17...
Market research firm TrendForce reports that the global notebook shipments for this second quarter registered a sequential quarterly increase of 5.7% and a year-on-year increase of 3.6%, totaling 39.... Read more
Sale! 10-inch iPad Pros for $50 off MSRP, no...
B&H Photo has 10.5″ iPad Pros in stock today and on sale for $50 off MSRP. Each iPad includes free shipping, and B&H charges sales tax in NY & NJ only: – 10.5″ 64GB iPad Pro: $599, save $... Read more
Sale! 2017 13-inch Silver 2.3GHz MacBook Pro...
Amazon has new 2017 13″ 2.3GHz/128GB Silver MacBook Pro on sale today for $100 off MSRP including free shipping. Their price is the lowest available for this model from any reseller: – 13″ 2.3GHz/... Read more
WaterField Unveils Collaboratively-Designed,...
In collaboration with customers and seasoned travelers, San Francisco maker WaterField Designs set out to create the preeminent carry-on system to improve the experience of frequent fliers. The... Read more
Miya Notes Mac-Client for Google Keep (Launch...
MacPlus Software has announced te launch of Miya Notes for Google Keep 1.0, a powerful Mac-client for Google Keep. Millions of people use Google Keep on their phones and online, but a convenient Mac... Read more
Apple refurbished iMacs available starting at...
Apple has previous-generation Certified Refurbished 2015 21″ & 27″ iMacs available starting at $849. Apple’s one-year warranty is standard, and shipping is free. The following models are... Read more
2017 13-inch MacBook Airs on sale for $100 of...
B&H Photo new 2017 13″ MacBook Airs on sale today for $100 off MSRP, starting at $899: – 13″ 1.8GHz/128GB MacBook Air (MQD32LL/A): $899, $100 off MSRP – 13″ 1.8GHz/256GB MacBook Air (MQD42LL/A... Read more
12-inch MacBooks on sale for $100 off MSRP
Amazon has 2017 12″ Retina MacBooks on sale for $100 off MSRP. Shipping is free: 12″ 1.2GHz Space Gray MacBook: $1199.99 $100 off MSRP 12″ 1.2GHz Silver MacBook: $1198 $101 off MSRP 12″ 1.2GHz Gold... Read more

Jobs Board

*Apple* Customer Experience (ACE) Leader - A...
…management to deliver on business objectivesTraining partner store staff on Apple products, services, and merchandising guidelinesCoaching partner store staff on Read more
*Apple* Solutions Consultant (ASC) - Poole -...
Job Summary The people here at Apple don't just create products - they create the kind of wonder that's revolutionised entire industries. It's the diversity of those Read more
Business Development Manager, *Apple* iClou...
Job Summary Apple is seeking an entrepreneurial person to help grow the Apple iCloud business, a service that is integral to the Apple customer experience. Read more
Product Metrics Manager - *Apple* Media Pro...
Job Summary Apple is seeking a product manager responsible for overseeing the instrumentation and analysis of usage data, in order to make data driven product Read more
iOS Wallet & *Apple* Pay Engineer - App...
Job Summary The iOS Apple Pay & Wallet team is looking for talented,...now add credit and debit cards to Wallet using Apple Pay. You can use Apple Pay in Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.