(...)
// Support for throwing D exceptions from C/C++.
typedef enum {
  SWIG_DException = 0,
  SWIG_DIllegalArgumentException,
  SWIG_DIllegalElementException,
  SWIG_DIOException,
  SWIG_DNoSuchElementException,
} SWIG_DExceptionCodes;

typedef void (* SWIG_DExceptionCallback_t)(const char *);

typedef struct {
  SWIG_DExceptionCodes code;
  SWIG_DExceptionCallback_t callback;
} SWIG_DException_t;

static SWIG_DException_t SWIG_d_exceptions[] = {
  { SWIG_DException, NULL },
  { SWIG_DIllegalArgumentException, NULL },
  { SWIG_DIllegalElementException, NULL },
  { SWIG_DIOException, NULL },
  { SWIG_DNoSuchElementException, NULL }
};

(..)
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void SWIGRegisterExceptionCallbacks_Horde3D(
  SWIG_DExceptionCallback_t exceptionCallback,
  SWIG_DExceptionCallback_t illegalArgumentCallback,
  SWIG_DExceptionCallback_t illegalElementCallback,
  SWIG_DExceptionCallback_t ioCallback,
  SWIG_DExceptionCallback_t noSuchElementCallback) {
  SWIG_d_exceptions[SWIG_DException].callback = exceptionCallback;
  SWIG_d_exceptions[SWIG_DIllegalArgumentException].callback = illegalArgumentCallback;
  SWIG_d_exceptions[SWIG_DIllegalElementException].callback = illegalElementCallback;
  SWIG_d_exceptions[SWIG_DIOException].callback = ioCallback;
  SWIG_d_exceptions[SWIG_DNoSuchElementException].callback = noSuchElementCallback;
}


// Callback for returning strings to D without leaking memory.
typedef char * (* SWIG_DStringHelperCallback)(const char *);
static SWIG_DStringHelperCallback SWIG_d_string_callback = NULL;

#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void SWIGRegisterStringCallback_Horde3D(SWIG_DStringHelperCallback callback) {
  SWIG_d_string_callback = callback;
}


/* Contract support. */
#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_DSetPendingException(SWIG_DException, msg); return nullreturn; } else


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT int D_H3DRootNode_get() {
  int jresult ;
  H3DNode result;
 
  result = (H3DNode)(H3DNode)H3DRootNode;
  jresult = result;
  return jresult;
}


SWIGEXPORT void * D_new_H3DOptions() {
  void * jresult ;
  struct H3DOptions *result = 0 ;
 
  result = (struct H3DOptions *)calloc(1, sizeof(struct H3DOptions));
  jresult = (void *)result;
  return jresult;
}


SWIGEXPORT void D_delete_H3DOptions(void * jarg1) {
  struct H3DOptions *arg1 = (struct H3DOptions *) 0 ;
 
  arg1 = (struct H3DOptions *)jarg1;
  free((char *) arg1);
}

SWIGEXPORT char * D_h3dGetResName(int jarg1) {
  char * jresult ;
  H3DRes arg1 ;
  char *result = 0 ;
 
  arg1 = (H3DRes)jarg1;
  result = (char *)h3dGetResName(arg1);
  jresult = SWIG_d_string_callback((const char *)result);
  return jresult;
}


SWIGEXPORT int D_h3dGetNextResource(int jarg1, int jarg2) {
  int jresult ;
  int arg1 ;
  H3DRes arg2 ;
  H3DRes result;
 
  arg1 = (int)jarg1;
  arg2 = (H3DRes)jarg2;
  result = (H3DRes)h3dGetNextResource(arg1,arg2);
  jresult = result;
  return jresult;
}


SWIGEXPORT int D_h3dFindResource(int jarg1, char * jarg2) {
  int jresult ;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  H3DRes result;
 
  arg1 = (int)jarg1;
  arg2 = (char *)jarg2;
  result = (H3DRes)h3dFindResource(arg1,(char const *)arg2);
  jresult = result;
  return jresult;
}


SWIGEXPORT int D_h3dAddResource(int jarg1, char * jarg2, int jarg3) {
  int jresult ;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  H3DRes result;
 
  arg1 = (int)jarg1;
  arg2 = (char *)jarg2;
  arg3 = (int)jarg3;
  result = (H3DRes)h3dAddResource(arg1,(char const *)arg2,arg3);
  jresult = result;
  return jresult;
}


SWIGEXPORT int D_h3dCloneResource(int jarg1, char * jarg2) {
  int jresult ;
  H3DRes arg1 ;
  char *arg2 = (char *) 0 ;
  H3DRes result;
 
  arg1 = (H3DRes)jarg1;
  arg2 = (char *)jarg2;
  result = (H3DRes)h3dCloneResource(arg1,(char const *)arg2);
  jresult = result;
  return jresult;
}


SWIGEXPORT int D_h3dRemoveResource(int jarg1) {
  int jresult ;
  H3DRes arg1 ;
  int result;
 
  arg1 = (H3DRes)jarg1;
  result = (int)h3dRemoveResource(arg1);
  jresult = result;
  return jresult;
}

Index: trunk/Horde3D/Bindings/CMakeLists.txt
===================================================================
--- trunk/Horde3D/Bindings/CMakeLists.txt       (revision 724)
+++ trunk/Horde3D/Bindings/CMakeLists.txt       (working copy)
@@ -1 +1,2 @@
-add_subdirectory(C++)
\ No newline at end of file
+add_subdirectory(C++)
+add_subdirectory(D)

# ls D
CMakeLists.txt  derelict  native  swig
#cat CMakeLists.txt
add_subdirectory(swig)
# cd D && ls swig
CMakeLists.txt  Horde3D.i
# cat CMakeLists.txt
FIND_PACKAGE(SWIG REQUIRED)
INCLUDE(${SWIG_USE_FILE})

SET(CMAKE_SWIG_FLAGS "-d2")

aux_source_directory(${Horde3D_SOURCE_DIR}/Horde3D/Source/Horde3DEngine/ HORDE3D_SOURCES)
include_directories(${Horde3D_SOURCE_DIR}/Horde3D/Source/Horde3DEngine/ ${Horde3D_SOURCE_DIR}/Horde3D/Source/Shared/ ${Horde3D_SOURCE_DIR}/Extensions)

SET_SOURCE_FILES_PROPERTIES(Horde3D.i PROPERTIES CPLUSPLUS ON)
SET_SOURCE_FILES_PROPERTIES(Horde3D.i PROPERTIES SWIG_FLAGS "-wrapperlibrary Horde3D -includeall")
SET(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR})
SWIG_ADD_MODULE(Horde3D_wrap d Horde3D.i ${HORDE3D_SOURCES})
SWIG_LINK_LIBRARIES(Horde3D_wrap Horde3D)
SET_TARGET_PROPERTIES(Horde3D_wrap PROPERTIES LINKER_LANGUAGE C)

if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
endif(${CMAKE_SYSTEM_NAME} MATCHES "Windows")

if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
        install(FILES Horde3D.d #Horde3DUtils.d
        DESTINATION include/d)
        install(TARGETS Horde3D_wrap
                RUNTIME DESTINATION bin
                LIBRARY DESTINATION lib
                ARCHIVE DESTINATION lib)
endif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")

if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
# cat Horde3D.i
%module Horde3D
%{
#include "../../C++/Horde3D.h"
%}
%include "../../C++/Horde3D.h"

SWIGEXPORT char * D_h3dGetResName(int jarg1)

string h3dGetResParamStr(int res, int elem, int elemIdx, int param) {
  string ret = std.conv.to!string(Horde3D_im.h3dGetResParamStr(res, elem, elemIdx, param));
  return ret;
}

SWIGEXPORT char * D_h3dGetResParamStr(int jarg1, int jarg2, int jarg3, int jarg4) {
  char * jresult ;
  H3DRes arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  char *result = 0 ;

  arg1 = (H3DRes)jarg1;
  arg2 = (int)jarg2;
  arg3 = (int)jarg3;
  arg4 = (int)jarg4;
  result = (char *)h3dGetResParamStr(arg1,arg2,arg3,arg4);
  jresult = SWIG_d_string_callback((const char *)result);
  return jresult;
}

/*
   Draft high-level generic physics C-API. For low-level access, use the physics SDK native API's.
   Work in progress, functionality will be added on demand.

   If possible, use the richer Bullet C++ API, by including "btBulletDynamicsCommon.h"
*/