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;
}