com.badlogic.gdx.graphics.g3d.Attribute Java Examples

protected void updateEnvironment(){
	computedEnvironement.setCache(environment);
	pointLights.lights.clear();
	spotLights.lights.clear();
	if(environment != null) {
		for(Attribute a : environment){
			if(a instanceof PointLightsAttribute){
				pointLights.lights.addAll(((PointLightsAttribute) a).lights);
				computedEnvironement.replaceCache(pointLights);
			}else if(a instanceof SpotLightsAttribute){
				spotLights.lights.addAll(((SpotLightsAttribute) a).lights);
				computedEnvironement.replaceCache(spotLights);
			}else{
				computedEnvironement.set(a);
			}
		}
	}
	cullLights();
}
 

/**
 * fast way to copy only references
 * @param env
 */
public void setCache(Environment env){
	this.mask = env.getMask();
	this.attributes.clear();
	for(Attribute a : env) this.attributes.add(a);
	this.shadowMap  = env.shadowMap;
	this.sorted = true;
}
 

@Override
public Attribute copy () {
	return new FogAttribute(type).set(value);
}
 

@Override
public int compareTo(Attribute o) {
    return -1; // FIXME implement comparing
}
 

@Override
public int compareTo(Attribute o) {
    if (type != o.type) return type < o.type ? -1 : 1;
    return 0; // FIXME implement comparing
}
 

@Override
public int compareTo(Attribute o) {
    if (type != o.type) return type < o.type ? -1 : 1;
    return 0; // FIXME implement comparing
}
 

@Override
public int compareTo(Attribute o) {
    if (type != o.type) return type < o.type ? -1 : 1;
    TerrainTexture otherValue = ((TerrainTextureAttribute) o).terrainTexture;
    return terrainTexture.equals(otherValue) ? 0 : -1;
}
 

@Override
public Attribute copy() {
    return new TerrainTextureAttribute(this);
}
 

private void export(Material material) {
	if(base.materialMapping.contains(material, true)) return;
	base.materialMapping.add(material);
	
	GLTFMaterial m = new GLTFMaterial();
	if(base.root.materials == null) base.root.materials = new Array<GLTFMaterial>();
	base.root.materials.add(m);
	

	m.name = material.id;
	
	boolean blending = false;
	for(Attribute a : material){
		if(a.type == ColorAttribute.Diffuse){
			pbr(m).baseColorFactor = GLTFExportTypes.rgba(defaultNull(Color.WHITE, (ColorAttribute)a));
		}
		else if(a.type == PBRColorAttribute.BaseColorFactor){
			pbr(m).baseColorFactor = GLTFExportTypes.rgba(defaultNull(Color.WHITE, (PBRColorAttribute)a));
		}
		else if(a.type == ColorAttribute.Emissive){
			m.emissiveFactor = GLTFExportTypes.rgb(defaultNull(Color.BLACK, (ColorAttribute)a));
		}
		else if(a.type == BlendingAttribute.Type){
			blending = true;
		}
		else if(a.type == IntAttribute.CullFace){
			m.doubleSided = defaultNull(true, ((IntAttribute)a).value == 0);
		}
		else if(a.type == FloatAttribute.AlphaTest){
			m.alphaCutoff = ((FloatAttribute)a).value;
		}
		else if(a.type == PBRFloatAttribute.Metallic){
			pbr(m).metallicFactor = ((PBRFloatAttribute)a).value;
		}
		else if(a.type == PBRFloatAttribute.Roughness){
			pbr(m).roughnessFactor = ((PBRFloatAttribute)a).value;
		}
		else if(a.type == PBRTextureAttribute.BaseColorTexture){
			pbr(m).baseColorTexture = texture((PBRTextureAttribute)a);
		}
		else if(a.type == PBRTextureAttribute.MetallicRoughnessTexture){
			pbr(m).metallicRoughnessTexture = texture((PBRTextureAttribute)a);
		}
		else if(a.type == PBRTextureAttribute.EmissiveTexture){
			m.emissiveTexture = texture((PBRTextureAttribute)a);
		}
		else if(a.type == PBRTextureAttribute.NormalTexture){
			m.normalTexture = normalTexture((PBRTextureAttribute)a, material);
		}
		else if(a.type == PBRTextureAttribute.OcclusionTexture){
			m.occlusionTexture = occlusionTexture((PBRTextureAttribute)a, material);
		}
	}
	if(blending){
		if(m.alphaCutoff != null){
			m.alphaMode = "MASK";
		}else{
			m.alphaMode = "BLEND";
		}
	}
}
 

@Override
public Attribute copy() {
	return new PBRCubemapAttribute(type, textureDescription);
}
 

public static Attribute createSpecularEnv(Cubemap specularCubemap) {
	return new PBRCubemapAttribute(SpecularEnv, specularCubemap);
}
 

public static Attribute createDiffuseEnv(Cubemap diffuseCubemap) {
	return new PBRCubemapAttribute(DiffuseEnv, diffuseCubemap);
}
 

@Override
public int compareTo (Attribute o) {
	return (int)(type - o.type);
}
 

public Attribute set(Vector3 value) {
	this.value.set(value);
	return this;
}
 

@Override
public Attribute copy() {
	return new PBRTextureAttribute(this);
}
 

public static Attribute createOcclusionStrength(float value) {
	return new PBRFloatAttribute(OcclusionStrength, value);
}
 

public static Attribute createNormalScale(float value) {
	return new PBRFloatAttribute(NormalScale, value);
}
 

public static Attribute createRoughness(float value) {
	return new PBRFloatAttribute(Roughness, value);
}
 

public static Attribute createMetallic(float value) {
	return new PBRFloatAttribute(Metallic, value);
}
 

@Override
public Attribute copy () {
	return new PBRFloatAttribute(type, value);
}
 

@Override
public Attribute copy() {
	return new PBRColorAttribute(type, color);
}
 

@Override
public int compareTo (Attribute o) {
	return (int)(type - o.type);
}
 

@Override
public Attribute copy () {
	return new PBRFlagAttribute(type);
}
 

/**
 * fast way to replace an attribute without sorting
 * @param attribute
 */
public void replaceCache(Attribute attribute) {
	final int idx = indexOf(attribute.type);
	this.attributes.set(idx, attribute);
}