Example #1
0
 public void getChildMap(List<Spatial> res, Node parent, Node n, String name, boolean raypick) {
   for (Spatial child : n.getChildren()) {
     if (child instanceof Node) {
       getChildMap(res, parent, (Node) child, name, raypick);
     }
     if (child.getName() != null && child.getName().startsWith(name)) {
       if (raypick && child instanceof Geometry) {
         child.setUserData(ENTITY_GEOMETRY_REFERENCE, parent);
       }
       res.add(child);
     }
   }
 }
Example #2
0
 /**
  * Reload a prop and unpick it.
  *
  * @param originalProp which prop to reload (not null)
  */
 public void reload(Spatial originalProp) {
   String name = originalProp.getName();
   logger.log(Level.INFO, "reloading prop {0}", MyString.quote(name));
   Node reloaded = duplicate(originalProp);
   scene.deleteSpatial(originalProp);
   reloaded.setName(name);
 }
Example #3
0
  /**
   * Create a prop without adding it to the scene.
   *
   * @param propType which kind of prop to add (not null)
   * @param relativeSize the prop's size relative to standard (&gt;0)
   * @return a new node to represent the prop, or null if the model is invalid
   */
  private Node create(String propType, float relativeSize) {
    assert propType != null;
    assert relativeSize > 0f : relativeSize;

    Node propNode = loadModel(propType);
    Node modelNode = (Node) propNode.getChild(0);
    List<Spatial> parts = modelNode.getChildren();
    /*
     * Texture each part of the prop and specify its hardness.
     */
    for (Spatial part : parts) {
      String partName = part.getName();
      if (!(part instanceof Geometry)) {
        logger.log(Level.SEVERE, "Prop part {0} is not a geometry.", MyString.quote(partName));
        return null;
      }
      String materialName = material(partName);
      SpatialProperties.setHardness(part, materialName);
      Material material = Assets.loadBlockMaterial(materialName);
      part.setMaterial(material);
    }
    /*
     * Set the scale factor.
     */
    float scaleFactor = scene.getScaleFactor();
    float modelScale = relativeSize / scaleFactor;
    propNode.setLocalScale(modelScale);
    assert getRelativeSize(propNode) == relativeSize : relativeSize;
    /*
     * Set other properties.
     */
    propNode.setShadowMode(RenderQueue.ShadowMode.CastAndReceive);
    /*
     * Give the prop a physics control.
     */
    CollisionShape shape = createShape(propType, relativeSize, parts);
    float mass = calculateMass(propType, relativeSize);
    RigidBodyControl rigidBodyControl = new RigidBodyControl(shape, mass);
    propNode.addControl(rigidBodyControl);
    /*
     * Configure the physics control.
     */
    rigidBodyControl.setFriction(friction);
    scene.getWorld().getPhysics().addObject(rigidBodyControl);
    /*
     * Give the prop a PickedControl.
     */
    SpatialProperties.setPickType(propNode, pickType);
    PickedControl pickedControl = new PickedControl();
    propNode.addControl(pickedControl);

    return propNode;
  }
Example #4
0
  /**
   * Duplicate a prop. Duplicating differs from cloning because the duplicate gets a unique name and
   * any descendants of the duplicate get renamed to match. Besides, cloning doesn't work well on
   * physics controls.
   *
   * @param originalProp which prop to duplicate (not null)
   * @return the new prop
   */
  public Node duplicate(Spatial originalProp) {
    String name = originalProp.getName();
    logger.log(Level.INFO, "duplicating prop {0}", MyString.quote(name));

    String propType = SpatialProperties.getPrefixType(originalProp);
    float relativeSize = originalProp.getWorldScale().x;
    Vector3f centerLocation = MySpatial.getWorldLocation(originalProp);
    Quaternion orientation = MySpatial.getWorldOrientation(originalProp);

    Node result = add(propType, relativeSize, centerLocation, orientation);
    return result;
  }
Example #5
0
  public static Geometry findGeoByName(String name, Node parent) {

    for (Spatial sp : parent.getChildren()) {
      if (sp instanceof Geometry) {

        if (sp.getName().equals(name)) {
          return (Geometry) sp;
        }
      }
    }

    for (Spatial sp : parent.getChildren()) {
      if (sp instanceof Node) {
        Geometry result = findGeoByName(name, (Node) sp);
        if (result != null) {
          return (Geometry) result;
        }
      }
    }
    return null;
  }
Example #6
0
  private void applyGravity(Spatial blackHole, Spatial target, float tpf) {
    Vector3f difference = blackHole.getLocalTranslation().subtract(target.getLocalTranslation());

    Vector3f gravity = difference.normalize().multLocal(tpf);
    float distance = difference.length();

    if (target.getName().equals("Player")) {
      gravity.multLocal(250f / distance);
      target.getControl(PlayerControl.class).applyGravity(gravity.mult(80f));
    } else if (target.getName().equals("Bullet")) {
      gravity.multLocal(250f / distance);
      target.getControl(BulletControl.class).applyGravity(gravity.mult(-0.8f));
    } else if (target.getName().equals("Seeker")) {
      target.getControl(SeekerControl.class).applyGravity(gravity.mult(150000));
    } else if (target.getName().equals("Wanderer")) {
      target.getControl(WandererControl.class).applyGravity(gravity.mult(150000));
    } else if (target.getName().equals("Laser") || target.getName().equals("Glow")) {
      target.getControl(ParticleControl.class).applyGravity(gravity.mult(15000), distance);
    }
  }
  /**
   * 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;
  }