com.jme3.shader.VarType Java Examples

@Override
public void read(JmeImporter im) throws IOException {
    super.read(im);
    InputCapsule in = im.getCapsule(this);
    skeleton = (Skeleton) in.readSavable("skeleton", null);
    
    numberOfBonesParam = (MatParamOverride) in.readSavable("numberOfBonesParam", null);
    boneMatricesParam = (MatParamOverride) in.readSavable("boneMatricesParam", null);
    
    if (numberOfBonesParam == null) {
        numberOfBonesParam = new MatParamOverride(VarType.Int, "NumberOfBones", null);
        boneMatricesParam = new MatParamOverride(VarType.Matrix4Array, "BoneMatrices", null);
        getSpatial().addMatParamOverride(numberOfBonesParam);
        getSpatial().addMatParamOverride(boneMatricesParam);
    }
}
 

@Override
public void read(JmeImporter im) throws IOException {
    super.read(im);
    InputCapsule in = im.getCapsule(this);
    armature = (Armature) in.readSavable("armature", null);

    numberOfJointsParam = (MatParamOverride) in.readSavable("numberOfBonesParam", null);
    jointMatricesParam = (MatParamOverride) in.readSavable("boneMatricesParam", null);

    if (numberOfJointsParam == null) {
        numberOfJointsParam = new MatParamOverride(VarType.Int, "NumberOfBones", null);
        jointMatricesParam = new MatParamOverride(VarType.Matrix4Array, "BoneMatrices", null);
        getSpatial().addMatParamOverride(numberOfJointsParam);
        getSpatial().addMatParamOverride(jointMatricesParam);
    }
}
 

/**
 * Access the attachments node of this joint. If this joint doesn't already
 * have an attachments node, create one. Models and effects attached to the
 * attachments node will follow this bone's motions.
 *
 * @param jointIndex this bone's index in its armature (≥0)
 * @param targets    a list of geometries animated by this bone's skeleton (not
 *                   null, unaffected)
 */
Node getAttachmentsNode(int jointIndex, SafeArrayList<Geometry> targets) {
    targetGeometry = null;
    /*
     * Search for a geometry animated by this particular bone.
     */
    for (Geometry geometry : targets) {
        Mesh mesh = geometry.getMesh();
        if (mesh != null && mesh.isAnimatedByJoint(jointIndex)) {
            targetGeometry = geometry;
            break;
        }
    }

    if (attachedNode == null) {
        attachedNode = new Node(name + "_attachnode");
        attachedNode.setUserData("AttachedBone", this);
        //We don't want the node to have a numBone set by a parent node so we force it to null
        attachedNode.addMatParamOverride(new MatParamOverride(VarType.Int, "NumberOfBones", null));
    }

    return attachedNode;
}
 

public void testRemoveOverride() {
    material("Common/MatDefs/Light/Lighting.j3md");

    reset();
    inputMp(mpoInt("NumberOfBones", 1234));
    outDefines(def("NUM_BONES", VarType.Int, 1234));
    outUniforms(uniform("NumberOfBones", VarType.Int, 1234));

    reset();
    inputMpo(mpoInt("NumberOfBones", 4321));
    outDefines(def("NUM_BONES", VarType.Int, 4321));
    outUniforms(uniform("NumberOfBones", VarType.Int, 4321));

    reset();
    geometry.clearMatParamOverrides();
    outDefines(def("NUM_BONES", VarType.Int, 1234));
    outUniforms(uniform("NumberOfBones", VarType.Int, 1234));
}
 

@Test
public void testRemoveTexture() {
    material("Common/MatDefs/Light/Lighting.j3md");
    Texture2D tex = new Texture2D(128, 128, Format.RGBA8);

    reset();
    inputMpo(mpoTexture2D("DiffuseMap", tex));
    outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex));
    outUniforms(uniform("DiffuseMap", VarType.Int, 0));
    outTextures(tex);

    reset();
    geometry.clearMatParamOverrides();
    root.updateGeometricState();
    outDefines();
    outUniforms();
    outTextures();
}
 

@Test
public void testRemoveTextureOverride() {
    material("Common/MatDefs/Light/Lighting.j3md");
    Texture2D tex1 = new Texture2D(128, 128, Format.RGBA8);
    Texture2D tex2 = new Texture2D(128, 128, Format.RGBA8);

    reset();
    inputMp(mpoTexture2D("DiffuseMap", tex1));
    outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex1));
    outUniforms(uniform("DiffuseMap", VarType.Int, 0));
    outTextures(tex1);

    reset();
    inputMpo(mpoTexture2D("DiffuseMap", tex2));
    outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex2));
    outUniforms(uniform("DiffuseMap", VarType.Int, 0));
    outTextures(tex2);

    reset();
    geometry.clearMatParamOverrides();
    root.updateGeometricState();
    outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex1));
    outUniforms(uniform("DiffuseMap", VarType.Int, 0));
    outTextures(tex1);
}
 

/**
 * Convert material parameter type to editable property type.
 *
 * @param varType the material parameter type.
 * @return the editable property type or null.
 */
@FxThread
protected @Nullable EditablePropertyType convert(@NotNull VarType varType) {

    switch (varType) {
        case Boolean:
            return EditablePropertyType.BOOLEAN;
        case Float:
            return EditablePropertyType.FLOAT;
        case Int:
            return EditablePropertyType.INTEGER;
        case Vector4:
            return EditablePropertyType.COLOR;
        case Vector3:
            return EditablePropertyType.VECTOR_3F;
        case Vector2:
            return EditablePropertyType.VECTOR_2F;
        case Texture2D:
            return EditablePropertyType.TEXTURE_2D;
    }

    return null;
}
 

private void outDefines(Define... expectedDefinesArray) {
    StringBuilder expectedDefineSource = new StringBuilder();
    for (Define define : expectedDefinesArray) {
        expectedDefineSource.append(define.toString());
    }
    
    if (!evaluated) {
        evaluateTechniqueDef();
    }

    Material mat = geometry.getMaterial();
    Technique tech = mat.getActiveTechnique();
    TechniqueDef def = tech.getDef();
    DefineList actualDefines = tech.getDynamicDefines();
    String[] defineNames = def.getDefineNames();
    VarType[] defineTypes = def.getDefineTypes();
    String actualDefineSource = actualDefines.generateSource(Arrays.asList(defineNames), Arrays.asList(defineTypes));

    assertEquals(expectedDefineSource.toString(), actualDefineSource);
}
 

/**
 * Access the attachments node of this bone. If this bone doesn't already
 * have an attachments node, create one. Models and effects attached to the
 * attachments node will follow this bone's motions.
 *
 * @param boneIndex this bone's index in its skeleton (≥0)
 * @param targets a list of geometries animated by this bone's skeleton (not
 * null, unaffected)
 */
Node getAttachmentsNode(int boneIndex, SafeArrayList<Geometry> targets) {
    targetGeometry = null;
    /*
     * Search for a geometry animated by this particular bone.
     */
    for (Geometry geometry : targets) {
        Mesh mesh = geometry.getMesh();
        if (mesh != null && mesh.isAnimatedByBone(boneIndex)) {
            targetGeometry = geometry;
            break;
        }
    }

    if (attachNode == null) {
        attachNode = new Node(name + "_attachnode");
        attachNode.setUserData("AttachedBone", this);
        //We don't want the node to have a numBone set by a parent node so we force it to null
        attachNode.addMatParamOverride(new MatParamOverride(VarType.Int, "NumberOfBones", null));
    }

    return attachNode;
}
 

@Test
public void testForcedColorSpace(){
   
    Image img=new Image(Format.RGBA8,2,2,BufferUtils.createByteBuffer(16),null,ColorSpace.sRGB);
    Image img2=new Image(Format.RGBA8,2,2,BufferUtils.createByteBuffer(16),null,ColorSpace.sRGB);
    Texture2D tx=new Texture2D(img);
    Texture2D tx2=new Texture2D(img2);

    assertTrue(tx2.getImage().getColorSpace()==ColorSpace.sRGB);
    assertTrue(tx2.getImage().getColorSpace()==ColorSpace.sRGB);

    AssetManager assetManager = TestUtil.createAssetManager();
    MaterialDef def=new MaterialDef(assetManager,"test");
    def.addMaterialParamTexture(VarType.Texture2D, "ColorMap",ColorSpace.Linear, null);
    Material mat=new Material(def);
    
    mat.setTexture("ColorMap",tx);          
    assertTrue(tx.getImage().getColorSpace()==ColorSpace.Linear);
    
    mat.setTexture("ColorMap",tx2);  
    assertTrue(tx2.getImage().getColorSpace()==ColorSpace.Linear);       

}
 

private String checkSetParam(VarType type, String name) {
    MatParam paramDef = def.getMaterialParam(name);
    String newName = name;

    if (paramDef == null && name.startsWith("m_")) {
        newName = name.substring(2);
        paramDef = def.getMaterialParam(newName);
        if (paramDef == null) {
            throw new IllegalArgumentException("Material parameter is not defined: " + name);
        } else {
            logger.log(Level.WARNING, "Material parameter {0} uses a deprecated naming convention use {1} instead ", new Object[]{name, newName});
        }
    } else if (paramDef == null) {
        throw new IllegalArgumentException("Material parameter is not defined: " + name);
    }

    if (type != null && paramDef.getVarType() != type) {
        logger.log(Level.WARNING, "Material parameter being set: {0} with "
                + "type {1} doesn''t match definition types {2}", new Object[]{name, type.name(), paramDef.getVarType()} );
    }

    return newName;
}
 

void updateUniformParam(int paramIndex, VarType type, Object value, boolean ifNotOwner) {
        Uniform u = uniformArray[paramIndex];
        if (u == null) {
            u = shader.getUniform(paramValues.getValue(paramIndex).getPrefixedName());
            uniformArray[paramIndex] = u;
        }

//        if (ifNotOwner && u.getLastChanger() == owner)
//            return;

        switch (type) {
            case Texture2D: // fall intentional
            case Texture3D:
            case TextureArray:
            case TextureCubeMap:
            case Int:
                u.setValue(VarType.Int, value);
                break;
            default:
                u.setValue(type, value);
                break;
        }
//        u.setLastChanger(owner);
    }
 

public void read(JmeImporter im) throws IOException {
    InputCapsule ic = im.getCapsule(this);
    type = ic.readEnum("varType", VarType.class, null);
    name = ic.readString("name", null);
    ffBinding = ic.readEnum("ff_binding", FixedFuncBinding.class, null);
    switch (getVarType()) {
        case Boolean:
            value = ic.readBoolean("value_bool", false);
            break;
        case Float:
            value = ic.readFloat("value_float", 0f);
            break;
        case Int:
            value = ic.readInt("value_int", 0);
            break;
        default:
            value = ic.readSavable("value_savable", null);
            break;
    }
}
 

public void setParam(int paramIndex, VarType type, Object value) {
        MatParam val = paramValues.getValue(paramIndex);
//        if (technique != null) {
//            technique.notifySetParam(name, type, value);
//        }

        val.setValue(value);
        Object value2 = val.multiData != null ? val.multiData : value;
        if (techniqueArray == null) {
            setTechniqueArray();
        }
        paramValues.getValue(0);
        for(Technique tech : techniqueArray) {
            tech.notifySetParam(paramIndex, type, value2);
        }
    }
 

/**
 * Refresh textures in a material.
 *
 * @param material   the material.
 * @param textureKey the texture key.
 */
@JmeThread
private static void refreshTextures(@NotNull Material material, @NotNull String textureKey) {

    var assetManager = EditorUtil.getAssetManager();

    material.getParams().forEach(matParam -> {

        var varType = matParam.getVarType();
        var value = matParam.getValue();

        if (varType != VarType.Texture2D || value == null) {
            return;
        }

        var texture = (Texture) value;
        var key = (TextureKey) texture.getKey();

        if (key != null && StringUtils.equals(key.getName(), textureKey)) {
            var newTexture = assetManager.loadAsset(key);
            matParam.setValue(newTexture);
        }
    });

}
 

/**
 * Check a material on containing a texture.
 *
 * @param material  the material.
 * @param assetPath the path of the texture.
 * @return true if the material definition contains the texture.
 */
@FromAnyThread
private static boolean containsTexture(@NotNull Material material, @NotNull String assetPath) {

    var materialParams = material.getParams();

    for (var materialParam : materialParams) {

        if (materialParam.getVarType() != VarType.Texture2D) {
            continue;
        }

        var value = (Texture) materialParam.getValue();
        var textureKey = value == null ? null : (TextureKey) value.getKey();
        if (textureKey != null && StringUtils.equals(textureKey.getName(), assetPath)) {
            return true;
        }
    }

    return false;
}
 

private Define def(String name, VarType type, Object value) {
    Define d = new Define();
    d.name = name;
    d.type = type;
    d.value = value;
    return d;
}
 

/**
 * Pass a texture to the material shader.
 *
 * @param name the name of the texture defined in the material definition
 * (j3md) (for example Texture for Lighting.j3md)
 * @param value the Texture object previously loaded by the asset manager
 */
public void setTexture(String name, Texture value) {
    if (value == null) {
        // clear it
        clearTextureParam(name);
        return;
    }

    VarType paramType = null;
    switch (value.getType()) {
        case TwoDimensional:
            paramType = VarType.Texture2D;
            break;
        case TwoDimensionalArray:
            paramType = VarType.TextureArray;
            break;
        case ThreeDimensional:
            paramType = VarType.Texture3D;
            break;
        case CubeMap:
            paramType = VarType.TextureCubeMap;
            break;
        default:
            throw new UnsupportedOperationException("Unknown texture type: " + value.getType());
    }

    setTextureParam(name, paramType, value);
}
 

@Test
public void testFloatOverride() {
    material("Common/MatDefs/Light/Lighting.j3md");
    inputMp(mpoFloat("AlphaDiscardThreshold", 3.12f));
    inputMpo(mpoFloat("AlphaDiscardThreshold", 2.79f));
    outDefines(def("DISCARD_ALPHA", VarType.Float, 2.79f));
    outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 2.79f));
}
 

@Test
public void testTextureOverride() {
    material("Common/MatDefs/Light/Lighting.j3md");
    Texture2D tex1 = new Texture2D(128, 128, Format.RGBA8);
    Texture2D tex2 = new Texture2D(128, 128, Format.RGBA8);

    inputMp(mpoTexture2D("DiffuseMap", tex1));
    inputMpo(mpoTexture2D("DiffuseMap", tex2));

    outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex2));
    outUniforms(uniform("DiffuseMap", VarType.Int, 0));
    outTextures(tex2);
}
 

private void readDefine(String statement) throws IOException{
    String[] split = statement.split(":");
    if (split.length == 1){
        // add preset define
        technique.addShaderPresetDefine(split[0].trim(), VarType.Boolean, true);
    }else if (split.length == 2){
        technique.addShaderParamDefine(split[1].trim(), split[0].trim());
    }else{
        throw new IOException("Define syntax incorrect");
    }
}
 

@Test
public void testTextureMpoOnly() {
    material("Common/MatDefs/Light/Lighting.j3md");
    Texture2D tex = new Texture2D(128, 128, Format.RGBA8);

    inputMpo(mpoTexture2D("DiffuseMap", tex));
    outDefines(def("DIFFUSEMAP", VarType.Texture2D, tex));
    outUniforms(uniform("DiffuseMap", VarType.Int, 0));
    outTextures(tex);
}
 

@Test
public void testIntMpOnly() {
    material("Common/MatDefs/Light/Lighting.j3md");
    inputMp(mpoInt("NumberOfBones", 1234));
    outDefines(def("NUM_BONES", VarType.Int, 1234));
    outUniforms(uniform("NumberOfBones", VarType.Int, 1234));
}
 

@Test
public void testIntMpoOnly() {
    material("Common/MatDefs/Light/Lighting.j3md");
    inputMpo(mpoInt("NumberOfBones", 1234));
    outDefines(def("NUM_BONES", VarType.Int, 1234));
    outUniforms(uniform("NumberOfBones", VarType.Int, 1234));
}
 

@Override
protected Material getMaterial() {
    material.setFloat("SampleDist", sampleDist);
    material.setFloat("SampleStrength", sampleStrength);
    material.setParam("Samples", VarType.FloatArray, samples);
    return material;
}
 

@Test
public void testChildOverridesParent() {
    material("Common/MatDefs/Light/Lighting.j3md");

    inputParentMpo(mpoFloat("AlphaDiscardThreshold", 3.12f));
    inputMpo(mpoFloat("AlphaDiscardThreshold", 2.79f));

    outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 2.79f));
    outDefines(def("DISCARD_ALPHA", VarType.Float, 2.79f));
}
 

@Test
public void testForcedOverride() {
    material("Common/MatDefs/Light/Lighting.j3md");
    inputMp(mpoFloat("AlphaDiscardThreshold", 3.12f));
    inputMpo(mpoFloat("AlphaDiscardThreshold", 2.79f));
    inputFpo(mpoFloat("AlphaDiscardThreshold", 1.23f));
    outDefines(def("DISCARD_ALPHA", VarType.Float, 1.23f));
    outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 1.23f));

    reset();
    root.clearMatParamOverrides();
    root.updateGeometricState();
    outDefines(def("DISCARD_ALPHA", VarType.Float, 2.79f));
    outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 2.79f));
}
 

@Test
public void testFloatMpZero() {
    material("Common/MatDefs/Light/Lighting.j3md");
    inputMp(mpoFloat("AlphaDiscardThreshold", 0.0f));
    outDefines(def("DISCARD_ALPHA", VarType.Float, 0.0f));
    outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 0.0f));
}
 

@Test
public void testFloatMpOnly() {
    material("Common/MatDefs/Light/Lighting.j3md");
    inputMp(mpoFloat("AlphaDiscardThreshold", 3.12f));
    outDefines(def("DISCARD_ALPHA", VarType.Float, 3.12f));
    outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 3.12f));
}
 

@Test
public void testFloatMpoOnly() {
    material("Common/MatDefs/Light/Lighting.j3md");
    inputMpo(mpoFloat("AlphaDiscardThreshold", 3.12f));
    outDefines(def("DISCARD_ALPHA", VarType.Float, 3.12f));
    outUniforms(uniform("AlphaDiscardThreshold", VarType.Float, 3.12f));
}