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

Capto 1.2.9 - $29.99
Capto (was Voila) is an easy-to-use app that takes capturing, recording, video and image editing to the next level. With an intelligent file manager and quick sharing options, Capto is perfect for... Read more
Opera 51.0.2830.40 - High-performance We...
Opera is a fast and secure browser trusted by millions of users. With the intuitive interface, Speed Dial and visual bookmarks for organizing favorite sites, news feature with fresh, relevant content... Read more
GarageSale 7.0.13 - Create outstanding e...
GarageSale is a slick, full-featured client application for the eBay online auction system. Create and manage your auctions with ease. With GarageSale, you can create, edit, track, and manage... Read more
1Password 6.8.7 - Powerful password mana...
1Password is a password manager that uniquely brings you both security and convenience. It is the only program that provides anti-phishing protection and goes beyond password management by adding Web... Read more
Evernote 7.0.1 - Create searchable notes...
Evernote allows you to easily capture information in any environment using whatever device or platform you find most convenient, and makes this information accessible and searchable at anytime, from... Read more
MacUpdate Desktop 6.2.0 - $20.00
MacUpdate Desktop brings seamless 1-click app installs and version updates to your Mac. With a free MacUpdate account and MacUpdate Desktop 6, Mac users can now install almost any Mac app on... Read more
HoudahSpot 4.3.5 - Advanced file-search...
HoudahSpot is a versatile desktop search tool. Use HoudahSpot to locate hard-to-find files and keep frequently used files within reach. HoudahSpot will immediately feel familiar. It works just the... Read more
EtreCheck 4.0.4 - For troubleshooting yo...
EtreCheck is an app that displays the important details of your system configuration and allow you to copy that information to the Clipboard. It is meant to be used with Apple Support Communities to... Read more
WhatsApp 0.2.8361 - Desktop client for W...
WhatsApp is the desktop client for WhatsApp Messenger, a cross-platform mobile messaging app which allows you to exchange messages without having to pay for SMS. WhatsApp Messenger is available for... Read more
iClock 4.2 - Customize your menubar cloc...
iClock is a menu-bar replacement for Apple's default clock but with 100x features. Have your Apple or Google calendar in the menubar. Have the day, date, and time in different fonts and colors in the... Read more

Latest Forum Discussions

See All

Alto's Odyssey Guide - How to Tackl...
Alto’s Odyssey is a completely stunning and serene runner, but it can also be a bit tricky. Check out these to try and keep your cool while playing this endless runner: Don’t focus too much on tasks [Read more] | Read more »
Here's everything you need to know...
Alto's Odyssey is a really, really good game. If you don't believe me, you should definitely check out our review by clicking this link right here. It takes the ideas from the original Alto's Adventure, then subtly builds on them, creating... | Read more »
Alto's Odyssey (Games)
Alto's Odyssey 1.0.1 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0.1 (iTunes) Description: Just beyond the horizon sits a majestic desert, vast and unexplored. Join Alto and his friends and set off on an endless... | Read more »
Vainglory 5v5: Everything you need to kn...
Vainglory just got bigger. [Read more] | Read more »
Check out these 5 games that are a lot l...
So you're in love with Minecraft, but you're looking for something else to play as well? You've come to the right place then, because this list is all about games that are a bit like Minecraft. Some of them, more than others. [Read more] | Read more »
Our top 5 characters from casual RPG Cre...
Creature Quest definitely lives up to its name with a host of collectible creatures based on fantasy tales and world mythologies. To celebrate Creature Quest’s first birthday, we’re going to lay out what we think are the five best characters in the... | Read more »
Around the Empire: What have you missed...
Did you know that Steel Media has a whole swathe of other sites dedicated to all aspects of mobile gaming? Sure you'll get the very best iPhone news, reviews, and opinions right here at 148Apps, but we don't want you missing out on a single piece... | Read more »
All the best games on sale for iPhone an...
Oh hi there, and welcome to our round-up of the best games that are currently on sale for iPhone and iPad. You thought I didn't see you there, did you, skulking behind the bushes? Trust me though, the bushes aren't where the best deals are. The... | Read more »
The Battle of Polytopia Guide - How to H...
A new update just released for The Battle of Polytopia (formerly Super Tribes), which introduces online multiplayer. For all the fans of Midjiwan’s lite take on Civilization, this is certainly welcome news, but playing online isn’t as easy and... | Read more »
The best games that came out for iPhone...
Another week, another bunch of new releases on the App Store, another update to our big list of new games. It's not a classic lineup this week, but there are some really good ones in the mix all the same. [Read more] | Read more »

Price Scanner via MacPrices.net

Amazon restocks MacBook Pros with models avai...
Amazon has restocked 15″ and 13″ Apple MacBook Pros with models on sale for up to $251 off MSRP. Shipping is free. Note that stock of some Macs may come and go (and some sell out quickly), so check... Read more
Lowest price of the year: 15″ 2.8GHz Apple Ma...
Amazon has the 2017 Space Gray 15″ 2.8GHz MacBook Pro on sale today for $251 off MSRP. Shipping is free: – 15″ 2.8GHz Touch Bar MacBook Pro Space Gray (MPTR2LL/A): $2148, $251 off MSRP Their price is... Read more
Apple restocks full line of Certified Refurbi...
Apple has restocked a full line of Apple Certified Refurbished 2017 13″ MacBook Pros for $200-$300 off MSRP. A standard Apple one-year warranty is included with each MacBook, and shipping is free.... Read more
Lowest sale price available for 13″ 1.8GHz Ma...
Focus Camera has the 2017 13″ 1.8GHz/128GB Apple MacBook Air on sale today for $829 including free shipping. Their price is $170 off MSRP, and it’s the lowest price available for a current 13″... Read more
21-inch 2.3GHz iMac on sale for $999, $100 of...
B&H Photo has the 2017 21″ 2.3GHz iMac (MMQA2LL/A) in stock and on sale for $999 including free shipping plus NY & NJ tax only. Their price is $100 off MSRP. Read more
Apple refurbished Mac minis in stock again st...
Apple has restocked Certified Refurbished Mac minis starting at $419. Apple’s one-year warranty is included with each mini, and shipping is free: – 1.4GHz Mac mini: $419 $80 off MSRP – 2.6GHz Mac... Read more
Tuesday MacBook Deals: $250 off 15″ 2.9GHz Ma...
Adorama has the Silver 15″ 2.9GHz Apple MacBook Pro on sale today for $250 off MSRP. Shipping is free, and Adorama charges sales tax for residents in NY & NJ only: – 15″ 2.9GHz Silver MacBook Pro... Read more
Save up to $350 with these Apple Certified Re...
Apple has a full line of Certified Refurbished iMacs available for up to $350 off original MSRP. Apple’s one-year warranty is standard, and shipping is free. The following models are available: – 27... Read more
B&H offers $200 discount on Silver 15″ Ma...
B&H Photo has Silver 15″ Apple MacBook Pros on sale for $200 off MSRP. Shipping is free, and B&H charges sales tax for NY & NJ residents only: – 15″ 2.8GHz Touch Bar MacBook Pro Silver (... Read more
12″ Apple iPad Pro Sale of the Year! Models u...
B&H Photo has 12″ #iPad Pros on sale for up to $150 off MSRP. Shipping is free, and B&H charges sales tax in NY & NJ only: – 12″ 64GB WiFi iPad Pro: $719 $80 off MSRP – 12″ 256GB WiFi... Read more

Jobs Board

*Apple* Retail - Multiple Positions - Apple,...
Job Description:SalesSpecialist - Retail Customer Service and SalesTransform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Sr. Experience Designer, Today at *Apple* -...
# Sr. Experience Designer, Today at Apple Job Number: 56495251 Santa Clara Valley, California, United States Posted: 18-Jan-2018 Weekly Hours: 40.00 **Job Summary** Read more
*Apple* Technical Specialist - Apple, Inc. (...
…customers purchase our products, you're the one who helps them get more out of their new Apple technology. Your day in the Apple Store is filled with a range of Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Strategist, *Apple* Media Products, Content...
# Strategist, Apple Media Products, Content and Marketing Job Number: 113399632 Santa Clara Valley, California, United States Posted: 20-Feb-2018 Weekly Hours: 40.00 Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.