Пример #1
0
  public boolean loadShader(ModelMD3 model, String fileShader) {
    try {
      // Wrap a buffer to make reading more efficient (faster)
      BufferedReader reader = new BufferedReader(new FileReader(fileShader));

      // These variables are used to read in a line at a time from the file, and also
      // to store the current line being read so that we can use that as an index for the
      // textures, in relation to the index of the sub-object loaded in from the weapon model.
      String strLine;
      int currentIndex = 0;

      // Go through and read in every line of text from the file
      while ((strLine = reader.readLine()) != null) {
        // Create a local material info structure
        MaterialInfo texture = new MaterialInfo();

        // Copy the name of the file into our texture file name variable
        texture.setName(strLine);

        // The tile or scale for the UV's is 1 to 1 (but Quake saves off a 0-256 ratio)
        texture.setUTile(1);
        texture.setVTile(1);

        // Add the local material info to our model's material list
        // Store the material ID for this object and set the texture boolean to true
        model.getObject(currentIndex).setMaterialID(model.getMaterials().size());
        model.getObject(currentIndex).setbHasTexture(true);

        // Add the local material info structure to our model's material list
        model.addMaterials(texture);

        // Here we increase the material index for the next texture (if any)
        currentIndex++;
      }

      // Close the file and return a success
      reader.close();
    } catch (Exception e) {
      return false;
    }

    return true;
  }
Пример #2
0
  private void convertDataStructures(ModelMD3 model, MeshInfoMD3 meshHeader) {
    int i = 0;

    Object3d currentMesh = new Object3d();

    // Assign the vertex, texture coord and face count to our new structure
    currentMesh.setNumVertices(meshHeader.numVertices * meshHeader.numMeshFrames);
    currentMesh.setNumVert(meshHeader.numVertices);

    currentMesh.setNumTexcoords(meshHeader.numVertices);
    currentMesh.setNumFaces(meshHeader.numTriangles);
    currentMesh.setName(meshHeader.strName);

    // Go through all of the vertices and assign them over to our structure
    for (i = 0; i < currentMesh.getNumVertices() * meshHeader.numMeshFrames; i++) {
      Vector3f temp =
          new Vector3f(
              vertices[i].vertex[0] / 64.0f,
              vertices[i].vertex[1] / 64.0f,
              vertices[i].vertex[2] / 64.0f);

      currentMesh.setVertices(temp, i);
    }

    for (i = 0; i < currentMesh.getNumTexcoords(); i++) {
      Vector3f temp = new Vector3f(texCoords[i].u, -texCoords[i].v, 0);
      currentMesh.setTexcoords(temp, i);
    }

    // Go through all of the face data and assign it over to OUR structure
    for (i = 0; i < currentMesh.getNumFaces(); i++) {
      // Assign the vertex indices to our face data
      currentMesh.getFace(i).setVertices(0, triangles[i].vertexIndices[0]);
      currentMesh.getFace(i).setVertices(1, triangles[i].vertexIndices[1]);
      currentMesh.getFace(i).setVertices(2, triangles[i].vertexIndices[2]);

      // Assign the texture coord indices to our face data
      currentMesh.getFace(i).setTexCoords(0, triangles[i].vertexIndices[0]);
      currentMesh.getFace(i).setTexCoords(1, triangles[i].vertexIndices[1]);
      currentMesh.getFace(i).setTexCoords(2, triangles[i].vertexIndices[2]);
    }
    currentMesh.setDimension();
    // Here we add the current object (or frame) to our list object list
    model.addObject(currentMesh);
  }
Пример #3
0
  /**
   * This loads the texture information for the model from the *.skin file.
   *
   * @param model Current model.
   * @param fileSkin Skin path.
   */
  public boolean loadSkin(ModelMD3 model, String fileSkin) {

    // Make sure valid data was passed in
    if (model == null || fileSkin == null) return false;

    // This function is used to load a .skin file for the .md3 model associated
    // with it.  The .skin file stores the textures that need to go with each
    // object and subject in the .md3 files.  For instance, in our Lara Croft model,
    // her upper body model links to 2 texture; one for her body and the other for
    // her face/head.  The .skin file for the lara_upper.md3 model has 2 textures:
    //
    // u_torso,models/players/laracroft/default.bmp
    // u_head,models/players/laracroft/default_h.bmp
    //
    // Notice the first word, then a comma.  This word is the name of the object
    // in the .md3 file.  Remember, each .md3 file can have many sub-objects.
    // The next bit of text is the Quake3 path into the .pk3 file where the
    // texture for that model is stored  Since we don't use the Quake3 path
    // because we aren't making Quake, I just grab the texture name at the
    // end of the string and disregard the rest.  of course, later this is
    // concatenated to the original MODEL_PATH that we passed into load our character.
    // So, for the torso object it's clear that default.bmp is assigned to it, where
    // as the head model with the pony tail, is assigned to default_h.bmp.  Simple enough.
    // What this function does is go through all the lines of the .skin file, and then
    // goes through all of the sub-objects in the .md3 file to see if their name is
    // in that line as a sub string.  We use our cool IsInString() function for that.
    // If it IS in that line, then we know that we need to grab it's texture file at
    // the end of the line.  I just parse backwards until I find the last '/' character,
    // then copy all the characters from that index + 1 on (I.E. "default.bmp").
    // Remember, it's important to note that I changed the texture files from .tga
    // files to .bmp files because that is what all of our tutorials use.  That way
    // you don't have to sift through tons of image loading code.  You can write or
    // get your own if you really want to use the .tga format.
    try {
      // Wrap a buffer to make reading more efficient (faster)
      BufferedReader reader = new BufferedReader(new FileReader(fileSkin));

      // These 2 variables are for reading in each line from the file, then storing
      // the index of where the bitmap name starts after the last '/' character.
      String strLine;
      int textureNameStart = 0;

      // Go through every line in the .skin file
      while ((strLine = reader.readLine()) != null) {
        // Loop through all of our objects to test if their name is in this line
        for (int i = 0; i < model.getObject().size(); i++) {
          // Check if the name of this object appears in this line from the skin file
          if (strLine.contains(model.getObject(i).getName())) {

            // To extract the texture name, we loop through the string, starting
            // at the end of it until we find a '/' character, then save that index + 1.
            textureNameStart = strLine.lastIndexOf("/") + 1;

            // Create a local material info structure
            MaterialInfo texture = new MaterialInfo();

            // Copy the name of the file into our texture file name variable.
            texture.setName(strLine.substring(textureNameStart));

            // The tile or scale for the UV's is 1 to 1 (but Quake saves off a 0-256 ratio)
            texture.setUTile(1);
            texture.setVTile(1);

            // Add the local material info to our model's material list
            // Store the material ID for this object and set the texture boolean to true
            model.getObject(i).setMaterialID(model.getMaterials().size());
            model.getObject(i).setbHasTexture(true);

            // Add the local material info structure to our model's material list
            model.addMaterials(texture);
          }
        }
      }

      // Close the file and return a success
      reader.close();
    } catch (Exception e) {
      return false;
    }

    return true;
  }
Пример #4
0
  private void readMD3Data(ModelMD3 model) throws Exception {

    int i;

    // Here we allocate memory for the bone information and read the bones in.
    bones = new BoneMD3[header.numFrames];

    for (i = 0; i < header.numFrames; i++) bones[i] = new BoneMD3();

    // Free the unused bones
    bones = null;

    // Next, after the bones are read in, we need to read in the tags.
    model.setNumTags(header.numFrames * header.numTags);

    for (i = 0; i < model.getTags().length; i++) {
      TagMD3 pTags = new TagMD3();
      model.setTags(pTags, i);
    }
    // Assign the number of tags to our model
    model.setNumOfTags(header.numTags);

    // Now we want to initialize our links.
    model.setNumLinks(header.numTags);

    // Get the current offset into the file
    // loader.markPos();
    int meshOffset = loader.getFileIndex();

    // Create a local meshHeader that stores the info about the mesh
    MeshInfoMD3 meshHeader;

    // Go through all of the sub-objects in this mesh
    for (int j = 0; j < header.numMeshes; j++) {
      // Seek to the start of this mesh and read in it's header
      loader.setOffset(meshOffset);

      meshHeader = new MeshInfoMD3();

      // Here we allocate all of our memory from the header's information
      skins = new SkinMD3[meshHeader.numSkins];
      texCoords = new TexCoordMD3[meshHeader.numVertices];
      triangles = new FaceMD3[meshHeader.numTriangles];
      vertices = new TriangleMD3[meshHeader.numVertices * meshHeader.numMeshFrames];

      // Read in the skin information
      loader.setOffset(meshOffset + meshHeader.numSkins);
      for (i = 0; i < meshHeader.numSkins; i++) skins[i] = new SkinMD3();

      // Seek to the start of the triangle/face data, then read it in
      loader.setOffset(meshOffset + meshHeader.triStart);

      for (i = 0; i < meshHeader.numTriangles; i++) triangles[i] = new FaceMD3();

      // Seek to the start of the UV coordinate data, then read it in
      loader.setOffset(meshOffset + meshHeader.uvStart);

      for (i = 0; i < meshHeader.numVertices; i++) texCoords[i] = new TexCoordMD3();

      // Seek to the start of the vertex/face index information, then read it in.
      loader.setOffset(meshOffset + meshHeader.vertexStart);

      for (i = 0; i < meshHeader.numMeshFrames * meshHeader.numVertices; i++)
        vertices[i] = new TriangleMD3();

      // Now that we have the data loaded into the md3 structures, let's convert them to
      // our data types like ModelMD3 and Object3D.
      convertDataStructures(model, meshHeader);

      // Free all the memory for this mesh since we just converted it to our structures
      skins = null;
      texCoords = null;
      triangles = null;
      vertices = null;

      // Increase the offset into the file
      meshOffset += meshHeader.meshSize;
    }
  }