X-Git-Url: https://git.jsancho.org/?p=guile-irrlicht.git;a=blobdiff_plain;f=src%2Fvideo-driver.cpp;h=dd663e745d75e45b8d4c695d21e66baaa76c4a41;hp=c746db3ae313727d9f7c42a3b6d8958755ec9d67;hb=09e9ed196aadab0f77e831c134fce8bdb58b772b;hpb=2806f03eafc48ec9ef02a3dc2d74133eaf11ccc1

diff --git a/src/video-driver.cpp b/src/video-driver.cpp
index c746db3..dd663e7 100644
--- a/src/video-driver.cpp
+++ b/src/video-driver.cpp
@@ -21,19 +21,186 @@
 
 #include <irrlicht/irrlicht.h>
 #include <libguile.h>
+#include "color.h"
+#include "gsubr.h"
+#include "matrix4.h"
+#include "primitive-types.h"
+#include "rect.h"
+#include "vertex3d.h"
 #include "video-driver.h"
+#include "wchar.h"
 #include "wrapped.h"
 
-extern "C" {
+using namespace irr;
 
-  void
-  init_video_driver (void)
-  {
-    init_video_driver_type ();
-  }
+SCM
+IVideoDriver_beginScene (SCM video_driver,
+                         SCM back_buffer,
+                         SCM z_buffer,
+                         SCM color,
+                         SCM video_data,
+                         SCM source_rect)
+{
+  video::IVideoDriver* driver = (video::IVideoDriver*) scm_to_irr_pointer (video_driver);
 
-  DEFINE_WRAPPED_TYPE (irr::video::IVideoDriver*, "video-driver",
-                       init_video_driver_type, video_driver_p,
-                       wrap_video_driver, unwrap_video_driver);
+  // Source rect
+  core::rect<s32>* sourceRectAddress = 0;
+  if (!scm_is_false (source_rect))
+    {
+      core::rect<s32> sourceRect = scm_to_rect_s32 (source_rect);
+      sourceRectAddress = &sourceRect;
+    }
 
+  return scm_from_bool (driver->beginScene (scm_to_bool (back_buffer),
+                                            scm_to_bool (z_buffer),
+                                            scm_to_color (color),
+                                            video::SExposedVideoData (),
+                                            sourceRectAddress));
+}
+
+SCM
+IVideoDriver_drawVertexPrimitiveList (SCM video_driver,
+                                      SCM vertices,
+                                      SCM indices,
+                                      SCM v_type,
+                                      SCM p_type)
+{
+  // Build vertex array
+  u32 vertex_count = scm_to_uint32 (scm_length (vertices));
+  video::S3DVertex s3d_vertices [vertex_count];
+  for (int i = 0; i < vertex_count; i++)
+    {
+      video::S3DVertex* vertex =
+        (video::S3DVertex*) scm_to_irr_pointer (scm_list_ref (vertices, scm_from_int (i)));
+      s3d_vertices[i] = video::S3DVertex (vertex->Pos,
+                                          vertex->Normal,
+                                          vertex->Color,
+                                          vertex->TCoords);
+    }
+
+  // Build index array
+  u32 index_count = scm_to_uint32 (scm_length (indices));
+  SCM flat_indices = scm_apply_0 (scm_eval_string (scm_from_utf8_string ("append")),
+                                  indices);
+  int flat_length = scm_to_int (scm_length (flat_indices));
+  u32 c_indices [flat_length];
+  for (int i = 0; i < flat_length; i++)
+    {
+      c_indices[i] = scm_to_uint32 (scm_list_ref (flat_indices, scm_from_int (i)));
+    }
+
+  // Draw vertices
+  video::IVideoDriver* driver = (video::IVideoDriver*) scm_to_irr_pointer (video_driver);
+  driver->drawVertexPrimitiveList (&s3d_vertices[0],
+                                   vertex_count,
+                                   &c_indices[0],
+                                   index_count,
+                                   scm_to_vertex_type (v_type),
+                                   scm_to_primitive_type (p_type),
+                                   video::EIT_32BIT);
+  return SCM_UNSPECIFIED;
+}
+
+SCM
+IVideoDriver_endScene (SCM video_driver)
+{
+  video::IVideoDriver* driver = (video::IVideoDriver*) scm_to_irr_pointer (video_driver);
+  return scm_from_bool (driver->endScene ());
+}
+
+SCM
+IVideoDriver_getFPS (SCM video_driver)
+{
+  video::IVideoDriver* driver = (video::IVideoDriver*) scm_to_irr_pointer (video_driver);
+  return scm_from_int32 (driver->getFPS ());
+}
+
+SCM
+IVideoDriver_getName (SCM video_driver)
+{
+  video::IVideoDriver* driver = (video::IVideoDriver*) scm_to_irr_pointer (video_driver);
+  return scm_from_wide_char_string (driver->getName ());
+}
+
+SCM
+IVideoDriver_getTexture (SCM video_driver,
+                         SCM filename)
+{
+  video::IVideoDriver* driver = (video::IVideoDriver*) scm_to_irr_pointer (video_driver);
+  video::ITexture* texture = driver->getTexture (scm_to_utf8_string (filename));
+  return scm_from_pointer ((void*) texture, NULL);
+}
+
+SCM
+IVideoDriver_setMaterial (SCM video_driver,
+                          SCM material)
+{
+  video::IVideoDriver* driver = (video::IVideoDriver*) scm_to_irr_pointer (video_driver);
+  driver->setMaterial (*((video::SMaterial*) scm_to_irr_pointer (material)));
+  return SCM_UNSPECIFIED;
+}
+
+SCM
+IVideoDriver_setTransform (SCM video_driver,
+                           SCM state,
+                           SCM mat)
+{
+  video::IVideoDriver* driver = (video::IVideoDriver*) scm_to_irr_pointer (video_driver);
+  driver->setTransform (scm_to_transformation_state (state),
+                        scm_to_matrix4 (mat));
+  return SCM_UNSPECIFIED;
+}
+
+
+void
+init_video_driver (void)
+{
+  DEFINE_GSUBR ("IVideoDriver_beginScene", 6, 0, 0, IVideoDriver_beginScene);
+  DEFINE_GSUBR ("IVideoDriver_drawVertexPrimitiveList", 5, 0, 1,
+                IVideoDriver_drawVertexPrimitiveList);
+  DEFINE_GSUBR ("IVideoDriver_endScene", 1, 0, 0, IVideoDriver_endScene);
+  DEFINE_GSUBR ("IVideoDriver_getFPS", 1, 0, 0, IVideoDriver_getFPS);
+  DEFINE_GSUBR ("IVideoDriver_getName", 1, 0, 0, IVideoDriver_getName);
+  DEFINE_GSUBR ("IVideoDriver_getTexture", 2, 0, 0, IVideoDriver_getTexture);
+  DEFINE_GSUBR ("IVideoDriver_setMaterial", 2, 0, 0, IVideoDriver_setMaterial);
+  DEFINE_GSUBR ("IVideoDriver_setTransform", 3, 0, 0, IVideoDriver_setTransform);
+}
+
+video::E_TRANSFORMATION_STATE
+scm_to_transformation_state (SCM transformation_state)
+{
+  char* state = scm_to_utf8_string (scm_symbol_to_string (transformation_state));
+  if (!strcmp (state, "view"))
+    {
+      return video::ETS_VIEW;
+    }
+  else if (!strcmp (state, "world"))
+    {
+      return video::ETS_WORLD;
+    }
+  else if (!strcmp (state, "projection"))
+    {
+      return video::ETS_PROJECTION;
+    }
+  else if (!strcmp (state, "texture0"))
+    {
+      return video::ETS_TEXTURE_0;
+    }
+  else if (!strcmp (state, "texture1"))
+    {
+      return video::ETS_TEXTURE_1;
+    }
+  else if (!strcmp (state, "texture2"))
+    {
+      return video::ETS_TEXTURE_2;
+    }
+  else if (!strcmp (state, "texture3"))
+    {
+      return video::ETS_TEXTURE_3;
+    }
+  else
+    {
+      scm_error (scm_arg_type_key, NULL, "Wrong transformation state: ~S",
+                 scm_list_1 (transformation_state), scm_list_1 (transformation_state));
+    }
 }