← Back to branch summary

~ubuntu-branches/ubuntu/utopic/sweethome3d/utopic

« back to all changes in this revision

Viewing changes to src/com/eteks/sweethome3d/j3d/PhotoRenderer.java

  • Committer: Package Import Robot
  • Author(s): Gabriele Giacone
  • Date: 2013-11-05 13:02:16 UTC
  • mfrom: (1.1.14)
  • Revision ID: package-import@ubuntu.com-20131105130216-0e7dgqqvdq4pwm96
Tags: 4.2+dfsg-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/com/eteks/sweethome3d/j3d/PhotoRenderer.java
62
62
import javax.media.j3d.Link;
63
63
import javax.media.j3d.Material;
64
64
import javax.media.j3d.Node;
 
65
import javax.media.j3d.PolygonAttributes;
65
66
import javax.media.j3d.QuadArray;
66
67
import javax.media.j3d.RenderingAttributes;
67
68
import javax.media.j3d.Shape3D;
594
595
  
595
596
        String appearanceName = null;
596
597
        TexCoordGeneration texCoordGeneration = null;
 
598
        int cullFace = PolygonAttributes.CULL_BACK;
 
599
        boolean backFaceNormalFlip = false;
597
600
        if (appearance != null) {
 
601
          PolygonAttributes polygonAttributes = appearance.getPolygonAttributes();
 
602
          if (polygonAttributes != null) {
 
603
            cullFace = polygonAttributes.getCullFace();
 
604
            backFaceNormalFlip = polygonAttributes.getBackFaceNormalFlip();
 
605
          }
598
606
          texCoordGeneration = appearance.getTexCoordGeneration();
599
607
          appearanceName = "shader" + uuid;
600
608
          boolean mirror = shapeName != null
607
615
          String objectNameBase = "object" + uuid + "-" + i;
608
616
          // Always ignore normals on walls
609
617
          String [] objectsName = exportNodeGeometry(shape.getGeometry(i), parentTransformations, texCoordGeneration, 
610
 
              objectNameBase);
 
618
              cullFace, backFaceNormalFlip, objectNameBase);
611
619
          if (objectsName != null) {
612
620
            for (String objectName : objectsName) {
613
621
              if (appearanceName != null) {
627
635
  private String [] exportNodeGeometry(Geometry geometry, 
628
636
                                       Transform3D parentTransformations, 
629
637
                                       TexCoordGeneration texCoordGeneration, 
 
638
                                       int cullFace, 
 
639
                                       boolean backFaceNormalFlip,
630
640
                                       String objectNameBase) {
631
641
    if (geometry instanceof GeometryArray) {
632
642
      GeometryArray geometryArray = (GeometryArray)geometry;
722
732
              for (int index = 0, i = vertexSize - 6, n = geometryArray.getVertexCount(); 
723
733
                   index < n; index++, i += vertexSize) {
724
734
                Vector3f normal = new Vector3f(vertexData [i], vertexData [i + 1], vertexData [i + 2]);
725
 
                exportNormal(parentTransformations, normal, index, normals);
 
735
                exportNormal(parentTransformations, normal, index, normals, backFaceNormalFlip);
726
736
              }
727
737
            }
728
738
            // Export texture coordinates
754
764
              float [] normalCoordinates = geometryArray.getNormalRefFloat();
755
765
              for (int index = 0, i = 0, n = geometryArray.getVertexCount(); index < n; index++, i += 3) {
756
766
                Vector3f normal = new Vector3f(normalCoordinates [i], normalCoordinates [i + 1], normalCoordinates [i + 2]);
757
 
                exportNormal(parentTransformations, normal, index, normals);
 
767
                exportNormal(parentTransformations, normal, index, normals, backFaceNormalFlip);
758
768
              }
759
769
            }
760
770
            // Export texture coordinates
786
796
            for (int index = 0, n = geometryArray.getVertexCount(); index < n; index++) {
787
797
              Vector3f normal = new Vector3f();
788
798
              geometryArray.getNormal(index, normal);
789
 
              exportNormal(parentTransformations, normal, index, normals);
 
799
              exportNormal(parentTransformations, normal, index, normals, backFaceNormalFlip);
790
800
            }
791
801
          }
792
802
          // Export texture coordinates
828
838
              IndexedTriangleArray triangleArray = (IndexedTriangleArray)geometryArray;
829
839
              for (int i = 0, n = triangleArray.getIndexCount(), triangleIndex = 0; i < n; i += 3) {
830
840
                triangleIndex = exportIndexedTriangle(triangleArray, i, i + 1, i + 2, 
831
 
                    verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles);
 
841
                    verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles, cullFace);
832
842
              }
833
843
            } else if (geometryArray instanceof IndexedQuadArray) {
834
844
              IndexedQuadArray quadArray = (IndexedQuadArray)geometryArray;
835
845
              for (int i = 0, n = quadArray.getIndexCount(), triangleIndex = 0; i < n; i += 4) {
836
846
                triangleIndex = exportIndexedTriangle(quadArray, i, i + 1, i + 2, 
837
 
                    verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles);
 
847
                    verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles, cullFace);
838
848
                triangleIndex = exportIndexedTriangle(quadArray, i, i + 2, i + 3, 
839
 
                    verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles);
 
849
                    verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles, cullFace);
840
850
              }
841
851
            } else if (geometryArray instanceof IndexedLineStripArray) {
842
852
              IndexedLineStripArray lineStripArray = (IndexedLineStripArray)geometryArray;
854
864
                     i < n; i++, j++) {
855
865
                  if (j % 2 == 0) {
856
866
                    triangleIndex = exportIndexedTriangle(triangleStripArray, i, i + 1, i + 2, 
857
 
                        verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles);
 
867
                        verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles, cullFace);
858
868
                  } else { // Vertices of odd triangles are in reverse order               
859
869
                    triangleIndex = exportIndexedTriangle(triangleStripArray, i, i + 2, i + 1, 
860
 
                        verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles);
 
870
                        verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles, cullFace);
861
871
                  }
862
872
                }
863
873
                initialIndex += stripVertexCount [strip];
868
878
                for (int i = initialIndex, n = initialIndex + stripVertexCount [strip] - 2; 
869
879
                     i < n; i++) {
870
880
                  triangleIndex = exportIndexedTriangle(triangleFanArray, initialIndex, i + 1, i + 2, 
871
 
                      verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles);
 
881
                      verticesIndices, normalsIndices, uvsIndices, triangleIndex, vertices, exportedTriangles, cullFace);
872
882
                }
873
883
                initialIndex += stripVertexCount [strip];
874
884
              }
922
932
              TriangleArray triangleArray = (TriangleArray)geometryArray;
923
933
              for (int i = 0, n = triangleArray.getVertexCount(), triangleIndex = 0; i < n; i += 3) {
924
934
                triangleIndex = exportTriangle(triangleArray, i, i + 1, i + 2, 
925
 
                    verticesIndices, triangleIndex, vertices, exportedTriangles);
 
935
                    verticesIndices, triangleIndex, vertices, exportedTriangles, cullFace);
926
936
              }
927
937
            } else if (geometryArray instanceof QuadArray) {
928
938
              QuadArray quadArray = (QuadArray)geometryArray;
929
939
              for (int i = 0, n = quadArray.getVertexCount(), triangleIndex = 0; i < n; i += 4) {
930
940
                triangleIndex = exportTriangle(quadArray, i, i + 1, i + 2, 
931
 
                    verticesIndices, triangleIndex, vertices, exportedTriangles);
 
941
                    verticesIndices, triangleIndex, vertices, exportedTriangles, cullFace);
932
942
                triangleIndex = exportTriangle(quadArray, i + 2, i + 3, i, 
933
 
                    verticesIndices, triangleIndex, vertices, exportedTriangles);
 
943
                    verticesIndices, triangleIndex, vertices, exportedTriangles, cullFace);
934
944
              }
935
945
            } else if (geometryArray instanceof LineStripArray) {
936
946
              LineStripArray lineStripArray = (LineStripArray)geometryArray;
948
958
                     i < n; i++, j++) {
949
959
                  if (j % 2 == 0) {
950
960
                    triangleIndex = exportTriangle(triangleStripArray, i, i + 1, i + 2, 
951
 
                        verticesIndices, triangleIndex, vertices, exportedTriangles);
 
961
                        verticesIndices, triangleIndex, vertices, exportedTriangles, cullFace);
952
962
                  } else { // Vertices of odd triangles are in reverse order               
953
963
                    triangleIndex = exportTriangle(triangleStripArray, i, i + 2, i + 1, 
954
 
                        verticesIndices, triangleIndex, vertices, exportedTriangles);
 
964
                        verticesIndices, triangleIndex, vertices, exportedTriangles, cullFace);
955
965
                  }
956
966
                }
957
967
                initialIndex += stripVertexCount [strip];
962
972
                for (int i = initialIndex, n = initialIndex + stripVertexCount [strip] - 2; 
963
973
                     i < n; i++) {
964
974
                  triangleIndex = exportTriangle(triangleFanArray, initialIndex, i + 1, i + 2, verticesIndices, 
965
 
                      triangleIndex, vertices, exportedTriangles);
 
975
                      triangleIndex, vertices, exportedTriangles, cullFace);
966
976
                }
967
977
                initialIndex += stripVertexCount [strip];
968
978
              }
1089
1099
   */
1090
1100
  private void exportNormal(Transform3D transformationToParent,
1091
1101
                            Vector3f normal, int index,
1092
 
                            float [] normals) {
 
1102
                            float [] normals,
 
1103
                            boolean backFaceNormalFlip) {
 
1104
    if (backFaceNormalFlip) {
 
1105
      normal.negate();
 
1106
    }
1093
1107
    transformationToParent.transform(normal);
1094
1108
    int i = index * 3;
1095
1109
    normals [i++] = normal.x;
1126
1140
                                    int [] verticesIndices, int [] normalsIndices, int [] textureCoordinatesIndices, 
1127
1141
                                    int index, 
1128
1142
                                    float [] vertices, 
1129
 
                                    Set<Triangle> exportedTriangles) {
 
1143
                                    Set<Triangle> exportedTriangles,
 
1144
                                    int cullFace) {
 
1145
    if (cullFace == PolygonAttributes.CULL_FRONT) {
 
1146
      // Reverse vertex order
 
1147
      int tmp = vertexIndex1;
 
1148
      vertexIndex1 = vertexIndex3;
 
1149
      vertexIndex3 = tmp;
 
1150
    }
 
1151
    
1130
1152
    int coordinateIndex1 = geometryArray.getCoordinateIndex(vertexIndex1);
1131
1153
    int coordinateIndex2 = geometryArray.getCoordinateIndex(vertexIndex2);
1132
1154
    int coordinateIndex3 = geometryArray.getCoordinateIndex(vertexIndex3);
1168
1190
                             int vertexIndex1, int vertexIndex2, int vertexIndex3,
1169
1191
                             int [] verticesIndices, int index, 
1170
1192
                             float [] vertices, 
1171
 
                             Set<Triangle> exportedTriangles) {
 
1193
                             Set<Triangle> exportedTriangles,
 
1194
                             int cullFace) {
 
1195
    if (cullFace == PolygonAttributes.CULL_FRONT) {
 
1196
      // Reverse vertex order
 
1197
      int tmp = vertexIndex1;
 
1198
      vertexIndex1 = vertexIndex3;
 
1199
      vertexIndex3 = tmp;
 
1200
    }
 
1201
    
1172
1202
    Triangle exportedTriangle = new Triangle(vertices, vertexIndex1, vertexIndex2, vertexIndex3);
1173
1203
    if (!exportedTriangles.contains(exportedTriangle)) {
1174
1204
      exportedTriangles.add(exportedTriangle);