3D viewer enhancements (better render + better vrml reader) from Mario Luzeiro

3d-viewer/3d_aux.cpp

@@ -57,13 +57,31 @@ void S3D_MASTER::ObjectCoordsTo3DUnits( std::vector< S3D_VERTEX >& aVertices )
 
         // adjust rotation
         if( m_MatRotation.x )
-            RotatePoint( &aVertices[ii].y, &aVertices[ii].z, m_MatRotation.x * 10 );
+        {
+            double a = aVertices[ii].y;
+            double b = aVertices[ii].z;
+            RotatePoint( &a, &b, m_MatRotation.x * 10 );
+            aVertices[ii].y = (float)a;
+            aVertices[ii].z = (float)b;
+        }
 
         if( m_MatRotation.y )
-            RotatePoint( &aVertices[ii].z, &aVertices[ii].x, m_MatRotation.y * 10 );
+        {
+            double a = aVertices[ii].z;
+            double b = aVertices[ii].x;
+            RotatePoint( &a, &b, m_MatRotation.x * 10 );
+            aVertices[ii].z = (float)a;
+            aVertices[ii].x = (float)b;
+        }
 
         if( m_MatRotation.z )
-            RotatePoint( &aVertices[ii].x, &aVertices[ii].y, m_MatRotation.z * 10 );
+        {
+            double a = aVertices[ii].x;
+            double b = aVertices[ii].y;
+            RotatePoint( &a, &b, m_MatRotation.x * 10 );
+            aVertices[ii].x = (float)a;
+            aVertices[ii].y = (float)b;
+        }
 
         /* adjust offset position (offset is given in UNIT 3D (0.1 inch) */
 #define SCALE_3D_CONV ((IU_PER_MILS * 1000) / UNITS3D_TO_UNITSPCB)

3d-viewer/3d_canvas.cpp

@@ -16,17 +16,21 @@
 
 #include <gestfich.h>
 
+#include <gl/glew.h>        // must be included before gl.h
+
 #include <3d_viewer.h>
 #include <3d_canvas.h>
 #include <info3d_visu.h>
 #include <trackball.h>
 #include <3d_viewer_id.h>
 
+#include <textures/text_silk.c>
+#include <textures/text_pcb.c>
 
 // -----------------
 // helper function (from wxWidgets, opengl/cube.cpp sample
 // -----------------
-void CheckGLError()
+void CheckGLError(const char *aFileName, int aLineNumber)
 {
     GLenum errLast = GL_NO_ERROR;
 
@@ -47,7 +51,7 @@ void CheckGLError()
 
         errLast = err;
 
-        wxLogError(wxT("OpenGL error %d"), err);
+        wxLogError( wxT( "OpenGL error %d\nAt: %s, line: %d" ), err, aFileName, aLineNumber );
     }
 }
 
@@ -78,6 +82,7 @@ EDA_3D_CANVAS::EDA_3D_CANVAS( EDA_3D_FRAME* parent, int* attribList ) :
                 wxFULL_REPAINT_ON_RESIZE )
 {
     m_init   = false;
+    m_shadow_init = false;
 
     // Clear all gl list identifiers:
     for( int ii = GL_ID_BEGIN; ii < GL_ID_END; ii++ )
@@ -490,15 +495,46 @@ void EDA_3D_CANVAS::OnEraseBackground( wxEraseEvent& event )
     // Do nothing, to avoid flashing.
 }
 
+typedef struct s_sImage
+{
+  unsigned int   width;
+  unsigned int   height;
+  unsigned int   bytes_per_pixel; /* 2:RGB16, 3:RGB, 4:RGBA */
+  unsigned char  pixel_data[64 * 64 * 4 + 1];
+}tsImage;
+
+
+GLuint load_and_generate_texture( tsImage *image )
+{
+
+    GLuint texture;
+    glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+    glPixelStorei (GL_PACK_ALIGNMENT, 1);
+
+    glGenTextures( 1, &texture );
+    glBindTexture( GL_TEXTURE_2D, texture );
+    gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, image->width, image->height, GL_RGBA, GL_UNSIGNED_BYTE, image->pixel_data );
+
+    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
+    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
+    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
+
+    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
+    return texture;
+}
 
 /* Initialize broad parameters for OpenGL */
 void EDA_3D_CANVAS::InitGL()
 {
-    wxSize size = GetClientSize();
-
     if( !m_init )
     {
         m_init = true;
+
+
+        m_text_pcb = load_and_generate_texture( (tsImage *)&text_pcb  );
+        m_text_silk = load_and_generate_texture( (tsImage *)&text_silk );
+
         g_Parm_3D_Visu.m_Zoom = 1.0;
         m_ZBottom = 1.0;
         m_ZTop = 10.0;
@@ -513,7 +549,7 @@ void EDA_3D_CANVAS::InitGL()
         glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
 
         // speedups
-        glEnable( GL_DITHER );
+        //glEnable( GL_DITHER );
         glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE );
         glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
         glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );
@@ -521,52 +557,7 @@ void EDA_3D_CANVAS::InitGL()
         // Initialize alpha blending function.
         glEnable( GL_BLEND );
         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
-}
-
-    // set viewing projection
-
-    glMatrixMode( GL_PROJECTION );
-    glLoadIdentity();
-
-#define MAX_VIEW_ANGLE 160.0 / 45.0
-    if( g_Parm_3D_Visu.m_Zoom > MAX_VIEW_ANGLE )
-        g_Parm_3D_Visu.m_Zoom = MAX_VIEW_ANGLE;
-
-     if( Parent()->ModeIsOrtho() )
-     {
-         // OrthoReductionFactor is chosen so as to provide roughly the same size as
-         // Perspective View
-         const double orthoReductionFactor = 400 / g_Parm_3D_Visu.m_Zoom;
-
-         // Initialize Projection Matrix for Ortographic View
-         glOrtho( -size.x / orthoReductionFactor, size.x / orthoReductionFactor,
-                  -size.y / orthoReductionFactor, size.y / orthoReductionFactor, 1, 10 );
     }
-     else
-     {
-         // Ratio width / height of the window display
-         double ratio_HV = (double) size.x / size.y;
-
-         // Initialize Projection Matrix for Perspective View
-         gluPerspective( 45.0 * g_Parm_3D_Visu.m_Zoom, ratio_HV, 1, 10 );
-     }
-
-
-    // position viewer
-    glMatrixMode( GL_MODELVIEW );
-    glLoadIdentity();
-    glTranslatef( 0.0F, 0.0F, -( m_ZBottom + m_ZTop) / 2 );
-
-    // clear color and depth buffers
-    glClearColor( g_Parm_3D_Visu.m_BgColor.m_Red,
-                  g_Parm_3D_Visu.m_BgColor.m_Green,
-                  g_Parm_3D_Visu.m_BgColor.m_Blue, 1 );
-    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
-
-    // Setup light sources:
-    SetLights();
-
-    CheckGLError();
 }
 
 
@@ -578,16 +569,19 @@ void EDA_3D_CANVAS::SetLights()
 
     /* set viewing projection */
     light_color[3] = 1.0;
-    GLfloat Z_axis_pos[4]    = { 0.0, 0.0, 3.0, 0.0 };
-    GLfloat lowZ_axis_pos[4] = { 0.0, 0.0, -3.0, 0.5 };
+    GLfloat Z_axis_pos[4]    = { 0.0, 0.0, 30.0, 0.0 };
+    GLfloat lowZ_axis_pos[4] = { 0.0, 0.0, -30.0, 0.5 };
 
     /* activate light */
     light = 1.0;
     light_color[0] = light_color[1] = light_color[2] = light;
     glLightfv( GL_LIGHT0, GL_POSITION, Z_axis_pos );
     glLightfv( GL_LIGHT0, GL_DIFFUSE, light_color );
-    light = 0.3;
-    light_color[0] = light_color[1] = light_color[2] = light;
+
+    light_color[0] = 0.3;
+    light_color[1] = 0.3;
+    light_color[2] = 0.4;
+
     glLightfv( GL_LIGHT1, GL_POSITION, lowZ_axis_pos );
     glLightfv( GL_LIGHT1, GL_DIFFUSE, light_color );
     glEnable( GL_LIGHT0 );      // White spot on Z axis
@@ -654,7 +648,6 @@ void EDA_3D_CANVAS::TakeScreenshot( wxCommandEvent& event )
                   viewport.x, viewport.y,
                   GL_ALPHA, GL_UNSIGNED_BYTE, alphabuffer );
 
-
     image.SetData( pixelbuffer );
     image.SetAlpha( alphabuffer );
     image = image.Mirror( false );

3d-viewer/3d_canvas.h

@@ -43,10 +43,11 @@
 #endif
 
 #include <3d_struct.h>
+#include <convert_basic_shapes_to_polygon.h>
  
 class BOARD_DESIGN_SETTINGS;
 class EDA_3D_FRAME;
-class S3D_VERTEX;
+
 class VIA;
 class D_PAD;
 
@@ -61,8 +62,14 @@ enum GL_LIST_ID
     GL_ID_BOARD,                // List id for copper layers
     GL_ID_TECH_LAYERS,          // List id for non copper layers (masks...)
     GL_ID_AUX_LAYERS,           // List id for user layers (draw, eco, comment)
-    GL_ID_3DSHAPES_SOLID,       // List id for 3D shapes, non transparent entities
-    GL_ID_3DSHAPES_TRANSP,      // List id for 3D shapes, transparent entities
+    GL_ID_3DSHAPES_SOLID_FRONT, // List id for 3D shapes, non transparent entities
+    GL_ID_3DSHAPES_TRANSP_FRONT,// List id for 3D shapes, transparent entities
+    GL_ID_3DSHAPES_SOLID_BACK, // List id for 3D shapes, non transparent entities
+    GL_ID_3DSHAPES_TRANSP_BACK,// List id for 3D shapes, transparent entities
+    GL_ID_SHADOW_FRONT,
+    GL_ID_SHADOW_BACK,
+    GL_ID_SHADOW_BOARD,
+    GL_ID_BODY,                // Body only list
     GL_ID_END
 };
 
@@ -76,6 +83,16 @@ private:
     double          m_ZBottom;          // position of the back layer
     double          m_ZTop;             // position of the front layer
 
+    GLuint          m_text_pcb;
+    GLuint          m_text_silk;
+
+    bool            m_shadow_init;
+    GLuint          m_text_fake_shadow_front;
+    GLuint          m_text_fake_shadow_back;
+    GLuint          m_text_fake_shadow_board;
+
+    void Create_and_Render_Shadow_Buffer( GLuint *aDst_gl_texture, GLuint aTexture_size, bool aDraw_body, int aBlurPasses );
+    
 public:
     EDA_3D_CANVAS( EDA_3D_FRAME* parent, int* attribList = 0 );
     ~EDA_3D_CANVAS();
@@ -122,6 +139,9 @@ public:
         m_draw3dOffset.x = aPosX;
         m_draw3dOffset.y = aPosY;
     }
+    void SetGLTechLayersColor( LAYER_NUM aLayer );
+    void SetGLCopperColor();
+    void SetGLEpoxyColor( double aTransparency = 1.0 );
 
     /**
      * Function BuildBoard3DView
@@ -129,7 +149,7 @@ public:
      * Populates the OpenGL GL_ID_BOARD draw list with board items only on copper layers.
      * 3D footprint shapes, tech layers and aux layers are not on this list
      */
-    void   BuildBoard3DView();
+    void   BuildBoard3DView(GLuint aBoardList, GLuint aBodyOnlyList);
 
     /**
      * Function BuildTechLayers3DView
@@ -138,6 +158,12 @@ public:
      */
     void   BuildTechLayers3DView();
 
+    /**
+     * Function BuildShadowList
+     * Called by CreateDrawGL_List()
+     */
+     void BuildShadowList( GLuint aFrontList, GLuint aBacklist, GLuint aBoardList );
+
     /**
      * Function BuildFootprintShape3DList
      * Called by CreateDrawGL_List()
@@ -148,7 +174,8 @@ public:
      * which need to be drawn after all other items
      */
     void   BuildFootprintShape3DList( GLuint aOpaqueList,
-                                      GLuint aTransparentList);
+                                      GLuint aTransparentList,
+                                      bool aSideToLoad );
     /**
      * Function BuildBoard3DAuxLayers
      * Called by CreateDrawGL_List()
@@ -163,7 +190,11 @@ public:
     void   Draw3DViaHole( const VIA * aVia );
     void   Draw3DPadHole( const D_PAD * aPad );
 
+    void   GenerateFakeShadowsTextures();
+
     DECLARE_EVENT_TABLE()
 };
 
+void CheckGLError(const char *aFileName, int aLineNumber);
+
 #endif  /*  _3D_CANVAS_H_ */

3d-viewer/3d_class.cpp

@@ -30,36 +30,6 @@
 
 #include <3d_viewer.h>
 
-S3D_MATERIAL::S3D_MATERIAL( S3D_MASTER* father, const wxString& name ) :
-    EDA_ITEM( father, NOT_USED )
-{
-    m_DiffuseColor.x   = m_DiffuseColor.y = m_DiffuseColor.z = 1.0;
-    m_SpecularColor.x  = m_SpecularColor.y = m_SpecularColor.z = 1.0;
-    m_AmbientIntensity = 1.0;
-    m_Transparency     = 0.0;
-    m_Shininess = 1.0;
-    m_Name = name;
-}
-
-void S3D_MATERIAL::SetMaterial()
-{
-    S3D_MASTER * s3dParent = (S3D_MASTER *) GetParent();
-    s3dParent->SetLastTransparency( m_Transparency );
-
-    if( ! s3dParent->IsOpenGlAllowed() )
-        return;
-
-    glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
-    glColor4f( m_DiffuseColor.x * m_AmbientIntensity,
-               m_DiffuseColor.y * m_AmbientIntensity,
-               m_DiffuseColor.z * m_AmbientIntensity,
-               1.0 - m_Transparency );
-#if 0
-    glColorMaterial( GL_FRONT_AND_BACK, GL_SPECULAR );
-    glColor3f( m_SpecularColor.x, m_SpecularColor.y, m_SpecularColor.z );
-    glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
-#endif
-}
 
 bool S3D_MASTER::IsOpenGlAllowed()
 {
@@ -68,9 +38,12 @@ bool S3D_MASTER::IsOpenGlAllowed()
         if( m_lastTransparency == 0.0 )
             return true;
     }
+
     if( m_loadTransparentObjects )      // return true for transparent objects only
+    {
         if( m_lastTransparency != 0.0 )
             return true;
+    }
 
     return false;
 }
@@ -102,6 +75,13 @@ S3D_MASTER::S3D_MASTER( EDA_ITEM* aParent ) :
     m_3D_Drawings = NULL;
     m_Materials   = NULL;
     m_ShapeType   = FILE3D_NONE;
+
+    m_use_modelfile_diffuseColor = true;
+    m_use_modelfile_emissiveColor = false;
+    m_use_modelfile_specularColor = false;
+    m_use_modelfile_ambientIntensity = false;
+    m_use_modelfile_transparency = true;
+    m_use_modelfile_shininess = false;
 }
 
 

3d-viewer/3d_draw_basic_functions.cpp

@@ -33,10 +33,7 @@
 #include <3d_viewer.h>
 #include <info3d_visu.h>
 #include <3d_draw_basic_functions.h>
-
-// Imported function:
-extern void TransfertToGLlist( std::vector<S3D_VERTEX>& aVertices, double aBiuTo3DUnits );
-extern void CheckGLError();
+#include <modelparsers.h>
 
 // Number of segments to approximate a circle by segments
 #define SEGM_PER_CIRCLE 16
@@ -62,6 +59,7 @@ static inline void SetNormalZneg()
     glNormal3f( 0.0, 0.0, -1.0 );
 }
 
+void TransfertToGLlist( std::vector< S3D_VERTEX >& aVertices, double aBiuTo3DUnits );
 
 /* Draw3D_VerticalPolygonalCylinder is a helper function.
  *
@@ -132,6 +130,15 @@ void SetGLColor( EDA_COLOR_T color, double alpha )
     glColor4f( red, green, blue, alpha );
 }
 
+static float m_texture_scale;
+
+void SetGLTexture( GLuint text_id, float scale )
+{
+    glEnable( GL_TEXTURE_2D );
+    glBindTexture( GL_TEXTURE_2D, text_id );
+    m_texture_scale = scale;
+}
+
 
 /* draw all solid polygons found in aPolysList
  * aZpos = z position in board internal units
@@ -152,9 +159,9 @@ void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList,
     gluTessCallback( tess, GLU_TESS_VERTEX, ( void (CALLBACK*) () )tessCPolyPt2Vertex );
 
     GLdouble    v_data[3];
-    double      zpos = ( aZpos + (aThickness / 2) ) * aBiuTo3DUnits;
+    double      zpos = ( aZpos + (aThickness / 2.0) ) * aBiuTo3DUnits;
     g_Parm_3D_Visu.m_CurrentZpos = zpos;
-    v_data[2] = aZpos + (aThickness / 2);
+    v_data[2] = aZpos + (aThickness / 2.0);
 
     // Set normal to toward positive Z axis, for a solid object only (to draw the top side)
     if( aThickness )
@@ -198,7 +205,7 @@ void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList,
             break;
 
         // Prepare the bottom side of solid areas
-        zpos = ( aZpos - (aThickness / 2) ) * aBiuTo3DUnits;
+        zpos = ( aZpos - (aThickness / 2.0) ) * aBiuTo3DUnits;
         g_Parm_3D_Visu.m_CurrentZpos = zpos;
         v_data[2] = zpos;
         // Now;, set normal to toward negative Z axis, for the solid object bottom side
@@ -211,7 +218,7 @@ void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList,
         return;
 
     // Build the 3D data : vertical side
-    Draw3D_VerticalPolygonalCylinder( polylist, aThickness, aZpos - (aThickness / 2), false, aBiuTo3DUnits );
+    Draw3D_VerticalPolygonalCylinder( polylist, aThickness, aZpos - (aThickness / 2.0), false, aBiuTo3DUnits );
 }
 
 
@@ -400,6 +407,12 @@ void CALLBACK tessCPolyPt2Vertex( const GLvoid* data )
     // cast back to double type
     const CPolyPt* ptr = (const CPolyPt*) data;
 
+    if( g_Parm_3D_Visu.IsRealisticMode() && g_Parm_3D_Visu.HightQualityMode() )
+    {
+        glTexCoord2f( ptr->x* g_Parm_3D_Visu.m_BiuTo3Dunits * m_texture_scale,
+                    -ptr->y * g_Parm_3D_Visu.m_BiuTo3Dunits * m_texture_scale);
+    }
+
     glVertex3d( ptr->x * g_Parm_3D_Visu.m_BiuTo3Dunits,
                 -ptr->y * g_Parm_3D_Visu.m_BiuTo3Dunits,
                 g_Parm_3D_Visu.m_CurrentZpos );

3d-viewer/3d_draw_basic_functions.h

@@ -126,4 +126,12 @@ void    Draw3D_ZaxisOblongCylinder( wxPoint aAxis1Pos, wxPoint aAxis2Pos,
 void SetGLColor( EDA_COLOR_T aColor, double aTransparency = 1.0 );
 
 
+/**
+ * Set a texture id and a scale to apply when rendering the polygons
+ * @param text_id = texture ID created by glGenTextures
+ * @param scale = scale to apply to texture coords
+ */
+void SetGLTexture( GLuint text_id, float scale );
+
+
 #endif      // _3D_DRAW_BASIC_FUNCTIONS_H_

3d-viewer/3d_frame.cpp

@@ -107,7 +107,8 @@ EDA_3D_FRAME::EDA_3D_FRAME( KIWAY* aKiway, PCB_BASE_FRAME* aParent,
     ReCreateMainToolbar();
 
     // Make a EDA_3D_CANVAS
-    int attrs[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_DEPTH_SIZE, 16, 0 };
+    int attrs[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_DEPTH_SIZE, 16,
+                    WX_GL_STENCIL_SIZE, 1, 0 };
     m_canvas = new EDA_3D_CANVAS( this, attrs );
 
     m_auimgr.SetManagedWindow( this );

3d-viewer/3d_material.cpp

+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2014 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2012 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+/**
+ * @file 3d_class.cpp
+ */
+
+#include <fctsys.h>
+#include <3d_struct.h>
+#include <3d_material.h>
+
+#ifdef __WXMAC__
+#  ifdef __DARWIN__
+#    include <OpenGL/glu.h>
+#  else
+#    include <glu.h>
+#  endif
+#else
+#  include <GL/glu.h>
+#endif
+
+S3D_MATERIAL::S3D_MATERIAL( S3D_MASTER* father, const wxString& name ) :
+    EDA_ITEM( father, NOT_USED )
+{
+    m_Name = name;
+    m_AmbientColor.clear();
+    m_DiffuseColor.clear();
+    m_EmissiveColor.clear();
+    m_SpecularColor.clear();
+    m_Shininess.clear();
+    m_Transparency.clear();
+}
+
+
+void SetOpenGlDefaultMaterial()
+{
+    glm::vec4 ambient( 0.2, 0.2, 0.2, 1.0 );
+    glm::vec4 specular( 0.1, 0.1, 0.1, 1.0 );
+    glm::vec4 emissive( 0.1, 0.1, 0.1, 1.0 );
+    GLint shininess_value = 100;
+
+    glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
+    //glColor4f( 1.0, 1.0, 1.0, 1.0 );
+    glMateriali ( GL_FRONT_AND_BACK, GL_SHININESS, shininess_value );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.x );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.x );
+    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT,  &ambient.x );
+
+}
+
+
+void S3D_MATERIAL::SetOpenGLMaterial( unsigned int materialIndex )
+{
+    S3D_MASTER * s3dParent = (S3D_MASTER *) GetParent();
+    
+    if( ! s3dParent->IsOpenGlAllowed() )
+        return;
+
+    float transparency_value = 0.0f;
+    if( m_Transparency.size() > materialIndex )
+    {
+        transparency_value = m_Transparency[materialIndex];
+        s3dParent->SetLastTransparency( transparency_value );
+    }
+
+    if( m_DiffuseColor.size() > materialIndex )            
+    {
+        glm::vec3 color = m_DiffuseColor[materialIndex];
+
+        if( m_AmbientColor.size() == 0 )
+        {
+            glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
+        }
+        
+        glColor4f( color.x, color.y, color.z, 1.0 - transparency_value );
+    }
+
+    if( m_Shininess.size() > materialIndex )
+    {
+        glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, m_Shininess[materialIndex] );
+    }
+
+    // emissive
+    if( m_EmissiveColor.size() > materialIndex )
+    {
+        glm::vec4 emissive;
+        emissive[0] = m_EmissiveColor[materialIndex].x;
+        emissive[1] = m_EmissiveColor[materialIndex].y;
+        emissive[2] = m_EmissiveColor[materialIndex].z;
+        emissive[3] = 1.0f;
+        glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.x );
+    }
+
+    // specular
+    if( m_SpecularColor.size() > materialIndex )
+    {
+        glm::vec4 specular;
+        specular[0] = m_SpecularColor[materialIndex].x;
+        specular[1] = m_SpecularColor[materialIndex].y;
+        specular[2] = m_SpecularColor[materialIndex].z;
+        specular[3] = 1.0f;
+        glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.x );
+    }
+
+    // ambient
+    if( m_AmbientColor.size() > materialIndex )
+    {
+        glm::vec4 ambient;
+        ambient[0] = m_AmbientColor[materialIndex].x;
+        ambient[1] = m_AmbientColor[materialIndex].y;
+        ambient[2] = m_AmbientColor[materialIndex].z;
+        ambient[3] = 1.0f;
+        glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT,  &ambient.x );
+    }    
+}
+

3d-viewer/3d_material.h

+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2014 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2014 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_material.h
+ */
+
+#ifndef STRUCT_3D_MATERIAL_H
+#define STRUCT_3D_MATERIAL_H
+
+#include <common.h>
+#include <base_struct.h>
+#include <gal/opengl/glm/glm.hpp>
+
+class S3D_MASTER;
+
+class S3D_MATERIAL : public EDA_ITEM       /* openGL "material" data*/
+{
+public:
+    wxString   m_Name;
+    
+    // Material list
+    std::vector< glm::vec3 > m_AmbientColor;
+    std::vector< glm::vec3 > m_DiffuseColor;
+    std::vector< glm::vec3 > m_EmissiveColor;
+    std::vector< glm::vec3 > m_SpecularColor;
+    std::vector< float > m_Shininess;
+    std::vector< float > m_Transparency;
+
+public:
+    S3D_MATERIAL( S3D_MASTER* father, const wxString& name );
+
+    S3D_MATERIAL* Next() const { return (S3D_MATERIAL*) Pnext; }
+    S3D_MATERIAL* Back() const { return (S3D_MATERIAL*) Pback; }
+
+    void SetOpenGLMaterial(unsigned int materialIndex);
+
+#if defined(DEBUG)
+    void Show( int nestLevel, std::ostream& os ) const { ShowDummy( os ); } // override
+#endif
+};
+
+void SetOpenGlDefaultMaterial();
+
+#endif

3d-viewer/3d_mesh_model.h

+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2014 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2014 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file 3d_mesh_model.h
+ * @brief 
+ */
+
+#ifndef __3D_MESH_MODEL_H__
+#define __3D_MESH_MODEL_H__
+
+#include <fctsys.h>
+#include <common.h>
+#include <macros.h>
+#include <base_struct.h>
+#include <gal/opengl/glm/glm.hpp>
+#include <vector>
+#include <kicad_string.h>
+#include <info3d_visu.h>
+#ifdef __WXMAC__
+#  ifdef __DARWIN__
+#    include <OpenGL/glu.h>
+#  else
+#    include <glu.h>
+#  endif
+#else
+#  include <GL/glu.h>
+#endif
+#include <wx/glcanvas.h>
+
+class S3D_MESH;
+
+class S3D_MESH
+{
+public:
+
+    S3D_MESH();
+    ~S3D_MESH();
+
+    void openGL_Render();
+    void openGL_RenderAllChilds();
+
+    S3D_MATERIAL    *m_Materials;
+
+    // Point and index list
+    std::vector< glm::vec3 > m_Point;
+    std::vector< std::vector<int> > m_CoordIndex;
+    std::vector< glm::vec3 > m_PerFaceNormalsNormalized;
+    std::vector< glm::vec3 > m_PerVertexNormalsNormalized;
+
+    std::vector< int > m_MaterialIndex;
+
+    glm::vec3 m_translation;
+    glm::vec4 m_rotation;
+    glm::vec3 m_scale;
+    glm::vec4 m_scaleOrientation; // not used
+    glm::vec3 m_center; // not used
+
+    std::vector<S3D_MESH *> childs;
+
+private:
+    std::vector< glm::vec3 > m_PerFaceNormalsRaw;
+    std::vector< std::vector< glm::vec3 > > m_PerFaceVertexNormals;
+    std::vector< glm::vec3 > m_PointNormalized;
+    std::vector< float > m_PerFaceSquaredArea;
+    std::vector< std::vector<int> > m_InvalidCoordIndexes; //!TODO: check for invalid CoordIndex in file and remove the index and the same material index
+
+    bool isPerFaceNormalsComputed;
+    void calcPerFaceNormals ();
+
+    bool isPointNormalizedComputed;
+    void calcPointNormalized();
+
+    bool isPerPointNormalsComputed;
+    void calcPerPointNormals();
+};
+
+
+#endif

3d-viewer/3d_struct.h

 /*
  * This program source code file is part of KiCad, a free EDA CAD application.
  *
+ * Copyright (C) 2014 Mario Luzeiro <mrluzeiro@gmail.com>
  * Copyright (C) 2004 Jean-Pierre Charras, jaen-pierre.charras@gipsa-lab.inpg.com
  * Copyright (C) 2011 Wayne Stambaugh <stambaughw@verizon.net>
  * Copyright (C) 1992-2011 KiCad Developers, see AUTHORS.txt for contributors.
@@ -32,7 +33,8 @@
 
 #include <common.h>
 #include <base_struct.h>
-
+#include <3d_material.h>
+#include <gal/opengl/glm/glm.hpp>
  
 /* 3D modeling units -> PCB units conversion scale:
  * 1 "3D model unit" wings3d = 1 unit = 2.54 mm = 0.1 inch = 100 mils
@@ -44,48 +46,7 @@ class S3D_MASTER;
 class STRUCT_3D_SHAPE;
 
 /*  S3D_VERTEX manages a 3D coordinate (3 float numbers: x,y,z coordinates)*/
-class S3D_VERTEX
-{
-public:
-    double x, y, z;
-
-public:
-    S3D_VERTEX()
-    {
-        x = y = z = 0.0;
-    }
-
-    S3D_VERTEX( double px, double py, double pz)
-    {
-        x = px;
-        y = py;
-        z = pz;
-    }
-};
-
-class S3D_MATERIAL : public EDA_ITEM       /* openGL "material" data*/
-{
-public:
-    wxString   m_Name;
-    S3D_VERTEX m_DiffuseColor;
-    S3D_VERTEX m_EmissiveColor;
-    S3D_VERTEX m_SpecularColor;
-    float      m_AmbientIntensity;
-    float      m_Transparency;
-    float      m_Shininess;
-
-public:
-    S3D_MATERIAL( S3D_MASTER* father, const wxString& name );
-
-    S3D_MATERIAL* Next() const { return (S3D_MATERIAL*) Pnext; }
-    S3D_MATERIAL* Back() const { return (S3D_MATERIAL*) Pback; }
-
-    void SetMaterial();
-
-#if defined(DEBUG)
-    void Show( int nestLevel, std::ostream& os ) const { ShowDummy( os ); } // override
-#endif
-};
+#define S3D_VERTEX glm::vec3
 
 
 /* Master structure for a 3D item description */
@@ -106,6 +67,14 @@ public:
         FILE3D_UNKNOWN
     };
 
+    // Check defaults in S3D_MASTER
+    bool        m_use_modelfile_diffuseColor;
+    bool        m_use_modelfile_emissiveColor;
+    bool        m_use_modelfile_specularColor;
+    bool        m_use_modelfile_ambientIntensity;
+    bool        m_use_modelfile_transparency;
+    bool        m_use_modelfile_shininess;
+
 private:
     wxString    m_Shape3DName;  /* 3D shape name in 3D library */
     FILE3D_TYPE m_ShapeType;
@@ -114,6 +83,8 @@ private:
     bool        m_loadTransparentObjects;
     bool        m_loadNonTransparentObjects;
 
+
+
 public:
     S3D_MASTER( EDA_ITEM* aParent );
     ~S3D_MASTER();

3d-viewer/CMakeLists.txt

@@ -2,6 +2,7 @@ add_definitions(-DPCBNEW)
 
 include_directories(BEFORE ${INC_BEFORE})
 include_directories(
+    textures
     ../pcbnew
     ../polygon
     ${INC_AFTER}
@@ -16,12 +17,17 @@ set(3D-VIEWER_SRCS
     3d_draw.cpp
     3d_draw_basic_functions.cpp
     3d_frame.cpp
+    3d_material.cpp
+    3d_mesh_model.cpp
     3d_read_mesh.cpp
     3d_toolbar.cpp
     info3d_visu.cpp
     trackball.cpp
-    x3dmodelparser.cpp
     vrmlmodelparser.cpp
+    vrml_aux.cpp
+    vrml_v1_modelparser.cpp
+    vrml_v2_modelparser.cpp
+    x3dmodelparser.cpp
     )
 
 add_library(3d-viewer STATIC ${3D-VIEWER_SRCS})

3d-viewer/info3d_visu.cpp

@@ -85,7 +85,7 @@ INFO3D_VISU::~INFO3D_VISU()
  */
 void INFO3D_VISU::InitSettings( BOARD* aBoard )
 {
-    EDA_RECT bbbox = aBoard->ComputeBoundingBox( false );
+    EDA_RECT bbbox = aBoard->ComputeBoundingBox( true );
 
     if( bbbox.GetWidth() == 0 && bbbox.GetHeight() == 0 )
     {
@@ -93,6 +93,7 @@ void INFO3D_VISU::InitSettings( BOARD* aBoard )
         bbbox.SetHeight( Millimeter2iu( 100 ) );
     }
 
+
     m_BoardSettings = &aBoard->GetDesignSettings();
 
     m_BoardSize = bbbox.GetSize();
@@ -199,8 +200,8 @@ void INFO3D_VISU::InitSettings( BOARD* aBoard )
 double INFO3D_VISU::GetModulesZcoord3DIU( bool aIsFlipped )
 {
     if(  aIsFlipped )
-        return m_layerZcoord[B_Cu] - ( m_copperThickness / 2 );
+        return m_layerZcoord[B_Paste] - ( m_copperThickness / 2 ); //B_Cu NOTE: in order to display modules in top of Paste and near the shadow
     else
-        return m_layerZcoord[F_Cu] + ( m_copperThickness / 2 );
+        return m_layerZcoord[F_Paste] + ( m_copperThickness / 2 ); //F_Cu
 }
 

3d-viewer/info3d_visu.h

@@ -95,6 +95,9 @@ public:
                                                     // to scale 3D units between -1.0 and +1.0
     double  m_CurrentZpos;                          // temporary storage of current value of Z position,
                                                     // used in some calculation
+
+    double zpos_offset;
+    
 private:
     double  m_layerZcoord[LAYER_ID_COUNT];          // Z position of each layer (normalized)
     double  m_copperThickness;                      // Copper thickness (normalized)

3d-viewer/modelparsers.h

@@ -32,13 +32,9 @@
 #include <map>
 #include <vector>
 #include <wx/string.h>
-
+#include <3d_mesh_model.h>
 
 class S3D_MASTER;
-class S3D_VERTEX;
-
-extern void TransfertToGLlist( std::vector< S3D_VERTEX >& aVertices, double aBiuTo3DUnits );
-
 class S3D_MODEL_PARSER;
 class X3D_MODEL_PARSER;
 
@@ -118,13 +114,17 @@ public:
     static void GetNodeProperties( wxXmlNode* aNode, PROPERTY_MAP& aProps );
 
     /**
-     * Return string representing x3d file in vrml format
+     * Return string representing x3d file in vrml2 format
      * Function Load must be called before this function, otherwise empty
      * data set is returned.
      */
-    wxString VRML_representation();
+    wxString VRML2_representation();
 
 private:
+    wxString m_Filename;
+    S3D_MESH *m_model;
+    std::vector<S3D_MESH *> childs;
+
     std::vector< wxString > vrml_materials;
     std::vector< wxString > vrml_points;
     std::vector< wxString > vrml_coord_indexes;
@@ -137,57 +137,110 @@ private:
     void rotate( S3D_VERTEX& aCoordinate, S3D_VERTEX& aRotAxis, double angle );
 };
 
+
+
 /**
- * class WRL_MODEL_PARSER
+ * class VRML2_MODEL_PARSER
  * Parses
  */
-class VRML_MODEL_PARSER: public S3D_MODEL_PARSER
+class VRML2_MODEL_PARSER: public S3D_MODEL_PARSER
 {
 public:
-    VRML_MODEL_PARSER( S3D_MASTER* aMaster );
-    ~VRML_MODEL_PARSER();
+    VRML2_MODEL_PARSER( S3D_MASTER* aMaster );
+    ~VRML2_MODEL_PARSER();
     void Load( const wxString aFilename );
 
-private:
     /**
-     * Function ReadMaterial
-     * read the description of a 3D material definition in the form:
-     * DEF yellow material Material (
-     * DiffuseColor 1.00000 1.00000 0.00000e 0
-     * EmissiveColor 0.00000e 0 0.00000e 0 0.00000e 0
-     * SpecularColor 1.00000 1.00000 1.00000
-     * AmbientIntensity 1.00000
-     * Transparency 0.00000e 0
-     * Shininess 1.00000
-     *)
-     * Or type:
-     * USE yellow material
+     * Return string representing VRML2 file in vrml2 format
+     * Function Load must be called before this function, otherwise empty
+     * data set is returned.
+     */
+    wxString VRML2_representation();
+
+private:
+    int read_Transform();
+    int read_DEF();
+    int read_Shape();
+    int read_Appearance();
+    int read_material();
+    int read_Material();
+    int read_IndexedFaceSet();
+    int read_Coordinate();
+    int read_Normal();
+    int read_Color();
+    int read_coordIndex();
+    int read_colorIndex();
+
+    bool m_normalPerVertex;
+    bool colorPerVertex;
+    S3D_MESH *m_model;
+    std::vector<S3D_MESH *> childs;
+    FILE *m_file;
+    S3D_MATERIAL *m_Materials;
+    wxString m_Filename;
+};
+
+
+/**
+ * class VRML1_MODEL_PARSER
+ * Parses
  */
-    int readMaterial( FILE* file, int* LineNum );
-    int readChildren( FILE* file, int* LineNum );
-    int readShape( FILE* file, int* LineNum );
-    int readAppearance( FILE* file, int* LineNum );
-    int readGeometry( FILE* file, int* LineNum );
+class VRML1_MODEL_PARSER: public S3D_MODEL_PARSER
+{
+public:
+    VRML1_MODEL_PARSER( S3D_MASTER* aMaster );
+    ~VRML1_MODEL_PARSER();
+    void Load( const wxString aFilename );
 
     /**
-     * Function ReadCoordList
-     * reads 3D coordinate lists like:
-     *      coord Coordinate { point [
-     *        -5.24489 6.57640e-3 -9.42129e-2,
-     *        -5.11821 6.57421e-3 0.542654,
-     *        -3.45868 0.256565 1.32000 ] }
-     *  or:
-     *  normal Normal { vector [
-     *        0.995171 -6.08102e-6 9.81541e-2,
-     *        0.923880 -4.09802e-6 0.382683,
-     *        0.707107 -9.38186e-7 0.707107]
-     *      }
-     *
-     *  text_buffer contains the first line of this node :
-     *     "coord Coordinate { point ["
+     * Return string representing VRML2 file in vrml2 format
+     * Function Load must be called before this function, otherwise empty
+     * data set is returned.
      */
-    void readCoordsList( FILE* file, char* text_buffer, std::vector< double >& aList,
-                         int* LineNum );
+    wxString VRML2_representation();
+
+private:
+    int read_separator();
+    int readMaterial();
+    int readCoordinate3();
+    int readIndexedFaceSet();
+
+    int readMaterial_ambientColor();
+    int readMaterial_diffuseColor();
+    int readMaterial_emissiveColor();
+    int readMaterial_specularColor();
+    int readMaterial_shininess();
+    int readMaterial_transparency();
+
+    int readCoordinate3_point();
+
+    int readIndexedFaceSet_coordIndex();
+    int readIndexedFaceSet_materialIndex();
+
+    bool m_normalPerVertex;
+    bool colorPerVertex;
+    S3D_MESH *m_model;
+    std::vector<S3D_MESH *> childs;
+    S3D_MATERIAL *m_Materials;
+    FILE *m_file;
+    wxString m_Filename;
 };
 
+/**
+ * class VRML_MODEL_PARSER
+ * Parses
+ */
+class VRML_MODEL_PARSER: public S3D_MODEL_PARSER
+{
+public:
+    VRML_MODEL_PARSER( S3D_MASTER* aMaster );
+    ~VRML_MODEL_PARSER();
+    void Load( const wxString aFilename );
+
+private:
+    VRML1_MODEL_PARSER *vrml1_parser;
+    VRML2_MODEL_PARSER *vrml2_parser;
+};
+
+
 #endif // MODELPARSERS_H

3d-viewer/vrml_aux.cpp

+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2014 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2014 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file vrml_aux.cpp
+ */
+
+#include "vrml_aux.h"
+
+char SkipGetChar ( FILE* File )
+{
+    char c;
+    bool re_parse;
+
+    if( (c = fgetc( File )) == EOF )
+    {
+        //DBG( printf( "EOF\n" ) );
+        return EOF;
+    }
+
+    //DBG( printf( "c %c 0x%02X\n", c, c ) );
+
+    do
+    {
+        re_parse = false;
+
+        if ((c == ' ') || (c == '\t') || (c == '{') || (c == '['))
+        {
+            //DBG( printf( "Skipping space \\t or { or [\n" ) );
+            do
+            {
+                if( (c = fgetc( File )) == EOF )
+                {
+                     //DBG( printf( "EOF\n" ) );
+
+                    return EOF;
+                }
+            }
+            while((c == ' ') || (c == '\t') || (c == '{') || (c == '['));
+        }
+
+        if ((c == '#') || (c == '\n') ||  (c == '\r') || (c == 0) || (c == ','))
+        {
+            if (c == '#')
+            {
+                //DBG( printf( "Skipping # \\n or \\r or 0, 0x%02X\n", c ) );
+                do
+                {
+                    if( (c = fgetc( File )) == EOF )
+                    {
+                        //DBG( printf( "EOF\n" ) );
+                        return EOF;
+                    }
+                }
+                while((c != '\n') &&  (c != '\r') && (c != 0) && (c != ','));
+            }
+            else
+            {
+                if( (c = fgetc( File )) == EOF )
+                {
+                    //DBG( printf( "EOF\n" ) );
+                    return EOF;
+                }
+            }
+
+            re_parse = true;
+        }
+    }while(re_parse == true);
+
+    return c;
+}
+
+
+char* GetNextTag( FILE* File, char* tag )
+{
+
+    char c = SkipGetChar( File );
+
+    if (c == EOF)
+    {
+        return NULL;
+    }
+    tag[0] = c;
+    tag[1] = 0;
+    //DBG( printf( "tag[0] %c\n", tag[0] ) );
+    if( (c != '}') && (c != ']') )
+    {
+        char *dst = &tag[1];
+        while (fscanf( File, "%c",  dst))
+        {
+            if( (*dst == ' ') || (*dst == '[') || (*dst == '{') || (*dst == '\t') || (*dst == '\n')|| (*dst == '\r') )
+            {
+                *dst = 0;
+                break;
+            }
+            dst++;
+        }
+
+
+        //DBG( printf( "tag %s\n", tag ) );
+        c = SkipGetChar( File );
+
+        if (c != EOF)
+        {
+            // Puts again the read char in the buffer
+            ungetc( c, File );
+        }
+    }
+
+    return tag;
+}
+
+
+int read_NotImplemented( FILE* File, char closeChar)
+{
+    char c;
+    //DBG( printf( "look for %c\n", closeChar) );
+    while( (c = fgetc( File )) != EOF )
+    {
+        if( c == '{' )
+        {
+            //DBG( printf( "{\n") );
+            read_NotImplemented( File, '}' );
+        } else if( c == '[' )
+        {
+            //DBG( printf( "[\n") );
+            read_NotImplemented( File, ']' );
+        } else if( c == closeChar )
+        {
+            //DBG( printf( "%c\n", closeChar) );
+            return 0;
+        }
+    }
+
+    DBG( printf( "  NotImplemented failed\n" ) );
+    return -1;
+}
+
+
+int parseVertexList( FILE* File, std::vector< glm::vec3 > &dst_vector)
+{
+    //DBG( printf( "      parseVertexList\n" ) );
+
+    dst_vector.clear();
+
+    glm::vec3 vertex;
+    while( parseVertex ( File, vertex ) == 3 )
+    {
+        dst_vector.push_back( vertex );
+    }
+
+    return 0;
+}
+
+
+int parseVertex( FILE* File, glm::vec3 &dst_vertex )
+{
+    float a,b,c;
+    int ret = fscanf( File, "%e %e %e", &a, &b, &c );
+
+    dst_vertex.x = a;
+    dst_vertex.y = b;
+    dst_vertex.z = c;
+
+    char s = SkipGetChar( File );
+
+    if (s != EOF)
+    {
+        // Puts again the read char in the buffer
+        ungetc( s, File );
+    }
+    //DBG( printf( "ret%d(%.9f,%.9f,%.9f)", ret, a,b,c) );
+
+    return ret;
+}
+
+
+int parseFloat( FILE* File, float *dst_float )
+{
+    float value;
+    int ret = fscanf( File, "%e", &value );
+    *dst_float = value;
+
+    return ret;
+}

3d-viewer/vrml_aux.h

+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2014 Mario Luzeiro <mrluzeiro@gmail.com>
+ * Copyright (C) 1992-2014 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file vrml_aux.h
+ */
+
+#ifndef _VRML_AUX_H
+#define _VRML_AUX_H
+
+#include <fctsys.h>
+#include <common.h>
+#include <macros.h>
+#include <base_struct.h>
+#include <gal/opengl/glm/glm.hpp>
+#include <vector>
+#include <kicad_string.h>
+#include <info3d_visu.h>
+#ifdef __WXMAC__
+#  ifdef __DARWIN__
+#    include <OpenGL/glu.h>
+#  else
+#    include <glu.h>
+#  endif
+#else
+#  include <GL/glu.h>
+#endif
+#include <wx/glcanvas.h>
+
+int read_NotImplemented( FILE* File, char closeChar);
+char SkipGetChar ( FILE* File );
+int parseVertexList( FILE* File, std::vector< glm::vec3 > &dst_vector);
+int parseVertex( FILE* File, glm::vec3 &dst_vertex );
+int parseFloat( FILE* File, float *dst_float );
+char* GetNextTag( FILE* File, char* tag );
+
+#endif

pcbnew/block_module_editor.cpp

@@ -144,6 +144,7 @@ bool FOOTPRINT_EDIT_FRAME::HandleBlockEnd( wxDC* DC )
         break;
 
     case BLOCK_DRAG:        // Drag
+    case BLOCK_DRAG_ITEM:   // Drag a given item (not used here)
     case BLOCK_MOVE:        // Move
     case BLOCK_COPY:        // Copy
         itemsCount = MarkItemsInBloc( currentModule, GetScreen()->m_BlockLocate );

pcbnew/class_module.h

@@ -281,11 +281,13 @@ public:
      * @param glcanvas = the openGL canvas
      * @param  aAllowNonTransparentObjects = true to load non transparent objects
      * @param  aAllowTransparentObjects = true to load non transparent objects
+     * @param  aSideToLoad = false will load not fliped, true will load fliped objects
      * in openGL, transparent objects should be drawn *after* non transparent objects
      */
     void ReadAndInsert3DComponentShape( EDA_3D_CANVAS* glcanvas,
                                         bool aAllowNonTransparentObjects,
-                                        bool aAllowTransparentObjects );
+                                        bool aAllowTransparentObjects,
+                                        bool aSideToLoad );
 
     /**
      * function TransformPadsShapesWithClearanceToPolygon

pcbnew/exporters/export_vrml.cpp

@@ -1325,7 +1325,7 @@ static void export_vrml_module( MODEL_VRML& aModel, BOARD* aPcb, MODULE* aModule
                 try
                 {
                     aOutputFile << "  children [\n ";
-                    aOutputFile << TO_UTF8( parser->VRML_representation() ) << " ]\n";
+                    aOutputFile << TO_UTF8( parser->VRML2_representation() ) << " ]\n";
                     aOutputFile << "  }\n";
                 }
                 catch( const std::exception& e )

pcbnew/legacy_plugin.cpp

@@ -1936,7 +1936,7 @@ void LEGACY_PLUGIN::load3D( MODULE* aModule )
 
         else if( TESTLINE( "Sc" ) )     // Scale
         {
-            sscanf( line + SZ( "Sc" ), "%lf %lf %lf\n",
+            sscanf( line + SZ( "Sc" ), "%f %f %f\n",
                     &t3D->m_MatScale.x,
                     &t3D->m_MatScale.y,
                     &t3D->m_MatScale.z );
@@ -1944,7 +1944,7 @@ void LEGACY_PLUGIN::load3D( MODULE* aModule )
 
         else if( TESTLINE( "Of" ) )     // Offset
         {
-            sscanf( line + SZ( "Of" ), "%lf %lf %lf\n",
+            sscanf( line + SZ( "Of" ), "%f %f %f\n",
                     &t3D->m_MatPosition.x,
                     &t3D->m_MatPosition.y,
                     &t3D->m_MatPosition.z );
@@ -1952,7 +1952,7 @@ void LEGACY_PLUGIN::load3D( MODULE* aModule )
 
         else if( TESTLINE( "Ro" ) )     // Rotation
         {
-            sscanf( line + SZ( "Ro" ), "%lf %lf %lf\n",
+            sscanf( line + SZ( "Ro" ), "%f %f %f\n",
                     &t3D->m_MatRotation.x,
                     &t3D->m_MatRotation.y,
                     &t3D->m_MatRotation.z );