Example #1
0
  /** Process and setup the <code>TextureState</code> and texture UV buffer. */
  private void processTexture() {
    FloatBuffer textureBuffer = BufferUtils.createVector2Buffer(this.vertices.length);
    float maxU = 1;
    float maxV = 1;
    float minU = 0;
    float minV = 0;
    int index = 0;
    for (IVertex vertex : this.vertices) {
      BufferUtils.setInBuffer(vertex.getTextureCoords(), textureBuffer, index);
      if (vertex.getTextureCoords().x > maxU) maxU = vertex.getTextureCoords().x;
      else if (vertex.getTextureCoords().x < minU) minU = vertex.getTextureCoords().x;
      if (vertex.getTextureCoords().y > maxV) maxV = vertex.getTextureCoords().y;
      else if (vertex.getTextureCoords().y < minV) minV = vertex.getTextureCoords().y;
      index++;
    }
    this.setTextureCoords(new TexCoords(textureBuffer));

    // Get texture state.
    TextureState state = (TextureState) this.getRenderState(StateType.Texture);
    if (state == null) {
      state = DisplaySystem.getDisplaySystem().getRenderer().createTextureState();
      this.setRenderState(state);
    }
    // Set color map.
    if (this.color != null) state.setTexture(this.loadTexture(this.color, maxU, maxV), 0);
    // Set normal map.
    if (this.normal != null) state.setTexture(this.loadTexture(this.normal, maxU, maxV), 1);
    // Set specular map.
    if (this.specular != null) state.setTexture(this.loadTexture(this.specular, maxU, maxV), 2);
  }
Example #2
0
 private Node constructMesh() {
   Node toReturn = new Node("MD3 File");
   for (int i = 0; i < head.numSurface; i++) {
     vkc = new KeyframeController();
     MD3Surface thisSurface = surfaces[i];
     TriMesh object = new TriMesh(thisSurface.name);
     object.setIndexBuffer(BufferUtils.createIntBuffer(thisSurface.triIndexes));
     object.setVertexBuffer(BufferUtils.createFloatBuffer(thisSurface.verts[0]));
     object.setNormalBuffer(BufferUtils.createFloatBuffer(thisSurface.norms[0]));
     object.setTextureCoords(TexCoords.makeNew(thisSurface.texCoords));
     toReturn.attachChild(object);
     vkc.setMorphingMesh(object);
     for (int j = 0; j < head.numFrames; j++) {
       TriMesh etm = new TriMesh();
       etm.setVertexBuffer(BufferUtils.createFloatBuffer(thisSurface.verts[j]));
       etm.setNormalBuffer(BufferUtils.createFloatBuffer(thisSurface.norms[j]));
       vkc.setKeyframe(j, etm);
     }
     vkc.setActive(true);
     vkc.setSpeed(5);
     object.addController(vkc);
     toReturn.addController(vkc);
   }
   nullAll();
   return toReturn;
 }
  /**
   * This is a <b>VERY </b> brute force method of detecting if two TriMesh objects intersect.
   *
   * @param mesh1 The first TriMesh.
   * @param mesh2 The second TriMesh.
   * @return True if they intersect, false otherwise.
   */
  public static boolean meshIntersection(TriMesh mesh1, TriMesh mesh2) {

    IntBuffer indexA = mesh1.getIndexBuffer();
    IntBuffer indexB = mesh2.getIndexBuffer();
    TransformMatrix aTransform = new TransformMatrix();
    aTransform.setRotationQuaternion(mesh1.getWorldRotation());
    aTransform.setTranslation(mesh1.getWorldTranslation());
    aTransform.setScale(mesh1.getWorldScale());

    TransformMatrix bTransform = new TransformMatrix();
    bTransform.setRotationQuaternion(mesh2.getWorldRotation());
    bTransform.setTranslation(mesh2.getWorldTranslation());
    bTransform.setScale(mesh2.getWorldScale());

    Vector3f[] vertA = BufferUtils.getVector3Array(mesh1.getVertexBuffer());
    for (int i = 0; i < vertA.length; i++) aTransform.multPoint(vertA[i]);

    Vector3f[] vertB = BufferUtils.getVector3Array(mesh2.getVertexBuffer());
    for (int i = 0; i < vertB.length; i++) bTransform.multPoint(vertB[i]);

    for (int i = 0; i < mesh1.getTriangleCount(); i++) {
      for (int j = 0; j < mesh2.getTriangleCount(); j++) {
        if (intersection(
            vertA[indexA.get(i * 3 + 0)],
            vertA[indexA.get(i * 3 + 1)],
            vertA[indexA.get(i * 3 + 2)],
            vertB[indexB.get(j * 3 + 0)],
            vertB[indexB.get(j * 3 + 1)],
            vertB[indexB.get(j * 3 + 2)])) return true;
      }
    }
    return false;
  }
Example #4
0
 /** Process and setup the vertex position buffer. */
 private void processVertex() {
   FloatBuffer vertexBuffer = this.getVertexBuffer();
   if (vertexBuffer == null) {
     vertexBuffer = BufferUtils.createVector3Buffer(this.vertices.length);
     this.setVertexBuffer(vertexBuffer);
   }
   vertexBuffer.clear();
   for (int i = 0; i < this.vertices.length; i++) {
     this.vertices[i].resetInformation();
     this.vertices[i].processPosition();
     BufferUtils.setInBuffer(this.vertices[i].getPosition(), vertexBuffer, i);
   }
 }
Example #5
0
  public void orthogonalLineFit(FloatBuffer points) {
    if (points == null) {
      return;
    }

    points.rewind();

    // compute average of points
    int length = points.remaining() / 3;

    BufferUtils.populateFromBuffer(origin, points, 0);
    for (int i = 1; i < length; i++) {
      BufferUtils.populateFromBuffer(compVec1, points, i);
      origin.addLocal(compVec1);
    }

    origin.multLocal(1f / (float) length);

    // compute sums of products
    float sumXX = 0.0f, sumXY = 0.0f, sumXZ = 0.0f;
    float sumYY = 0.0f, sumYZ = 0.0f, sumZZ = 0.0f;

    points.rewind();
    for (int i = 0; i < length; i++) {
      BufferUtils.populateFromBuffer(compVec1, points, i);
      compVec1.subtract(origin, compVec2);
      sumXX += compVec2.x * compVec2.x;
      sumXY += compVec2.x * compVec2.y;
      sumXZ += compVec2.x * compVec2.z;
      sumYY += compVec2.y * compVec2.y;
      sumYZ += compVec2.y * compVec2.z;
      sumZZ += compVec2.z * compVec2.z;
    }

    // find the smallest eigen vector for the direction vector
    compMat1.m00 = sumYY + sumZZ;
    compMat1.m01 = -sumXY;
    compMat1.m02 = -sumXZ;
    compMat1.m10 = -sumXY;
    compMat1.m11 = sumXX + sumZZ;
    compMat1.m12 = -sumYZ;
    compMat1.m20 = -sumXZ;
    compMat1.m21 = -sumYZ;
    compMat1.m22 = sumXX + sumYY;

    compEigen1.calculateEigen(compMat1);
    direction = compEigen1.getEigenVector(0);
  }
Example #6
0
/**
 * @see Ear
 * @author Joshua Slack
 * @version $Id: OpenALEar.java 4133 2009-03-19 20:40:11Z blaine.dev $
 */
public class OpenALEar extends Ear {

  private FloatBuffer orientBuf = BufferUtils.createFloatBuffer(6);

  @Override
  public void update(float dt) {
    super.update(dt);

    Vector3f pos = getPosition();
    Vector3f vel = getCurrVelocity();
    Vector3f up = getUpVector();
    Vector3f dir = getFacingVector();

    AL10.alListener3f(AL10.AL_POSITION, pos.x, pos.y, pos.z);
    AL10.alListener3f(AL10.AL_VELOCITY, vel.x, vel.y, vel.z);

    orientBuf.rewind();
    orientBuf.put(dir.x);
    orientBuf.put(dir.y);
    orientBuf.put(dir.z);
    orientBuf.put(up.x);
    orientBuf.put(up.y);
    orientBuf.put(up.z);
    orientBuf.rewind();

    AL10.alListener(AL10.AL_ORIENTATION, orientBuf);
  }
}
Example #7
0
 protected void duUpdateGeometryIndices() {
   setMode(TriMesh.Mode.Strip);
   if (getIndexBuffer() == null) {
     int[] indices = {1, 0, 4, 5, 7, 0, 3, 1, 2, 4, 6, 7, 2, 3};
     setIndexBuffer(BufferUtils.createIntBuffer(indices));
   }
 }
Example #8
0
 /**
  * Process and setup the normal position buffer.
  *
  * @param init The <code>Boolean</code> initialization flag.
  */
 private void processNormal(boolean init) {
   // Triangles have to process the normal first in case the vertices are not in order.
   for (int i = 0; i < this.triangles.length; i++) {
     this.triangles[i].processNormal();
   }
   // Average vertex normals with same vertex positions.
   if (init) this.averageNormal();
   // Put into buffer.
   FloatBuffer normalBuffer = this.getNormalBuffer();
   if (normalBuffer == null) {
     normalBuffer = BufferUtils.createVector3Buffer(this.vertices.length);
     this.setNormalBuffer(normalBuffer);
   }
   normalBuffer.clear();
   for (int i = 0; i < this.vertices.length; i++) {
     BufferUtils.setInBuffer(this.vertices[i].getNormal(), normalBuffer, i);
   }
 }
Example #9
0
 /** Process and setup the index buffer. */
 private void processIndex() {
   IntBuffer indexBuffer = BufferUtils.createIntBuffer(this.triangles.length * 3);
   indexBuffer.clear();
   for (ITriangle triangle : this.triangles) {
     for (int j = 0; j < 3; j++) {
       indexBuffer.put(triangle.getVertex(j).getIndex());
     }
   }
   indexBuffer.flip();
   this.setIndexBuffer(indexBuffer);
 }
Example #10
0
  protected void duUpdateGeometryNormals() {
    Vector3f[] vert = computeVertices(); // returns 8
    setNormalBuffer(BufferUtils.createVector3Buffer(getNormalBuffer(), 8));
    Vector3f norm = new Vector3f();

    getNormalBuffer().clear();
    for (int i = 0; i < 8; i++) {
      norm.set(vert[i]).normalizeLocal();
      getNormalBuffer().put(norm.x).put(norm.y).put(norm.z);
    }
  }
 /**
  * Loads the fragment program into a byte array.
  *
  * @see com.jme.scene.state.FragmentProgramState#load(java.net.URL)
  */
 public void load(String programContents) {
   try {
     byte[] bytes = programContents.getBytes();
     program = BufferUtils.createByteBuffer(bytes.length);
     program.put(bytes);
     program.rewind();
     programID = -1;
     setNeedsRefresh(true);
   } catch (Exception e) {
     logger.severe("Could not load fragment program: " + e);
     logger.logp(Level.SEVERE, getClass().getName(), "load(URL)", "Exception", e);
   }
 }
  /**
   * Queries OpenGL for errors in the fragment program. Errors are logged as SEVERE, noting both the
   * line number and message.
   */
  private void checkProgramError() {
    if (GL11.glGetError() == GL11.GL_INVALID_OPERATION) {
      // retrieve the error position
      IntBuffer errorloc = BufferUtils.createIntBuffer(16);
      GL11.glGetInteger(ARBProgram.GL_PROGRAM_ERROR_POSITION_ARB, errorloc);

      logger.severe(
          "Error "
              + GL11.glGetString(ARBProgram.GL_PROGRAM_ERROR_STRING_ARB)
              + " in fragment program on line "
              + errorloc.get(0));
    }
  }
Example #13
0
 protected void duUpdateGeometryVertices() {
   setVertexBuffer(BufferUtils.createVector3Buffer(getVertexBuffer(), 8));
   Vector3f[] vert = computeVertices(); // returns 8
   getVertexBuffer().clear();
   getVertexBuffer().put(vert[0].x).put(vert[0].y).put(vert[0].z);
   getVertexBuffer().put(vert[1].x).put(vert[1].y).put(vert[1].z);
   getVertexBuffer().put(vert[2].x).put(vert[2].y).put(vert[2].z);
   getVertexBuffer().put(vert[3].x).put(vert[3].y).put(vert[3].z);
   getVertexBuffer().put(vert[4].x).put(vert[4].y).put(vert[4].z);
   getVertexBuffer().put(vert[5].x).put(vert[5].y).put(vert[5].z);
   getVertexBuffer().put(vert[6].x).put(vert[6].y).put(vert[6].z);
   getVertexBuffer().put(vert[7].x).put(vert[7].y).put(vert[7].z);
 }
  /**
   * Update variableID for uniform shadervariable if needed.
   *
   * @param variable shadervaribale to update ID on
   * @param programID shader program context ID
   */
  public static void updateUniformLocation(ShaderVariable variable, int programID) {
    if (variable.variableID == -1) {
      ByteBuffer nameBuf = BufferUtils.createByteBuffer(variable.name.getBytes().length + 1);
      nameBuf.clear();
      nameBuf.put(variable.name.getBytes());
      nameBuf.rewind();

      variable.variableID = ARBShaderObjects.glGetUniformLocationARB(programID, nameBuf);

      if (variable.variableID == -1) {
        logger.severe("Shader uniform [" + variable.name + "] could not be located in shader");
      }
    }
  }
Example #15
0
 protected void duUpdateGeometryTextures() {
   if (getTextureCoords().get(0) == null) {
     getTextureCoords().set(0, new TexCoords(BufferUtils.createVector2Buffer(24)));
     FloatBuffer tex = getTextureCoords().get(0).coords;
     tex.put(1).put(0); // 0
     tex.put(0).put(0); // 1
     tex.put(0).put(1); // 2
     tex.put(1).put(1); // 3
     tex.put(1).put(0); // 4
     tex.put(0).put(0); // 5
     tex.put(1).put(1); // 6
     tex.put(0).put(1); // 7
   }
 }
  /**
   * Update variableID for attribute shadervariable if needed.
   *
   * @param variable shadervaribale to update ID on
   * @param programID shader program context ID
   */
  public static void updateAttributeLocation(ShaderVariable variable, int programID) {
    if (variable.variableID == -1) {
      ByteBuffer nameBuf = BufferUtils.createByteBuffer(variable.name.getBytes().length + 1);
      nameBuf.clear();
      nameBuf.put(variable.name.getBytes());
      nameBuf.rewind();

      variable.variableID = ARBVertexShader.glGetAttribLocationARB(programID, nameBuf);

      if (variable.variableID == -1) {
        logger.severe("Shader attribute [" + variable.name + "] could not be located in shader");
      }
    }
  }
Example #17
0
  /**
   * <code>print</code> renders the specified string to a given (x,y) location. The x, y location is
   * in terms of screen coordinates. There are currently two sets of fonts supported: NORMAL and
   * ITALICS.
   *
   * @param r
   * @param x the x screen location to start the string render.
   * @param y the y screen location to start the string render.
   * @param text the String to render.
   * @param set the mode of font: NORMAL or ITALICS.
   */
  public void print(Renderer r, float x, float y, Vector3f scale, StringBuffer text, int set) {
    RendererRecord matRecord =
        (RendererRecord) DisplaySystem.getDisplaySystem().getCurrentContext().getRendererRecord();
    if (set > 1) {
      set = 1;
    } else if (set < 0) {
      set = 0;
    }

    boolean alreadyOrtho = r.isInOrthoMode();
    if (!alreadyOrtho) r.setOrtho();
    else {
      matRecord.switchMode(GL11.GL_MODELVIEW);
      GL11.glPushMatrix();
      GL11.glLoadIdentity();
    }
    GL11.glTranslatef(x, y, 0);
    GL11.glScalef(scale.x, scale.y, scale.z);
    GL11.glListBase(base - 32 + (128 * set));

    // Put the string into a "pointer"
    if (text.length() > scratch.capacity()) {
      scratch = BufferUtils.createByteBuffer(text.length());
    } else {
      scratch.clear();
    }

    int charLen = text.length();
    for (int z = 0; z < charLen; z++) scratch.put((byte) text.charAt(z));
    scratch.flip();
    matRecord.setCurrentColor(fontColor);
    // call the list for each letter in the string.
    GL11.glCallLists(scratch);
    // set color back to white
    matRecord.setCurrentColor(1, 1, 1, 1);

    if (!alreadyOrtho) {
      r.unsetOrtho();
    } else {
      matRecord.switchMode(GL11.GL_MODELVIEW);
      GL11.glPopMatrix();
    }
  }
  private void create() {
    // first assert that the program is loaded
    if (program == null) {
      logger.severe("Attempted to apply unloaded fragment program state.");
      return;
    }

    IntBuffer buf = BufferUtils.createIntBuffer(1);

    ARBProgram.glGenProgramsARB(buf);
    ARBProgram.glBindProgramARB(ARBFragmentProgram.GL_FRAGMENT_PROGRAM_ARB, buf.get(0));
    ARBProgram.glProgramStringARB(
        ARBFragmentProgram.GL_FRAGMENT_PROGRAM_ARB,
        ARBProgram.GL_PROGRAM_FORMAT_ASCII_ARB,
        program);

    checkProgramError();

    programID = buf.get(0);
  }
  /**
   * Loads the fragment program into a byte array.
   *
   * @see com.jme.scene.state.FragmentProgramState#load(java.net.URL)
   */
  public void load(java.net.URL file) {
    InputStream inputStream = null;
    try {
      ByteArrayOutputStream outputStream = new ByteArrayOutputStream(16 * 1024);
      inputStream = new BufferedInputStream(file.openStream());
      byte[] buffer = new byte[1024];
      int byteCount = -1;

      // Read the byte content into the output stream first
      while ((byteCount = inputStream.read(buffer)) > 0) {
        outputStream.write(buffer, 0, byteCount);
      }

      // Set data with byte content from stream
      byte data[] = outputStream.toByteArray();

      // Release resources
      inputStream.close();
      outputStream.close();

      program = BufferUtils.createByteBuffer(data.length);
      program.put(data);
      program.rewind();
      programID = -1;
      setNeedsRefresh(true);
    } catch (Exception e) {
      logger.severe("Could not load fragment program: " + e);
      logger.logp(Level.SEVERE, getClass().getName(), "load(URL)", "Exception", e);
    } finally {
      // Ensure that the stream is closed, even if there is an exception.
      if (inputStream != null) {
        try {
          inputStream.close();
        } catch (IOException closeFailure) {
          logger.log(Level.WARNING, "Failed to close the fragment program", closeFailure);
        }
      }
    }
  }
  /**
   * <code>tessellate</code> generates the <code>BezierMesh</code> vertices from the supplied patch
   * and detail level. This method is called when patch is set, and therefore, should normally have
   * to be called. However, if patch is changed externally, and you wish to update the mesh, a call
   * to <code>tessellate</code> is appropriate.
   */
  public void tessellate() {
    if (patch == null) {
      return;
    }
    int u = 0, v;
    float py, px, pyold;
    int detailLevel = patch.getDetailLevel();

    Vector3f[] temp = new Vector3f[4];
    Vector3f[] last = new Vector3f[detailLevel + 1];

    temp[0] = patch.getAnchor(0, 3);
    temp[1] = patch.getAnchor(1, 3);
    temp[2] = patch.getAnchor(2, 3);
    temp[3] = patch.getAnchor(3, 3);

    for (v = 0; v <= detailLevel; v++) {
      px = ((float) v) / ((float) detailLevel);
      last[v] = calcBerstein(px, temp);
    }

    u = 1;
    setVertexCount(((detailLevel * 2) + 2) * detailLevel);
    setVertexBuffer(BufferUtils.createVector3Buffer(getVertexCount()));
    setTextureCoords(new TexCoords(BufferUtils.createFloatBuffer(getVertexCount() * 2), 2), 0);
    setNormalBuffer(BufferUtils.createVector3Buffer(getVertexCount()));

    setTriangleQuantity(detailLevel * detailLevel * 6);
    setIndexBuffer(BufferUtils.createIntBuffer(getTriangleCount() * 3));

    getVertexBuffer().clear();
    FloatBuffer src = getTextureCoords().get(0).coords;
    src.clear();
    for (u = 1; u <= detailLevel; u++) {
      py = ((float) u) / ((float) detailLevel);
      pyold = (u - 1.0f) / (detailLevel);
      temp[0] = calcBerstein(py, patch.getAnchors()[0]);
      temp[1] = calcBerstein(py, patch.getAnchors()[1]);
      temp[2] = calcBerstein(py, patch.getAnchors()[2]);
      temp[3] = calcBerstein(py, patch.getAnchors()[3]);

      for (v = 0; v <= detailLevel; v++) {
        px = ((float) v) / ((float) detailLevel);
        src.put(pyold).put(px);
        getVertexBuffer().put(last[v].x).put(last[v].y).put(last[v].z);
        last[v] = calcBerstein(px, temp);
        src.put(py).put(px);
        getVertexBuffer().put(last[v].x).put(last[v].y).put(last[v].z);
      }
    }

    int index = -1;
    for (int i = 0; i < getTriangleCount(); i = i + 6) {

      index++;
      if (i > 0 && i % (detailLevel * 6) == 0) {
        index += 1;
      }

      getIndexBuffer().put(2 * index);
      getIndexBuffer().put((2 * index) + 1);
      getIndexBuffer().put((2 * index) + 2);

      getIndexBuffer().put((2 * index) + 3);
      getIndexBuffer().put((2 * index) + 2);
      getIndexBuffer().put((2 * index) + 1);
    }

    setNormalBuffer(BufferUtils.createVector3Buffer(getVertexCount()));
    Vector3f oppositePoint = new Vector3f();
    Vector3f adjacentPoint = new Vector3f();
    Vector3f rootPoint = new Vector3f();
    Vector3f tempNorm = new Vector3f();
    int adj = 0, opp = 0, normalIndex = 0;
    for (int i = 0; i < detailLevel; i++) {
      for (int j = 0; j < (detailLevel * 2) + 2; j++) {
        BufferUtils.populateFromBuffer(rootPoint, getVertexBuffer(), normalIndex);
        if (j % 2 == 0) {
          if (i == 0) {
            if (j < (detailLevel * 2)) {
              // right cross up
              adj = normalIndex + 1;
              opp = normalIndex + 2;
            } else {
              // down cross right
              adj = normalIndex - 1;
              opp = normalIndex + 1;
            }
          } else {
            int ind = normalIndex - (detailLevel * 2 + 1);
            getNormalBuffer().rewind();
            tempNorm.x = getNormalBuffer().get(ind * 3);
            tempNorm.y = getNormalBuffer().get(ind * 3 + 1);
            tempNorm.z = getNormalBuffer().get(ind * 3 + 2);
            tempNorm.normalizeLocal();
            BufferUtils.setInBuffer(tempNorm, getNormalBuffer(), normalIndex);
            normalIndex++;
            continue;
          }
        } else {
          if (j < (detailLevel * 2) + 1) {
            // up cross left
            adj = normalIndex + 2;
            opp = normalIndex - 1;
          } else {
            // left cross down
            adj = normalIndex - 1;
            opp = normalIndex - 2;
          }
        }
        BufferUtils.populateFromBuffer(adjacentPoint, getVertexBuffer(), adj);
        BufferUtils.populateFromBuffer(oppositePoint, getVertexBuffer(), opp);
        tempNorm
            .set(adjacentPoint)
            .subtractLocal(rootPoint)
            .crossLocal(oppositePoint.subtractLocal(rootPoint))
            .normalizeLocal();
        BufferUtils.setInBuffer(tempNorm, getNormalBuffer(), normalIndex);
        normalIndex++;
      }
    }
  }
public class LightStateRecord extends StateRecord {
  private ArrayList<LightRecord> lightList = new ArrayList<LightRecord>();
  private int lightMask;
  private int backLightMask;
  private boolean twoSidedOn;
  public ColorRGBA globalAmbient = new ColorRGBA(-1, -1, -1, -1);
  private boolean enabled;
  private boolean localViewer;
  private boolean separateSpecular;

  // buffer for light colors.
  public FloatBuffer lightBuffer = BufferUtils.createColorBuffer(1);

  public int getBackLightMask() {
    return backLightMask;
  }

  public void setBackLightMask(int backLightMask) {
    this.backLightMask = backLightMask;
  }

  public LightRecord getLightRecord(int index) {
    if (lightList.size() <= index) {
      return null;
    }

    return lightList.get(index);
  }

  public void setLightRecord(LightRecord lr, int index) {
    while (lightList.size() <= index) {
      lightList.add(null);
    }

    lightList.set(index, lr);
  }

  public int getLightMask() {
    return lightMask;
  }

  public void setLightMask(int lightMask) {
    this.lightMask = lightMask;
  }

  public boolean isTwoSidedOn() {
    return twoSidedOn;
  }

  public void setTwoSidedOn(boolean twoSidedOn) {
    this.twoSidedOn = twoSidedOn;
  }

  public boolean isEnabled() {
    return enabled;
  }

  public void setEnabled(boolean enabled) {
    this.enabled = enabled;
  }

  public boolean isLocalViewer() {
    return localViewer;
  }

  public void setLocalViewer(boolean localViewer) {
    this.localViewer = localViewer;
  }

  public boolean isSeparateSpecular() {
    return separateSpecular;
  }

  public void setSeparateSpecular(boolean seperateSpecular) {
    this.separateSpecular = seperateSpecular;
  }

  @Override
  public void invalidate() {
    super.invalidate();
    for (LightRecord record : lightList) {
      record.invalidate();
    }

    lightMask = -1;
    backLightMask = -1;
    twoSidedOn = false;
    enabled = false;
    localViewer = false;
    separateSpecular = false;
    globalAmbient.set(-1, -1, -1, -1);
  }

  @Override
  public void validate() {
    super.validate();
    for (LightRecord record : lightList) {
      record.validate();
    }
  }
}
Example #22
0
 /**
  * Constructor instantiates a new <code>LWJGLFont</code> object. The initial color is set to
  * white.
  */
 public LWJGLFont() {
   fontColor = new ColorRGBA(1, 1, 1, 1);
   scratch = BufferUtils.createByteBuffer(1);
   buildDisplayList();
 }