Run .bin file in Linux / UNIX

# chmod +x jre-1_5_0-linux-i586.bin

# ./jre-1_5_0-linux-i586.bin

Qt 4.72

configure -platform win32-msvc2010
SET QTDIR=C:\Qt\4.7.2
QMAKESPEC=win32-msvc2010

Creating a WXWidgets template in XCode

Apple appears to be encouraging people to move toward Cocoa and stop using Carbon.  wxCocoa is in pretty good shape so I've stopped using wxCarbon a few months ago.
Here's how I build the library:
# Build the library for Cocoa

rm -rf build-cocoa-debug
mkdir build-cocoa-debug
cd build-cocoa-debug
../configure --enable-unicode --enable-debug --disable-shared
--with-osx_cocoa
make;cd ..

# Build the samples and demos

cd build-cocoa-debug/samples; make;cd ../..
cd build-cocoa-debug/demos;   make;cd ../..

# Use Finder to run some of the samples to prove to yourself they work
# Then copy one of the samples to your own directory and compile it like
this
  Create an empty directory
  Add the source code files *.h, *.cpp, etc.
  You may also need sample.xpm if it is included in your main .cpp file
  Start XCode
  File, New Project...
  Application, Cocoa Application
  Next
  Set Project Name
  Set Project Directory to be the directory with the source code files.
  Finish
  The project window should appear
  Highlight main.m and delete it
  Change the configuration from "Release" to "Debug"
  Project, Add To Project...
  Highlight all of the .cpp files in the directory
  Add, Add
  Open a terminal window

cd wx/build-cocoa-debug
    ./wx-config --cxxflags   
    ./wx-config --libs
    

It is critical that you use ./wx-config not wx-config in those two
lines.
    You will copy the output of those two lines into Xcode in the next
steps.
  Go back to Xcode
  Click the "info" icon (blue circle with white i)
  Choose the "Build" tab
  Set the Configuration to "Debug"
  Set Show to "All Settings"
  In the Linking section,
    Uncheck ZeroLink
    Set Other Linker Flags to the output of --libs from the terminal window
  In the GCC Code Generation Section
    Uncheck Inline Methods Hidden
    Uncheck Symbols Hidden by Default
    Set Other C Flags to the output of --cxxflags from the terminal window
  In the Packaging section
    Set Product Name to a suitable name
  Close the configuration window
  Return to the project window
  Click Build and Go icon (green circle with hammer)
Thanks,

GLnode.cpp

// GLnode.cpp : Defines the entry point for the console application.
//

// test LLVM 2.0 
#include 

#include 
#include 
#include 

#ifndef SAFE_DELETE_VECTOR
#define SAFE_DELETE_VECTOR(x) { for(size_t __i__(0); __i__ < x.size(); ++__i__) delete(x.at(__i__)); x.clear(); }
#endif

template 
class GLvector : public std::vector {
public:
 inline void remove(T t)
 {
    typename std::vector::iterator pos = std::find(std::vector::begin(), std::vector::end(), t);
  if (pos != std::vector::end())
   erase(pos);
 }
};

template 
class GLvectorF : public GLvector {
 class _find_if_pred {
 private:
  std::string _name;
    
 public:
  _find_if_pred(const std::string& name)
    : _name(name)
  {
  }
  template 
  bool operator()(const TT* tt)
  {
   return ((_name.compare(tt->_name)) == 0);
  }
 };
  
public:
 int find(const std::string& name)
 {
  typename std::vector::iterator pos = std::find_if(std::vector::begin(), std::vector::end(), _find_if_pred(name));
  if (pos != std::vector::end())
   return (pos - std::vector::begin());
    
  return -1;
 }

  //if (pos != end())
 T& find_ptr(const std::string& name)
 {
  typename std::vector::iterator pos = std::find_if(std::vector::begin(), std::vector::end(), _find_if_pred(name));
  return *pos;
 }
 const T& find_ptr(const std::string& name) const
 {
  typename std::vector::const_iterator pos = std::find_if(std::vector::begin(), std::vector::end(), _find_if_pred(name));
  return *pos;
 }
};

class GLnode {
 class _for_each_pred {
 public:
  _for_each_pred(float time)
    : _time(time)
  {
  }
    
  template 
  void operator()(T& t) const
  {
   t->_update(_time);
  }
  float _time;
 };
  
public:
 GLnode()
 {
 }
 GLnode(const std::string& name)
  : _name(name)
 {
 }
 virtual ~GLnode()
 {
    SAFE_DELETE_VECTOR(_vec);
 }
  
 virtual void update(float time)
 {
  std::for_each(_vec.begin(), _vec.end(), _for_each_pred(time));
 }
  
protected:
 virtual void _update(float time) const
 {
    
 }
  
 /// attribute
public:
 std::string _name;
  
 /// operation
public:
  GLvectorF _vec;
};

char* itoa(int val, int base)
{
  static char buf[32] = {0};
  int i = 30;
  for(; val && i ; --i, val /= base)
    buf[i] = "0123456789abcdef"[val % base];
  return &buf[i+1];
} 

int main (int argc, const char * argv[])
{

  // insert code here...
  std::cout << "Hello, World!\n";
  
 GLnode _node;
  
 for (int i=0; i<10; i++)
 {
  char* ib = itoa(i, 10);
  _node._vec.push_back(new GLnode(ib));
 }
  
 int index = _node._vec.find("9");
  if (index != -1)
  {
    const GLnode* at = _node._vec.at(index);
    std::cout << "at= " << at->_name << std::endl;
  }
  
 const GLnode* ptr = _node._vec.find_ptr("9");
  if (ptr != *_node._vec.end())
    std::cout << "ptr= " << ptr->_name << std::endl;
  
 size_t size = _node._vec.size();
  std::cout << "size= " << size << std::endl;
  
 const GLnode* begin = *_node._vec.begin();
 const GLnode* end = *_node._vec.end();
  
  return 0;
}

c++ 0x

#if _HAS_CPP0X

GLnode.cpp

// GLnode.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include 
#include 
#include 
#include 

#ifndef SAFE_DELETE_VECTOR
#define SAFE_DELETE_VECTOR(x) { for(size_t __i__(0); __i__ < x.size(); ++__i__) delete(x.at(__i__)); x.clear(); }
#endif

template 
class GLcontainer {
public:
 virtual ~GLcontainer()
 {
  SAFE_DELETE_VECTOR(_vec);
 }

 void push_back(T* t)
 {
  _vec.push_back(t);
 }
 void remove(T* t)
 {
  std::vector::iterator pos = std::find(_vec.begin(), _vec.end(), t);
  if (pos != _vec.end())
   _vec.erase(pos);
 }

 const T* at(int pos) const
 {
  return _vec.at(pos);
 }

 const std::vector& get() const
 {
  return _vec;
 }
protected:
 std::vector _vec;
};

template 
class GLcontainerF : public GLcontainer {
 class _find_if_pred {
 private:
  std::string _name;

 public:
  _find_if_pred(const std::string& name)
   : _name(name)
  {
  }
  template 
  bool operator()(const TT* tt)
  {
   return ((_name.compare(tt->_name)) == 0);
  }
 };

public:
 const int find(const std::string& name) const
 {
  std::vector::const_iterator pos = std::find_if(_vec.begin(), _vec.end(), _find_if_pred(name));
  if (pos != _vec.end())
   return (pos - _vec.begin());

  return -1;
 }
 const T* find_ptr(const std::string& name) const
 {
  std::vector::const_iterator pos = std::find_if(_vec.begin(), _vec.end(), _find_if_pred(name));
  if (pos != _vec.end())
   return (*pos);

  return NULL;
 }
};

class GLnode : public GLcontainerF {
 class _for_each_pred {
 public:
  _for_each_pred(float time)
   : _time(time)
  {
  }

  template 
  void operator()(T * t) const
  {
   t->_update(_time);
  }
  float _time;
 };

public:
 GLnode()
 {
 }
 GLnode(const std::string& name)
  : _name(name)
 {
 }
 virtual ~GLnode()
 {
 }

 virtual void update(float time)
 {
  std::for_each(_vec.begin(), _vec.end(), _for_each_pred(time));
 }

protected:
 virtual void _update(float time) const
 {

 }

 /// attribute
public:
 std::string _name;

 /// operation
public:
};

int _tmain(int argc, _TCHAR* argv[])
{
 GLnode _node;

 for (int i=0; i<10; i++)
 {
  char ib[10];
  itoa(i, ib, 10);

  _node.push_back(new GLnode(ib));
 }

 int index = _node.find("9");
 const GLnode * ptr = _node.find_ptr("9");

 const GLnode * res = _node.at(index);

 return 0;
}

Node

std::for_each(IGame.Node.begin(), IGame.Node.end(), 
 [&] (IGameImporter::Node Node)
 {
  IGameImporter::Mesh Mesh = Node.Mesh;
  float * vf = Mesh.Vertices.data();
  float * nf = Mesh.Normals.data();
}

atob

bool atob(const char * string)
{
 if (!strcmp(string, "true"))
  return true;

 return false;
}

txt2ushort

class txt2ushort {
public:
 void push_back(const char * text)
 {
  unsigned short f = (unsigned short) atoi(text);
  m_vf.push_back(f);

  char * p = (char *) text;
  while (*p)
  {
   if (*p == 0x20)
   {
    f = (unsigned short) atoi(p);
    m_vf.push_back(f);
   }

   p++;
  }
 }

 void clear()
 {
  m_vf.clear();
 }

 unsigned short * data()
 {
  return m_vf.data();
 }

 std::vector & get()
 {
  return m_vf;
 }

private:
 std::vector m_vf;
};

txt2float

#include 
#include 
#include 

class txt2float {
public:
 void push_back(const char * text)
 {
  float f = (float) atof(text);
  m_vf.push_back(f);
  char * p = (char *) text;
  while (*p)
  {
   if (*p == 0x20)
   {
    f = (float) atof(p);
    m_vf.push_back(f);
   }
   p++;
  }
 }
 void clear()
 {
  m_vf.clear();
 }
 float * data()
 {
  return m_vf.data();
 }
 std::vector & get()
 {
  return m_vf;
 }
private:
 std::vector m_vf;
};

{
txt2float tf;
tf.push_back(Value);
SubMaterial.Diffuse = tf.get();
}

OpenGL ES 2.0 + MFC

/// CXXXView.cpp

void CXXXView::OnInitialUpdate()
{
 CView::OnInitialUpdate();

 // TODO: Add your specialized code here and/or call the base class
 if (m_eglDisplay != EGL_NO_DISPLAY)
  return;

 const EGLint attrs[] = {
  EGL_LEVEL, 0,
  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
  EGL_NATIVE_RENDERABLE, EGL_FALSE,
  EGL_DEPTH_SIZE, EGL_DONT_CARE,
  EGL_NONE
 };
 EGLint numConfig =0;

 m_eglDisplay = eglGetDisplay(GetDC()->GetSafeHdc());
 if (m_eglDisplay == EGL_NO_DISPLAY)
  if ((m_eglDisplay = eglGetDisplay((EGLNativeDisplayType) EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY)
   return;

 // Initialize the display
 EGLint major = 0;
 EGLint minor = 0;
 if (!eglInitialize(m_eglDisplay, &major, &minor))
  return;

 if (major < 1 || minor < 3)
 {
  // Does not support EGL 1.3
  printf("System does not support at least EGL 1.3 \n");
  return;
 }

 EGLConfig eglConfig;

 // Obtain the first configuration with a depth buffer
 if (!eglChooseConfig(m_eglDisplay, attrs, &eglConfig, 1, &numConfig))
  return;

 // Create a surface for the main window
 if ((m_eglSurface = eglCreateWindowSurface(m_eglDisplay, eglConfig, (EGLNativeWindowType) GetSafeHwnd(), NULL)) == EGL_NO_SURFACE)
  return;

 // Bind the API (It could be OpenGLES or OpenVG)
 // eglBindAPI(EGL_OPENGL_ES_API);
 EGLint ai32ContextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };

 // Create an OpenGL ES context
 if ((m_eglContext = eglCreateContext(m_eglDisplay, eglConfig, EGL_NO_CONTEXT, ai32ContextAttribs)) == EGL_NO_CONTEXT)
  return;

 // Make the context and surface current
 if (!eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext))
  return;

 ///
 glClearColor(0.5f, 0.5f, 0.5f, 0.0f);
}

void CXXXView::PostNcDestroy()
{
 // TODO: Add your specialized code here and/or call the base class
 eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 eglDestroyContext(m_eglDisplay, m_eglContext);
 eglDestroySurface(m_eglDisplay, m_eglSurface);

 eglTerminate(m_eglDisplay);

 CView::PostNcDestroy();
}

void CXXXView::onDraw(void)
{
 glClear(GL_COLOR_BUFFER_BIT);

 ///
 IGameImporter * gameImport = NULL;

 auto pDoc = GetDocument();
 if (pDoc && pDoc->IsKindOf(RUNTIME_CLASS(CXXXDoc)))
  gameImport = dynamic_cast (pDoc)->getGameImport();
 ///

 eglSwapBuffers(m_eglDisplay, m_eglSurface);
}

BOOL CXXXView::OnEraseBkgnd(CDC* pDC)
{
 // TODO: Add your message handler code here and/or call default

 /// return CView::OnEraseBkgnd(pDC);
 return FALSE;
}

void CXXXView::OnSize(UINT nType, int cx, int cy)
{
 CView::OnSize(nType, cx, cy);

 // TODO: Add your message handler code here
 glViewport(0, 0, cx, cy);
}


/// CXXXApp.cpp

BOOL CXXXApp::OnIdle(LONG lCount)
{
 // TODO: Add your specialized code here and/or call the base class

// return CWinAppEx::OnIdle(lCount);
 CMainFrame * pFrame = (CMainFrame *) AfxGetMainWnd();

 CView * pView = pFrame->GetActiveView();
 if (pView && pView->IsKindOf(RUNTIME_CLASS(CXXXView)))
  dynamic_cast (pView)->onDraw();

 return TRUE;
}


/// CViewTree.h

#define WM_TVN_SELCHANGED (WM_USER+3)

class CViewTree : public CTreeCtrl
{
public:
 afx_msg void OnTvnSelchanged(NMHDR *pNMHDR, LRESULT *pResult);
};


/// CViewTree.cpp

BEGIN_MESSAGE_MAP(CViewTree, CTreeCtrl)
 ON_NOTIFY_REFLECT(TVN_SELCHANGED, &CViewTree::OnTvnSelchanged)
END_MESSAGE_MAP()

void CViewTree::OnTvnSelchanged(NMHDR *pNMHDR, LRESULT *pResult)
{
 LPNMTREEVIEW pNMTreeView = reinterpret_cast(pNMHDR);
 // TODO: Add your control notification handler code here
 GetParent()->SendNotifyMessage(WM_TVN_SELCHANGED, (WPARAM) pNMTreeView, (LPARAM) pResult);

 *pResult = 0;
}

MFC FileImport

void CXXXDoc::OnFileImport()
{
 // TODO: Add your command handler code here
 TCHAR currentPath[MAX_PATH];
 GetCurrentDirectory(MAX_PATH, currentPath);

 LPCTSTR szFilter = _T("XML Files (*.xml)|*.xml|All Files (*.*)|*.*|");
 CFileDialog fileDialog(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, szFilter);

 fileDialog.m_ofn.lpstrTitle = _T("Open XML Scene File");
 fileDialog.m_ofn.lpstrInitialDir = _T("");

 if (fileDialog.DoModal() == IDOK)
 {
  CString fileExt = fileDialog.GetFileExt();
  CString pathName = fileDialog.GetPathName();

  IGameImporter import;
  import.DoImport(pathName);
 }

 SetCurrentDirectory(currentPath);
}

SyntaxHighlighter

Ribbon Menu

ribbon.mfcribbon-ms

  Button
  
    ID_FILE_NEW
    57600
  
  &New
  0
  0





  
    ID_FILE_NEW
    57600
  

3D Studio MAX SDK

Environment Variables:
  MAXSDKPATH=C:\Program Files (x86)\Autodesk\3ds Max 2010 SDK

Sample source
  http://download.autodesk.com/media/adn/DevTV_Introduction_to_3DS_Max_Programming.zip
or
  $(MAXSDKPATH)\maxsdk\samples\igame\export

Visual Studio Property Pages:

C/C++:
  Additional Include Directories:
    $(MAXSDKPATH)\maxsdk\include;

Linker:
  Additional Library Directories:
    $(MAXSDKPATH)\maxsdk\lib
  Module Definition File:
    .\IGameExporter.def
  Additional Dependencies:
    core.lib;geom.lib;gfx.lib;mesh.lib;maxutil.lib;maxscrpt.lib;paramblk2.lib;msxml2.lib;igame.lib
  Ignore Specific Default Libraries:
    libcp.lib;libci.lib;msvcirt.lib;libcmt.lib;libcmtd.lib;msvcrt.lib

wxWidgets 2.9.1 & MinGW

WxWidgets: http://www.wxwidgets.org/downloads/
MinGW: http://sourceforge.net/projects/mingw/files/

* Microsoft Windows

Environment Variables:

set WXWIN = c:\wxwidgets-2.9.1
cd $(WXWIN)\build\msw

Microsoft Visual C++
  1. Visual Studio Command Prompt (2010)

nmake -f makefile.vc MONOLITHIC=1 SHARED=1 UNICODE=1 BUILD=release

MinGW

mingw32-make -f makefile.gcc MONOLITHIC=1 SHARED=1 UNICODE=1 BUILD=release

* Apple OSX

mkdir osx-build
cd osx-build
../configure -with-osx_cocoa -with-opengl -enable-stl -enable-monolithic -enable-debug -enable-debug-gdb -enable-dynlib
make

* Compile

/D _UNICODE;__WXMSW__;NOPCH;WXUSINGDLL;