예제 #1
0
  /**
   * Constructor. Creates the basic set of bone's data.
   *
   * @param boneStructure the bone's structure
   * @param parent bone's parent (null if the bone is the root bone)
   * @param objectToArmatureMatrix object-to-armature transformation matrix
   * @param bonesPoseChannels a map of pose channels for each bone OMA
   * @param blenderContext the blender context
   * @throws BlenderFileException an exception is thrown when problem with blender data reading
   *     occurs
   */
  private BoneContext(
      Structure boneStructure,
      BoneContext parent,
      Matrix4f objectToArmatureMatrix,
      final Map<Long, Structure> bonesPoseChannels,
      BlenderContext blenderContext)
      throws BlenderFileException {
    this.parent = parent;
    this.boneStructure = boneStructure;
    boneName = boneStructure.getFieldValue("name").toString();
    ObjectHelper objectHelper = blenderContext.getHelper(ObjectHelper.class);
    armatureMatrix = objectHelper.getMatrix(boneStructure, "arm_mat", true);

    fixUpAxis = blenderContext.getBlenderKey().isFixUpAxis();
    this.computeRestMatrix(objectToArmatureMatrix);
    List<Structure> childbase =
        ((Structure) boneStructure.getFieldValue("childbase")).evaluateListBase(blenderContext);
    for (Structure child : childbase) {
      this.children.add(
          new BoneContext(child, this, objectToArmatureMatrix, bonesPoseChannels, blenderContext));
    }

    poseChannel = bonesPoseChannels.get(boneStructure.getOldMemoryAddress());

    blenderContext.setBoneContext(boneStructure.getOldMemoryAddress(), this);
  }
예제 #2
0
  /**
   * This method reads mesh indexes
   *
   * @param objectStructure structure of the object that has the armature modifier applied
   * @param meshStructure the structure of the object's mesh
   * @param blenderContext the blender context
   * @throws BlenderFileException this exception is thrown when the blend file structure is somehow
   *     invalid or corrupted
   */
  private void readVerticesWeightsData(
      Structure objectStructure, Structure meshStructure, BlenderContext blenderContext)
      throws BlenderFileException {
    ArmatureHelper armatureHelper = blenderContext.getHelper(ArmatureHelper.class);
    Structure defBase = (Structure) objectStructure.getFieldValue("defbase");
    Map<Integer, Integer> groupToBoneIndexMap =
        armatureHelper.getGroupToBoneIndexMap(defBase, blenderContext);

    int[] bonesGroups = new int[] {0};
    MeshContext meshContext = blenderContext.getMeshContext(meshStructure.getOldMemoryAddress());

    VertexBuffer[] boneWeightsAndIndex =
        this.getBoneWeightAndIndexBuffer(
            meshStructure,
            meshContext.getVertexList().size(),
            bonesGroups,
            meshContext.getVertexReferenceMap(),
            groupToBoneIndexMap,
            blenderContext);
    this.verticesWeights = boneWeightsAndIndex[0];
    this.verticesWeightsIndices = boneWeightsAndIndex[1];
    this.boneGroups = bonesGroups[0];
  }
예제 #3
0
  /**
   * This method builds the bone. It recursively builds the bone's children.
   *
   * @param bones a list of bones where the newly created bone will be added
   * @param boneOMAs the map between bone and its old memory address
   * @param blenderContext the blender context
   * @return newly created bone
   */
  public Bone buildBone(List<Bone> bones, Map<Bone, Long> boneOMAs, BlenderContext blenderContext) {
    Long boneOMA = boneStructure.getOldMemoryAddress();
    bone = new Bone(boneName);
    bones.add(bone);
    boneOMAs.put(bone, boneOMA);
    blenderContext.addLoadedFeatures(boneOMA, boneName, boneStructure, bone);

    Matrix4f pose = this.restMatrix.clone();
    ObjectHelper objectHelper = blenderContext.getHelper(ObjectHelper.class);

    Vector3f poseLocation = pose.toTranslationVector();
    Quaternion rotation = pose.toRotationQuat();
    Vector3f scale = objectHelper.getScale(pose);

    bone.setBindTransforms(poseLocation, rotation, scale);
    for (BoneContext child : children) {
      bone.addChild(child.buildBone(bones, boneOMAs, blenderContext));
    }

    this.computePoseTransform();

    return bone;
  }
예제 #4
0
  /**
   * This method creates an ipo object used for interpolation calculations.
   *
   * @param ipoStructure the structure with ipo definition
   * @param blenderContext the blender context
   * @return the ipo object
   * @throws BlenderFileException this exception is thrown when the blender file is somehow
   *     corrupted
   */
  public Ipo fromIpoStructure(Structure ipoStructure, BlenderContext blenderContext)
      throws BlenderFileException {
    Structure curvebase = (Structure) ipoStructure.getFieldValue("curve");

    // preparing bezier curves
    Ipo result = null;
    List<Structure> curves = curvebase.evaluateListBase(); // IpoCurve
    if (curves.size() > 0) {
      BezierCurve[] bezierCurves = new BezierCurve[curves.size()];
      int frame = 0;
      for (Structure curve : curves) {
        Pointer pBezTriple = (Pointer) curve.getFieldValue("bezt");
        List<Structure> bezTriples = pBezTriple.fetchData();
        int type = ((Number) curve.getFieldValue("adrcode")).intValue();
        bezierCurves[frame++] = new BezierCurve(type, bezTriples, 2);
      }
      curves.clear();
      result = new Ipo(bezierCurves, fixUpAxis, blenderContext.getBlenderVersion());
      Long ipoOma = ipoStructure.getOldMemoryAddress();
      blenderContext.addLoadedFeatures(ipoOma, LoadedDataType.STRUCTURE, ipoStructure);
      blenderContext.addLoadedFeatures(ipoOma, LoadedDataType.FEATURE, result);
    }
    return result;
  }
예제 #5
0
  /**
   * This method reads constraints for for the given structure. The constraints are loaded only once
   * for object/bone.
   *
   * @param objectStructure the structure we read constraint's for
   * @param blenderContext the blender context
   * @throws BlenderFileException
   */
  public void loadConstraints(Structure objectStructure, BlenderContext blenderContext)
      throws BlenderFileException {
    LOGGER.fine("Loading constraints.");
    // reading influence ipos for the constraints
    IpoHelper ipoHelper = blenderContext.getHelper(IpoHelper.class);
    Map<String, Map<String, Ipo>> constraintsIpos = new HashMap<String, Map<String, Ipo>>();
    Pointer pActions = (Pointer) objectStructure.getFieldValue("action");
    if (pActions.isNotNull()) {
      List<Structure> actions = pActions.fetchData(blenderContext.getInputStream());
      for (Structure action : actions) {
        Structure chanbase = (Structure) action.getFieldValue("chanbase");
        List<Structure> actionChannels = chanbase.evaluateListBase(blenderContext);
        for (Structure actionChannel : actionChannels) {
          Map<String, Ipo> ipos = new HashMap<String, Ipo>();
          Structure constChannels = (Structure) actionChannel.getFieldValue("constraintChannels");
          List<Structure> constraintChannels = constChannels.evaluateListBase(blenderContext);
          for (Structure constraintChannel : constraintChannels) {
            Pointer pIpo = (Pointer) constraintChannel.getFieldValue("ipo");
            if (pIpo.isNotNull()) {
              String constraintName = constraintChannel.getFieldValue("name").toString();
              Ipo ipo =
                  ipoHelper.fromIpoStructure(
                      pIpo.fetchData(blenderContext.getInputStream()).get(0), blenderContext);
              ipos.put(constraintName, ipo);
            }
          }
          String actionName = actionChannel.getFieldValue("name").toString();
          constraintsIpos.put(actionName, ipos);
        }
      }
    }

    // loading constraints connected with the object's bones
    Pointer pPose = (Pointer) objectStructure.getFieldValue("pose");
    if (pPose.isNotNull()) {
      List<Structure> poseChannels =
          ((Structure)
                  pPose.fetchData(blenderContext.getInputStream()).get(0).getFieldValue("chanbase"))
              .evaluateListBase(blenderContext);
      for (Structure poseChannel : poseChannels) {
        List<Constraint> constraintsList = new ArrayList<Constraint>();
        Long boneOMA =
            Long.valueOf(((Pointer) poseChannel.getFieldValue("bone")).getOldMemoryAddress());

        // the name is read directly from structure because bone might not yet be loaded
        String name =
            blenderContext
                .getFileBlock(boneOMA)
                .getStructure(blenderContext)
                .getFieldValue("name")
                .toString();
        List<Structure> constraints =
            ((Structure) poseChannel.getFieldValue("constraints")).evaluateListBase(blenderContext);
        for (Structure constraint : constraints) {
          String constraintName = constraint.getFieldValue("name").toString();
          Map<String, Ipo> ipoMap = constraintsIpos.get(name);
          Ipo ipo = ipoMap == null ? null : ipoMap.get(constraintName);
          if (ipo == null) {
            float enforce = ((Number) constraint.getFieldValue("enforce")).floatValue();
            ipo = ipoHelper.fromValue(enforce);
          }
          constraintsList.add(this.createConstraint(constraint, boneOMA, ipo, blenderContext));
        }
        blenderContext.addConstraints(boneOMA, constraintsList);
      }
    }

    // loading constraints connected with the object itself
    List<Structure> constraints =
        ((Structure) objectStructure.getFieldValue("constraints")).evaluateListBase(blenderContext);
    List<Constraint> constraintsList = new ArrayList<Constraint>(constraints.size());

    for (Structure constraint : constraints) {
      String constraintName = constraint.getFieldValue("name").toString();
      String objectName = objectStructure.getName();

      Map<String, Ipo> objectConstraintsIpos = constraintsIpos.get(objectName);
      Ipo ipo = objectConstraintsIpos != null ? objectConstraintsIpos.get(constraintName) : null;
      if (ipo == null) {
        float enforce = ((Number) constraint.getFieldValue("enforce")).floatValue();
        ipo = ipoHelper.fromValue(enforce);
      }
      constraintsList.add(
          this.createConstraint(
              constraint, objectStructure.getOldMemoryAddress(), ipo, blenderContext));
    }
    blenderContext.addConstraints(objectStructure.getOldMemoryAddress(), constraintsList);
  }
  /**
   * The method loads library of a given ID from linked blender file.
   *
   * @param id the ID of the linked feature (it contains its name and blender path)
   * @return loaded feature or null if none was found
   * @throws BlenderFileException and exception is throw when problems with reading a blend file
   *     occur
   */
  @SuppressWarnings("unchecked")
  protected Object loadLibrary(Structure id) throws BlenderFileException {
    Pointer pLib = (Pointer) id.getFieldValue("lib");
    if (pLib.isNotNull()) {
      String fullName = id.getFieldValue("name").toString(); // we need full name with the prefix
      String nameOfFeatureToLoad = id.getName();
      Structure library = pLib.fetchData().get(0);
      String path = library.getFieldValue("filepath").toString();

      if (!blenderContext.getLinkedFeatures().keySet().contains(path)) {
        File file = new File(path);
        List<String> pathsToCheck = new ArrayList<String>();
        String currentPath = file.getName();
        do {
          pathsToCheck.add(currentPath);
          file = file.getParentFile();
          if (file != null) {
            currentPath = file.getName() + '/' + currentPath;
          }
        } while (file != null);

        Spatial loadedAsset = null;
        BlenderKey blenderKey = null;
        for (String p : pathsToCheck) {
          blenderKey = new BlenderKey(p);
          blenderKey.setLoadUnlinkedAssets(true);
          try {
            loadedAsset = blenderContext.getAssetManager().loadAsset(blenderKey);
            break; // break if no exception was thrown
          } catch (AssetNotFoundException e) {
            LOGGER.log(Level.FINEST, "Cannot locate linked resource at path: {0}.", p);
          }
        }

        if (loadedAsset != null) {
          Map<String, Map<String, Object>> linkedData = loadedAsset.getUserData("linkedData");
          for (Entry<String, Map<String, Object>> entry : linkedData.entrySet()) {
            String linkedDataFilePath = "this".equals(entry.getKey()) ? path : entry.getKey();

            List<Node> scenes = (List<Node>) entry.getValue().get("scenes");
            for (Node scene : scenes) {
              blenderContext.addLinkedFeature(linkedDataFilePath, "SC" + scene.getName(), scene);
            }
            List<Node> objects = (List<Node>) entry.getValue().get("objects");
            for (Node object : objects) {
              blenderContext.addLinkedFeature(linkedDataFilePath, "OB" + object.getName(), object);
            }
            List<TemporalMesh> meshes = (List<TemporalMesh>) entry.getValue().get("meshes");
            for (TemporalMesh mesh : meshes) {
              blenderContext.addLinkedFeature(linkedDataFilePath, "ME" + mesh.getName(), mesh);
            }
            List<MaterialContext> materials =
                (List<MaterialContext>) entry.getValue().get("materials");
            for (MaterialContext materialContext : materials) {
              blenderContext.addLinkedFeature(
                  linkedDataFilePath, "MA" + materialContext.getName(), materialContext);
            }
            List<Texture> textures = (List<Texture>) entry.getValue().get("textures");
            for (Texture texture : textures) {
              blenderContext.addLinkedFeature(
                  linkedDataFilePath, "TE" + texture.getName(), texture);
            }
            List<Texture> images = (List<Texture>) entry.getValue().get("images");
            for (Texture image : images) {
              blenderContext.addLinkedFeature(linkedDataFilePath, "IM" + image.getName(), image);
            }
            List<Animation> animations = (List<Animation>) entry.getValue().get("animations");
            for (Animation animation : animations) {
              blenderContext.addLinkedFeature(
                  linkedDataFilePath, "AC" + animation.getName(), animation);
            }
            List<Camera> cameras = (List<Camera>) entry.getValue().get("cameras");
            for (Camera camera : cameras) {
              blenderContext.addLinkedFeature(linkedDataFilePath, "CA" + camera.getName(), camera);
            }
            List<Light> lights = (List<Light>) entry.getValue().get("lights");
            for (Light light : lights) {
              blenderContext.addLinkedFeature(linkedDataFilePath, "LA" + light.getName(), light);
            }
            Spatial sky = (Spatial) entry.getValue().get("sky");
            if (sky != null) {
              blenderContext.addLinkedFeature(linkedDataFilePath, sky.getName(), sky);
            }
            List<Filter> filters = (List<Filter>) entry.getValue().get("filters");
            for (Filter filter : filters) {
              blenderContext.addLinkedFeature(linkedDataFilePath, filter.getName(), filter);
            }
          }
        } else {
          LOGGER.log(Level.WARNING, "No features loaded from path: {0}.", path);
        }
      }

      Object result = blenderContext.getLinkedFeature(path, fullName);
      if (result == null) {
        LOGGER.log(
            Level.WARNING,
            "Could NOT find asset named {0} in the library of path: {1}.",
            new Object[] {nameOfFeatureToLoad, path});
      } else {
        blenderContext.addLoadedFeatures(id.getOldMemoryAddress(), LoadedDataType.STRUCTURE, id);
        blenderContext.addLoadedFeatures(id.getOldMemoryAddress(), LoadedDataType.FEATURE, result);
      }
      return result;
    } else {
      LOGGER.warning("Library link points to nothing!");
    }
    return null;
  }
예제 #7
0
  /**
   * This constructor reads animation data from the object structore. The stored data is the
   * AnimData and additional data is armature's OMA.
   *
   * @param objectStructure the structure of the object
   * @param modifierStructure the structure of the modifier
   * @param blenderContext the blender context
   * @throws BlenderFileException this exception is thrown when the blender file is somehow
   *     corrupted
   */
  public ArmatureModifier(
      Structure objectStructure, Structure modifierStructure, BlenderContext blenderContext)
      throws BlenderFileException {
    if (this.validate(modifierStructure, blenderContext)) {
      Pointer pArmatureObject = (Pointer) modifierStructure.getFieldValue("object");
      if (pArmatureObject.isNotNull()) {
        ObjectHelper objectHelper = blenderContext.getHelper(ObjectHelper.class);
        ArmatureHelper armatureHelper = blenderContext.getHelper(ArmatureHelper.class);

        Structure armatureObject =
            pArmatureObject.fetchData(blenderContext.getInputStream()).get(0);
        this.armatureObjectOMA = armatureObject.getOldMemoryAddress();

        // read skeleton
        // changing bones matrices so that they fit the current object
        Structure armatureStructure =
            ((Pointer) armatureObject.getFieldValue("data"))
                .fetchData(blenderContext.getInputStream())
                .get(0);
        Structure bonebase = (Structure) armatureStructure.getFieldValue("bonebase");
        List<Structure> bonesStructures = bonebase.evaluateListBase(blenderContext);
        for (Structure boneStructure : bonesStructures) {
          BoneTransformationData rootBoneTransformationData =
              armatureHelper.readBoneAndItsChildren(boneStructure, null, blenderContext);
          armatureHelper.addBoneDataRoot(rootBoneTransformationData);
        }
        Matrix4f armatureObjectMatrix = objectHelper.getTransformationMatrix(armatureObject);
        Matrix4f inverseMeshObjectMatrix =
            objectHelper.getTransformationMatrix(objectStructure).invert();
        Matrix4f additionalRootBoneTransformation =
            inverseMeshObjectMatrix.multLocal(armatureObjectMatrix);
        Bone[] bones =
            armatureHelper.buildBonesStructure(Long.valueOf(0L), additionalRootBoneTransformation);

        // read mesh indexes
        Structure meshStructure =
            ((Pointer) objectStructure.getFieldValue("data"))
                .fetchData(blenderContext.getInputStream())
                .get(0);
        this.meshOMA = meshStructure.getOldMemoryAddress();
        this.readVerticesWeightsData(objectStructure, meshStructure, blenderContext);

        // read animations
        ArrayList<Animation> animations = new ArrayList<Animation>();
        List<FileBlockHeader> actionHeaders =
            blenderContext.getFileBlocks(Integer.valueOf(FileBlockHeader.BLOCK_AC00));
        if (actionHeaders != null) { // it may happen that the model has armature with no actions
          for (FileBlockHeader header : actionHeaders) {
            Structure actionStructure = header.getStructure(blenderContext);
            String actionName = actionStructure.getName();

            BoneTrack[] tracks = armatureHelper.getTracks(actionStructure, blenderContext);
            // determining the animation  time
            float maximumTrackLength = 0;
            for (BoneTrack track : tracks) {
              float length = track.getLength();
              if (length > maximumTrackLength) {
                maximumTrackLength = length;
              }
            }

            Animation boneAnimation = new Animation(actionName, maximumTrackLength);
            boneAnimation.setTracks(tracks);
            animations.add(boneAnimation);
          }
        }
        animData = new AnimData(new Skeleton(bones), animations);
      }
    }
  }
예제 #8
0
 /** @return the old memory address of the bone */
 public Long getBoneOma() {
   return boneStructure.getOldMemoryAddress();
 }