Пример #1
0
  Node createDebugGeometry() {
    Line l = new Line(from.getPlanet().getPosition(), to.getPlanet().getPosition());

    line = new Geometry("Line #" + from.getPlanet().getID() + " to #" + to.getPlanet().getID(), l);

    Material material =
        new Material(
            SolarWarsApplication.getInstance().getAssetManager(),
            "Common/MatDefs/Misc/Unshaded.j3md");

    Player p = from.getPlanet().getOwner();
    ColorRGBA c;
    if (p == null) {
      c = ColorRGBA.White.clone();
      c.a = 0.5f;
      material.setColor("Color", c);
    } else {
      c = p.getColor();
      c.a = 0.5f;
      material.setColor("Color", c);
    }
    material.getAdditionalRenderState().setBlendMode(RenderState.BlendMode.Alpha);
    line.setMaterial(material);

    createLabel();
    Node lineNode = new Node(line.getName() + "_Node");
    lineNode.attachChild(line);
    lineNode.attachChild(label);
    //        Vector3f pos = to.getPlanet().getPosition().
    //                subtract(from.getPlanet().getPosition());
    //        lineNode.setLocalTranslation(pos.mult(0.5f));
    return lineNode;
  }
Пример #2
0
 private Material getMaterial(ColorRGBA color) {
   Material mat = new Material(main.getAssetManager(), "Common/MatDefs/Light/Lighting.j3md");
   mat.setColor("Diffuse", color);
   ColorRGBA clone = color.clone();
   clone.multLocal(0.8f);
   clone.a = 1f;
   mat.setColor("Ambient", clone);
   mat.setBoolean("UseMaterialColors", true);
   return mat;
 }
Пример #3
0
 private ColorRGBA getAmbientColor(LightList lightList) {
   ambientLightColor.set(0, 0, 0, 1);
   for (int j = 0; j < lightList.size(); j++) {
     Light l = lightList.get(j);
     if (l instanceof AmbientLight) {
       ambientLightColor.addLocal(l.getColor());
     }
   }
   ambientLightColor.a = 1.0f;
   return ambientLightColor;
 }
Пример #4
0
  @Override
  public void simpleInitApp() {
    // add a random cube
    Box b = new Box(1, 1, 1);
    Geometry geom = new Geometry("Box", b);
    Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
    mat.setColor("Color", ColorRGBA.randomColor());
    geom.setMaterial(mat);
    geom.move(
        (FastMath.nextRandomFloat() * 10) - 5,
        (FastMath.nextRandomFloat() * 10) - 5,
        (FastMath.nextRandomFloat() * -10));
    rootNode.attachChild(geom);

    // add saved cubes
    String userHome = System.getProperty("user.home");
    BinaryImporter importer = BinaryImporter.getInstance();
    importer.setAssetManager(assetManager);
    try {
      File file = new File(userHome + "/mycoolgame/savedgame.j3o");
      Node sceneNode = (Node) importer.load(file);
      sceneNode.setName("My restored node");
      rootNode.attachChild(sceneNode);
      Logger.getLogger(SaveAndLoad.class.getName()).log(Level.INFO, "Success: Loaded saved node.");
    } catch (IOException ex) {
      Logger.getLogger(SaveAndLoad.class.getName())
          .log(Level.INFO, "Warning: Could not load saved node.", ex);
    }
  }
Пример #5
0
 protected void resetMaterial() {
   ambient.set(ColorRGBA.DarkGray);
   diffuse.set(ColorRGBA.LightGray);
   specular.set(ColorRGBA.Black);
   shininess = 16;
   disallowAmbient = false;
   disallowSpecular = false;
   shadeless = false;
   transparent = false;
   matName = null;
   diffuseMap = null;
   specularMap = null;
   normalMap = null;
   alphaMap = null;
   alpha = 1;
 }
  private void displayPlayersPositions() {
    Map<Vector3f, Integer> playerPositions = gm.getMapManager().getBoard().getPlayerPositions();

    Iterator it = playerPositions.entrySet().iterator();
    while (it.hasNext()) {
      Map.Entry pairs = (Map.Entry) it.next();
      Vector3f pos = (Vector3f) pairs.getKey();
      Integer number = (Integer) pairs.getValue();

      Box b = new Box(Vector3f.ZERO, 2.0f, 1.0f, 2.0f);
      Geometry geom = new Geometry("Box", b);
      Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md");
      mat.setColor("Color", ColorRGBA.randomColor());

      geom.setMaterial(mat);
      geom.setLocalTranslation(pos.x, 0, pos.z);

      String geomName = "PLAYERMARKER";
      geom.setName(geomName);
      geom.setUserData(geomName, pos);

      playerNodes.attachChild(geom);

      displayLocationName(number.toString(), new Vector3f(pos.x, 1, pos.z));
    }
  }
Пример #7
0
 /** A cube object for target practice */
 protected Geometry makeCube(String name, float x, float y, float z) {
   Box box = new Box(new Vector3f(x, y, z), 1, 1, 1);
   Geometry cube = new Geometry(name, box);
   Material mat1 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
   mat1.setColor("Color", ColorRGBA.randomColor());
   cube.setMaterial(mat1);
   return cube;
 }
Пример #8
0
 Range(int start, String colorStr) {
   this.start = start;
   this.color = new ColorRGBA();
   if (colorStr.length() >= 6) {
     color.set(
         Integer.parseInt(colorStr.subSequence(0, 2).toString(), 16) / 255f,
         Integer.parseInt(colorStr.subSequence(2, 4).toString(), 16) / 255f,
         Integer.parseInt(colorStr.subSequence(4, 6).toString(), 16) / 255f,
         1);
     if (colorStr.length() == 8) {
       color.a = Integer.parseInt(colorStr.subSequence(6, 8).toString(), 16) / 255f;
     }
   } else {
     color.set(
         Integer.parseInt(Character.toString(colorStr.charAt(0)), 16) / 15f,
         Integer.parseInt(Character.toString(colorStr.charAt(1)), 16) / 15f,
         Integer.parseInt(Character.toString(colorStr.charAt(2)), 16) / 15f,
         1);
     if (colorStr.length() == 4) {
       color.a = Integer.parseInt(Character.toString(colorStr.charAt(3)), 16) / 15f;
     }
   }
 }
Пример #9
0
  protected void createMaterial() {
    Material material;

    if (alpha < 1f && transparent) {
      diffuse.a = alpha;
    }

    if (shadeless) {
      material = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
      material.setColor("Color", diffuse.clone());
      material.setTexture("ColorMap", diffuseMap);
      // TODO: Add handling for alpha map?
    } else {
      material = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
      material.setBoolean("UseMaterialColors", true);
      material.setColor("Ambient", ambient.clone());
      material.setColor("Diffuse", diffuse.clone());
      material.setColor("Specular", specular.clone());
      material.setFloat("Shininess", shininess); // prevents "premature culling" bug

      if (diffuseMap != null) material.setTexture("DiffuseMap", diffuseMap);
      if (specularMap != null) material.setTexture("SpecularMap", specularMap);
      if (normalMap != null) material.setTexture("NormalMap", normalMap);
      if (alphaMap != null) material.setTexture("AlphaMap", alphaMap);
    }

    if (transparent) {
      material.setTransparent(true);
      material.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
      material.getAdditionalRenderState().setAlphaTest(true);
      material.getAdditionalRenderState().setAlphaFallOff(0.01f);
    }

    material.setName(matName);
    matList.put(matName, material);
  }
Пример #10
0
  Line(AssetManager assetmanager_) {
    assetmanager = assetmanager_;

    Mesh mesh = new Mesh();
    mesh.setMode(Mesh.Mode.Lines);
    mesh.setBuffer(VertexBuffer.Type.Position, 3, new float[] {0, 0, 0, 0, 0, 0});
    mesh.setBuffer(VertexBuffer.Type.Index, 2, new short[] {0, 1});

    // Box b = new Box(Vector3f.ZERO, 1, 1, 1);
    geom = new Geometry("Box", mesh);
    Material mat = new Material(assetmanager, "Common/MatDefs/Misc/Unshaded.j3md");
    mat.setColor("Color", ColorRGBA.randomColor());
    geom.setMaterial(mat);

    geom.getMesh().getBuffer(Type.Position).setUpdateNeeded();
    // geom.getMesh().getBuffer(Type.TexCoord).setUpdateNeeded();
    geom.getMesh().getBuffer(Type.Index).setUpdateNeeded();

    geom.getMesh().updateBound();
    geom.getMesh().updateCounts();
    geom.updateModelBound();
  }
Пример #11
0
 protected ColorRGBA readColor() {
   ColorRGBA v = new ColorRGBA();
   v.set(scan.nextFloat(), scan.nextFloat(), scan.nextFloat(), 1.0f);
   return v;
 }
Пример #12
0
  protected boolean readLine() {
    if (!scan.hasNext()) {
      return false;
    }

    String cmd = scan.next().toLowerCase();
    if (cmd.startsWith("#")) {
      // skip entire comment until next line
      return skipLine();
    } else if (cmd.equals("newmtl")) {
      String name = scan.next();
      startMaterial(name);
    } else if (cmd.equals("ka")) {
      ambient.set(readColor());
    } else if (cmd.equals("kd")) {
      diffuse.set(readColor());
    } else if (cmd.equals("ks")) {
      specular.set(readColor());
    } else if (cmd.equals("ns")) {
      float shiny = scan.nextFloat();
      if (shiny >= 1) {
        shininess = shiny; /* (128f / 1000f)*/
        if (specular.equals(ColorRGBA.Black)) {
          specular.set(ColorRGBA.White);
        }
      } else {
        // For some reason blender likes to export Ns 0 statements
        // Ignore Ns 0 instead of setting it
      }

    } else if (cmd.equals("d") || cmd.equals("tr")) {
      float tempAlpha = scan.nextFloat();
      if (tempAlpha != 0) {
        alpha = tempAlpha;
        transparent = true;
      }
    } else if (cmd.equals("map_ka")) {
      // ignore it for now
      return skipLine();
    } else if (cmd.equals("map_kd")) {
      String path = nextStatement();
      diffuseMap = loadTexture(path);
    } else if (cmd.equals("map_bump") || cmd.equals("bump")) {
      if (normalMap == null) {
        String path = nextStatement();
        normalMap = loadTexture(path);
      }
    } else if (cmd.equals("map_ks")) {
      String path = nextStatement();
      specularMap = loadTexture(path);
      if (specularMap != null) {
        // NOTE: since specular color is modulated with specmap
        // make sure we have it set
        if (specular.equals(ColorRGBA.Black)) {
          specular.set(ColorRGBA.White);
        }
      }
    } else if (cmd.equals("map_d")) {
      String path = scan.next();
      alphaMap = loadTexture(path);
      transparent = true;
    } else if (cmd.equals("illum")) {
      int mode = scan.nextInt();

      switch (mode) {
        case 0:
          // no lighting
          shadeless = true;
          break;
        case 1:
          disallowSpecular = true;
          break;
        case 2:
        case 3:
        case 5:
        case 8:
          break;
        case 4:
        case 6:
        case 7:
        case 9:
          // Enable transparency
          // Works best if diffuse map has an alpha channel
          transparent = true;
          break;
      }
    } else if (cmd.equals("ke") || cmd.equals("ni")) {
      // Ni: index of refraction - unsupported in jME
      // Ke: emission color
      return skipLine();
    } else {
      logger.log(Level.WARNING, "Unknown statement in MTL! {0}", cmd);
      return skipLine();
    }

    return true;
  }
Пример #13
0
  public void setLighting(LightList list) {
    // XXX: This is abuse of setLighting() to
    // apply fixed function bindings
    // and do other book keeping.
    if (list == null || list.size() == 0) {
      glDisable(GL_LIGHTING);
      applyFixedFuncBindings(false);
      setModelView(worldMatrix, viewMatrix);
      return;
    }

    // Number of lights set previously
    int numLightsSetPrev = lightList.size();

    // If more than maxLights are defined, they will be ignored.
    // The GL1 renderer is not permitted to crash due to a
    // GL1 limitation. It must render anything that the GL2 renderer
    // can render (even incorrectly).
    lightList.clear();
    materialAmbientColor.set(0, 0, 0, 0);

    for (int i = 0; i < list.size(); i++) {
      Light l = list.get(i);
      if (l.getType() == Light.Type.Ambient) {
        // Gather
        materialAmbientColor.addLocal(l.getColor());
      } else {
        // Add to list
        lightList.add(l);

        // Once maximum lights reached, exit loop.
        if (lightList.size() >= maxLights) {
          break;
        }
      }
    }

    applyFixedFuncBindings(true);

    glEnable(GL_LIGHTING);

    fb16.clear();
    fb16.put(materialAmbientColor.r)
        .put(materialAmbientColor.g)
        .put(materialAmbientColor.b)
        .put(1)
        .flip();

    glLightModel(GL_LIGHT_MODEL_AMBIENT, fb16);

    if (context.matrixMode != GL_MODELVIEW) {
      glMatrixMode(GL_MODELVIEW);
      context.matrixMode = GL_MODELVIEW;
    }
    // Lights are already in world space, so just convert
    // them to view space.
    glLoadMatrix(storeMatrix(viewMatrix, fb16));

    for (int i = 0; i < lightList.size(); i++) {
      int glLightIndex = GL_LIGHT0 + i;
      Light light = lightList.get(i);
      Light.Type lightType = light.getType();
      ColorRGBA col = light.getColor();
      Vector3f pos;

      // Enable the light
      glEnable(glLightIndex);

      // OGL spec states default value for light ambient is black
      switch (lightType) {
        case Directional:
          DirectionalLight dLight = (DirectionalLight) light;

          fb16.clear();
          fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
          glLight(glLightIndex, GL_DIFFUSE, fb16);
          glLight(glLightIndex, GL_SPECULAR, fb16);

          pos = tempVec.set(dLight.getDirection()).negateLocal().normalizeLocal();
          fb16.clear();
          fb16.put(pos.x).put(pos.y).put(pos.z).put(0.0f).flip();
          glLight(glLightIndex, GL_POSITION, fb16);
          glLightf(glLightIndex, GL_SPOT_CUTOFF, 180);
          break;
        case Point:
          PointLight pLight = (PointLight) light;

          fb16.clear();
          fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
          glLight(glLightIndex, GL_DIFFUSE, fb16);
          glLight(glLightIndex, GL_SPECULAR, fb16);

          pos = pLight.getPosition();
          fb16.clear();
          fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip();
          glLight(glLightIndex, GL_POSITION, fb16);
          glLightf(glLightIndex, GL_SPOT_CUTOFF, 180);

          if (pLight.getRadius() > 0) {
            // Note: this doesn't follow the same attenuation model
            // as the one used in the lighting shader.
            glLightf(glLightIndex, GL_CONSTANT_ATTENUATION, 1);
            glLightf(glLightIndex, GL_LINEAR_ATTENUATION, pLight.getInvRadius() * 2);
            glLightf(
                glLightIndex,
                GL_QUADRATIC_ATTENUATION,
                pLight.getInvRadius() * pLight.getInvRadius());
          } else {
            glLightf(glLightIndex, GL_CONSTANT_ATTENUATION, 1);
            glLightf(glLightIndex, GL_LINEAR_ATTENUATION, 0);
            glLightf(glLightIndex, GL_QUADRATIC_ATTENUATION, 0);
          }

          break;
        case Spot:
          SpotLight sLight = (SpotLight) light;

          fb16.clear();
          fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
          glLight(glLightIndex, GL_DIFFUSE, fb16);
          glLight(glLightIndex, GL_SPECULAR, fb16);

          pos = sLight.getPosition();
          fb16.clear();
          fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip();
          glLight(glLightIndex, GL_POSITION, fb16);

          Vector3f dir = sLight.getDirection();
          fb16.clear();
          fb16.put(dir.x).put(dir.y).put(dir.z).put(1.0f).flip();
          glLight(glLightIndex, GL_SPOT_DIRECTION, fb16);

          float outerAngleRad = sLight.getSpotOuterAngle();
          float innerAngleRad = sLight.getSpotInnerAngle();
          float spotCut = outerAngleRad * FastMath.RAD_TO_DEG;
          float spotExpo = 0.0f;
          if (outerAngleRad > 0) {
            spotExpo = (1.0f - (innerAngleRad / outerAngleRad)) * 128.0f;
          }

          glLightf(glLightIndex, GL_SPOT_CUTOFF, spotCut);
          glLightf(glLightIndex, GL_SPOT_EXPONENT, spotExpo);

          if (sLight.getSpotRange() > 0) {
            glLightf(glLightIndex, GL_LINEAR_ATTENUATION, sLight.getInvSpotRange());
          } else {
            glLightf(glLightIndex, GL_LINEAR_ATTENUATION, 0);
          }

          break;
        default:
          throw new UnsupportedOperationException("Unrecognized light type: " + lightType);
      }
    }

    // Disable lights after the index
    for (int i = lightList.size(); i < numLightsSetPrev; i++) {
      glDisable(GL_LIGHT0 + i);
    }

    // This will set view matrix as well.
    setModelView(worldMatrix, viewMatrix);
  }
Пример #14
0
  protected void renderMultipassLighting(Shader shader, Geometry g, RenderManager rm) {

    Renderer r = rm.getRenderer();
    LightList lightList = g.getWorldLightList();
    Uniform lightDir = shader.getUniform("g_LightDirection");
    Uniform lightColor = shader.getUniform("g_LightColor");
    Uniform lightPos = shader.getUniform("g_LightPosition");
    Uniform ambientColor = shader.getUniform("g_AmbientLightColor");
    boolean isFirstLight = true;
    boolean isSecondLight = false;

    for (int i = 0; i < lightList.size(); i++) {
      Light l = lightList.get(i);
      if (l instanceof AmbientLight) {
        continue;
      }

      if (isFirstLight) {
        // set ambient color for first light only
        ambientColor.setValue(VarType.Vector4, getAmbientColor(lightList));
        isFirstLight = false;
        isSecondLight = true;
      } else if (isSecondLight) {
        ambientColor.setValue(VarType.Vector4, ColorRGBA.Black);
        // apply additive blending for 2nd and future lights
        r.applyRenderState(additiveLight);
        isSecondLight = false;
      }

      TempVars vars = TempVars.get();
      Quaternion tmpLightDirection = vars.quat1;
      Quaternion tmpLightPosition = vars.quat2;
      ColorRGBA tmpLightColor = vars.color;
      Vector4f tmpVec = vars.vect4f;

      ColorRGBA color = l.getColor();
      tmpLightColor.set(color);
      tmpLightColor.a = l.getType().getId();
      lightColor.setValue(VarType.Vector4, tmpLightColor);

      switch (l.getType()) {
        case Directional:
          DirectionalLight dl = (DirectionalLight) l;
          Vector3f dir = dl.getDirection();

          tmpLightPosition.set(dir.getX(), dir.getY(), dir.getZ(), -1);
          lightPos.setValue(VarType.Vector4, tmpLightPosition);
          tmpLightDirection.set(0, 0, 0, 0);
          lightDir.setValue(VarType.Vector4, tmpLightDirection);
          break;
        case Point:
          PointLight pl = (PointLight) l;
          Vector3f pos = pl.getPosition();
          float invRadius = pl.getInvRadius();

          tmpLightPosition.set(pos.getX(), pos.getY(), pos.getZ(), invRadius);
          lightPos.setValue(VarType.Vector4, tmpLightPosition);
          tmpLightDirection.set(0, 0, 0, 0);
          lightDir.setValue(VarType.Vector4, tmpLightDirection);
          break;
        case Spot:
          SpotLight sl = (SpotLight) l;
          Vector3f pos2 = sl.getPosition();
          Vector3f dir2 = sl.getDirection();
          float invRange = sl.getInvSpotRange();
          float spotAngleCos = sl.getPackedAngleCos();

          tmpLightPosition.set(pos2.getX(), pos2.getY(), pos2.getZ(), invRange);
          lightPos.setValue(VarType.Vector4, tmpLightPosition);

          // We transform the spot directoin in view space here to save 5 varying later in the
          // lighting shader
          // one vec4 less and a vec4 that becomes a vec3
          // the downside is that spotAngleCos decoding happen now in the frag shader.
          tmpVec.set(dir2.getX(), dir2.getY(), dir2.getZ(), 0);
          rm.getCurrentCamera().getViewMatrix().mult(tmpVec, tmpVec);
          tmpLightDirection.set(tmpVec.getX(), tmpVec.getY(), tmpVec.getZ(), spotAngleCos);

          lightDir.setValue(VarType.Vector4, tmpLightDirection);

          break;
        default:
          throw new UnsupportedOperationException("Unknown type of light: " + l.getType());
      }
      vars.release();
      r.setShader(shader);
      r.renderMesh(g.getMesh(), g.getLodLevel(), 1);
    }

    if (isFirstLight && lightList.size() > 0) {
      // There are only ambient lights in the scene. Render
      // a dummy "normal light" so we can see the ambient
      ambientColor.setValue(VarType.Vector4, getAmbientColor(lightList));
      lightColor.setValue(VarType.Vector4, ColorRGBA.BlackNoAlpha);
      lightPos.setValue(VarType.Vector4, nullDirLight);
      r.setShader(shader);
      r.renderMesh(g.getMesh(), g.getLodLevel(), 1);
    }
  }
Пример #15
0
 private ColorRGBA convertColor(Color inColor, ColorRGBA outColor) {
   return outColor.set(
       inColor.getRed(), inColor.getGreen(), inColor.getBlue(), inColor.getAlpha());
 }
Пример #16
0
  /**
   * Uploads the lights in the light list as two uniform arrays.<br>
   * <br>
   * *
   *
   * <p><code>uniform vec4 g_LightColor[numLights];</code><br>
   * // g_LightColor.rgb is the diffuse/specular color of the light.<br>
   * // g_Lightcolor.a is the type of light, 0 = Directional, 1 = Point, <br>
   * // 2 = Spot. <br>
   * <br>
   * <code>uniform vec4 g_LightPosition[numLights];</code><br>
   * // g_LightPosition.xyz is the position of the light (for point lights)<br>
   * // or the direction of the light (for directional lights).<br>
   * // g_LightPosition.w is the inverse radius (1/r) of the light (for attenuation) <br>
   */
  protected void updateLightListUniforms(Shader shader, Geometry g, int numLights) {
    if (numLights == 0) { // this shader does not do lighting, ignore.
      return;
    }

    LightList lightList = g.getWorldLightList();
    Uniform lightColor = shader.getUniform("g_LightColor");
    Uniform lightPos = shader.getUniform("g_LightPosition");
    Uniform lightDir = shader.getUniform("g_LightDirection");
    lightColor.setVector4Length(numLights);
    lightPos.setVector4Length(numLights);
    lightDir.setVector4Length(numLights);

    Uniform ambientColor = shader.getUniform("g_AmbientLightColor");
    ambientColor.setValue(VarType.Vector4, getAmbientColor(lightList));

    int lightIndex = 0;

    for (int i = 0; i < numLights; i++) {
      if (lightList.size() <= i) {
        lightColor.setVector4InArray(0f, 0f, 0f, 0f, lightIndex);
        lightPos.setVector4InArray(0f, 0f, 0f, 0f, lightIndex);
      } else {
        Light l = lightList.get(i);
        ColorRGBA color = l.getColor();
        lightColor.setVector4InArray(
            color.getRed(), color.getGreen(), color.getBlue(), l.getType().getId(), i);

        switch (l.getType()) {
          case Directional:
            DirectionalLight dl = (DirectionalLight) l;
            Vector3f dir = dl.getDirection();
            lightPos.setVector4InArray(dir.getX(), dir.getY(), dir.getZ(), -1, lightIndex);
            break;
          case Point:
            PointLight pl = (PointLight) l;
            Vector3f pos = pl.getPosition();
            float invRadius = pl.getInvRadius();
            lightPos.setVector4InArray(pos.getX(), pos.getY(), pos.getZ(), invRadius, lightIndex);
            break;
          case Spot:
            SpotLight sl = (SpotLight) l;
            Vector3f pos2 = sl.getPosition();
            Vector3f dir2 = sl.getDirection();
            float invRange = sl.getInvSpotRange();
            float spotAngleCos = sl.getPackedAngleCos();

            lightPos.setVector4InArray(pos2.getX(), pos2.getY(), pos2.getZ(), invRange, lightIndex);
            lightDir.setVector4InArray(
                dir2.getX(), dir2.getY(), dir2.getZ(), spotAngleCos, lightIndex);
            break;
          case Ambient:
            // skip this light. Does not increase lightIndex
            continue;
          default:
            throw new UnsupportedOperationException("Unknown type of light: " + l.getType());
        }
      }

      lightIndex++;
    }

    while (lightIndex < numLights) {
      lightColor.setVector4InArray(0f, 0f, 0f, 0f, lightIndex);
      lightPos.setVector4InArray(0f, 0f, 0f, 0f, lightIndex);

      lightIndex++;
    }
  }
Пример #17
0
 void setColor(ColorRGBA color) {
   this.colorInt = color.asIntRGBA();
   invalidate();
 }