Java Code Examples for com.jme3.material.Material#getMaterialDef()

/**
 * Reload the material.
 */
@FxThread
private void reload(@NotNull final Material material) {
    setCurrentMaterial(material);
    setIgnoreListeners(true);
    try {

        final MaterialEditor3DPart editor3DState = getEditor3DPart();
        editor3DState.updateMaterial(material);

        getSettingsTree().fill(new RootMaterialSettings(material));

        final ComboBox<String> materialDefinitionBox = getMaterialDefinitionBox();
        final ObservableList<String> items = materialDefinitionBox.getItems();
        items.clear();
        items.addAll(RESOURCE_MANAGER.getAvailableResources(FileExtensions.JME_MATERIAL_DEFINITION));

        final MaterialDef materialDef = material.getMaterialDef();
        materialDefinitionBox.getSelectionModel().select(materialDef.getAssetName());

    } finally {
        setIgnoreListeners(false);
    }
}
 

/**
 * Migrate the material to second material.
 *
 * @param target the target migrating.
 * @param source the source material.
 */
@JmeThread
public static void migrateTo(@NotNull Material target, @NotNull Material source) {

    var materialDef = target.getMaterialDef();
    var actualParams = source.getParams();

    actualParams.forEach(matParam -> {

        var param = materialDef.getMaterialParam(matParam.getName());

        if (param == null || param.getVarType() != matParam.getVarType()) {
            return;
        }

        target.setParam(matParam.getName(), matParam.getVarType(), matParam.getValue());
    });

    var additionalRenderState = target.getAdditionalRenderState();
    additionalRenderState.set(source.getAdditionalRenderState());

    target.setKey(source.getKey());
}
 

/**
 * Check a material on containing a shader.
 *
 * @param material the material for checking.
 * @param file     the file of the shader.
 * @return true if the material contains the shader.
 */
@FromAnyThread
private static boolean containsShader(@NotNull Material material, @NotNull Path file) {

    var materialDef = material.getMaterialDef();
    var assetFile = notNull(getAssetFile(file), "Can't get an asset file.");
    var assetPath = toAssetPath(assetFile);

    return containsShader(materialDef, assetPath);
}
 

@Override
@FxThread
protected @Nullable List<EditableProperty<?, ?>> getProperties(@NotNull final Object object) {

    if (!(object instanceof MaterialSettings) || object instanceof RootMaterialSettings) {
        return null;
    }

    final MaterialSettings settings = (MaterialSettings) object;
    final Material material = settings.getMaterial();

    if(object instanceof RenderSettings) {

        final RenderState renderState = material.getAdditionalRenderState();

        final List<EditableProperty<?, ?>> result = new ArrayList<>();
        result.add(new SimpleProperty<>(BOOLEAN, Messages.MATERIAL_RENDER_STATE_COLOR_WRITE, settings,
                sett -> renderState.isColorWrite(),
                (sett, property) -> renderState.setColorWrite(property)));
        result.add(new SimpleProperty<>(BOOLEAN, Messages.MATERIAL_RENDER_STATE_DEPTH_WRITE, settings,
                sett -> renderState.isDepthWrite(),
                (sett, property) -> renderState.setDepthWrite(property)));
        result.add(new SimpleProperty<>(BOOLEAN, Messages.MATERIAL_RENDER_STATE_DEPTH_TEST, settings,
                sett -> renderState.isDepthTest(),
                (sett, property) -> renderState.setDepthTest(property)));
        result.add(new SimpleProperty<>(BOOLEAN, Messages.MATERIAL_RENDER_STATE_WIREFRAME, settings,
                sett -> renderState.isWireframe(),
                (sett, property) -> renderState.setWireframe(property)));
        result.add(new SimpleProperty<>(ENUM, Messages.MATERIAL_RENDER_STATE_FACE_CULL_MODE, settings,
                sett -> renderState.getFaceCullMode(),
                (sett, property) -> renderState.setFaceCullMode(property)));
        result.add(new SimpleProperty<>(ENUM, Messages.MATERIAL_RENDER_STATE_BLEND_MODE, settings,
                sett -> renderState.getBlendMode(),
                (sett, property) -> renderState.setBlendMode(property)));
        result.add(new SimpleProperty<>(ENUM, Messages.MATERIAL_RENDER_STATE_BLEND_EQUATION, settings,
                sett -> renderState.getBlendEquation(),
                (sett, property) -> renderState.setBlendEquation(property)));
        result.add(new SimpleProperty<>(ENUM, Messages.MATERIAL_RENDER_STATE_BLEND_EQUATION_ALPHA, settings,
                sett -> renderState.getBlendEquationAlpha(),
                (sett, property) -> renderState.setBlendEquationAlpha(property)));
        result.add(new SimpleProperty<>(FLOAT,  Messages.MATERIAL_RENDER_STATE_POLY_OFFSET_FACTOR, 0.1F, settings,
                sett -> renderState.getPolyOffsetFactor(),
                (sett, property) -> renderState.setPolyOffset(property, renderState.getPolyOffsetUnits())));
        result.add(new SimpleProperty<>(FLOAT,  Messages.MATERIAL_RENDER_STATE_POLY_OFFSET_UNITS, 0.1F, settings,
                sett -> renderState.getPolyOffsetUnits(),
                (sett, property) -> renderState.setPolyOffset(renderState.getPolyOffsetFactor(), property)));

        return result;
    }

    final MaterialDef materialDef = material.getMaterialDef();

    return materialDef.getMaterialParams()
            .stream()
            .filter(param -> filter(param, object))
            .sorted(MAT_PARAM_NAME_COMPARATOR)
            .map(param -> convert(param, material, settings))
            .filter(Objects::nonNull)
            .collect(Collectors.toList());
}
 

/**
 * Try to apply dropped texture.
 *
 * @param editor    the editor.
 * @param dragEvent the drag event.
 * @param path      the path to the texture.
 */
private void applyTexture(@NotNull final MaterialFileEditor editor, @NotNull final DragEvent dragEvent,
                          @NotNull final Path path) {

    final String textureName = path.getFileName().toString();
    final int textureType = MaterialUtils.getPossibleTextureType(textureName);

    if (textureType == 0) {
        return;
    }

    final String[] paramNames = MaterialUtils.getPossibleParamNames(textureType);
    final Material currentMaterial = getCurrentMaterial();
    final MaterialDef materialDef = currentMaterial.getMaterialDef();

    final Optional<MatParam> param = Arrays.stream(paramNames)
            .map(materialDef::getMaterialParam)
            .filter(Objects::nonNull)
            .filter(p -> p.getVarType() == VarType.Texture2D)
            .findAny();

    if (!param.isPresent()) {
        return;
    }

    final MatParam matParam = param.get();

    EXECUTOR_MANAGER.addJmeTask(() -> {

        final EditorConfig config = EditorConfig.getInstance();
        final Path assetFile = notNull(getAssetFile(path));
        final TextureKey textureKey = new TextureKey(toAssetPath(assetFile));
        textureKey.setFlipY(config.getBoolean(PREF_FLIPPED_TEXTURES, PREF_DEFAULT_FLIPPED_TEXTURES));

        final AssetManager assetManager = EditorUtil.getAssetManager();
        final Texture texture = assetManager.loadTexture(textureKey);
        texture.setWrap(Texture.WrapMode.Repeat);

        final String paramName = matParam.getName();
        final MatParamTexture textureParam = currentMaterial.getTextureParam(paramName);
        final Texture currentTexture = textureParam == null? null : textureParam.getTextureValue();

        PropertyOperation<ChangeConsumer, Material, Texture> operation =
                new PropertyOperation<>(currentMaterial, paramName, texture, currentTexture);
        operation.setApplyHandler((material, newTexture) -> material.setTexture(paramName, newTexture));

        execute(operation);
    });
}
 

/**
 * Serialize to string string.
 *
 * @param material the material
 * @return the string
 */
@FromAnyThread
public static @NotNull String serializeToString(@NotNull Material material) {

    var materialDef = material.getMaterialDef();
    var params = material.getParams();

    var builder = new StringBuilder();
    builder.append("Material MyMaterial : ").append(materialDef.getAssetName()).append(" {\n");
    builder.append("    MaterialParameters {\n");
    params.forEach(matParam -> addMaterialParameter(builder, matParam));
    builder.append("    }\n");
    builder.append("    AdditionalRenderState {\n");

    var renderState = material.getAdditionalRenderState();
    var blendMode = renderState.getBlendMode();
    var faceCullMode = renderState.getFaceCullMode();

    if (blendMode != RenderState.BlendMode.Off) {
        builder.append("      Blend ").append(blendMode.name()).append('\n');
    }

    if (faceCullMode != RenderState.FaceCullMode.Back) {
        builder.append("      FaceCull ").append(faceCullMode.name()).append('\n');
    }

    if (renderState.isWireframe()) builder.append("      Wireframe On\n");
    if (!renderState.isDepthTest()) builder.append("      DepthTest Off\n");
    if (!renderState.isDepthWrite()) builder.append("      DepthWrite Off\n");
    if (!renderState.isColorWrite()) builder.append("      ColorWrite Off\n");

    var polyOffsetFactor = renderState.getPolyOffsetFactor();
    var polyOffsetUnits = renderState.getPolyOffsetUnits();

    if (polyOffsetFactor != 0 || polyOffsetUnits != 0) {
        builder.append("      PolyOffset ")
                .append(polyOffsetFactor)
                .append(' ')
                .append(polyOffsetUnits)
                .append('\n');
    }

    builder.append("    }\n");
    builder.append("}");

    return builder.toString();
}
 

/**
 * Renders the given geometry.
 * <p>
 * First the proper world matrix is set, if 
 * the geometry's {@link Geometry#setIgnoreTransform(boolean) ignore transform}
 * feature is enabled, the identity world matrix is used, otherwise, the 
 * geometry's {@link Geometry#getWorldMatrix() world transform matrix} is used. 
 * <p>
 * Once the world matrix is applied, the proper material is chosen for rendering.
 * If a {@link #setForcedMaterial(com.jme3.material.Material) forced material} is
 * set on this RenderManager, then it is used for rendering the geometry,
 * otherwise, the {@link Geometry#getMaterial() geometry's material} is used.
 * <p>
 * If a {@link #setForcedTechnique(java.lang.String) forced technique} is
 * set on this RenderManager, then it is selected automatically
 * on the geometry's material and is used for rendering. Otherwise, one
 * of the {@link com.jme3.material.MaterialDef#getTechniqueDefsNames() default techniques} is
 * used.
 * <p>
 * If a {@link #setForcedRenderState(com.jme3.material.RenderState) forced
 * render state} is set on this RenderManager, then it is used
 * for rendering the material, and the material's own render state is ignored.
 * Otherwise, the material's render state is used as intended.
 * 
 * @param geom The geometry to render
   * 
 * @see Technique
 * @see RenderState
 * @see com.jme3.material.Material#selectTechnique(java.lang.String, com.jme3.renderer.RenderManager) 
 * @see com.jme3.material.Material#render(com.jme3.scene.Geometry, com.jme3.renderer.RenderManager) 
 */
public void renderGeometry(Geometry geom) {
    if (geom.isIgnoreTransform()) {
        setWorldMatrix(Matrix4f.IDENTITY);
    } else {
        setWorldMatrix(geom.getWorldMatrix());
    }
    
    // Perform light filtering if we have a light filter.
    LightList lightList = geom.getWorldLightList();
    
    if (lightFilter != null) {
        filteredLightList.clear();
        lightFilter.filterLights(geom, filteredLightList);
        lightList = filteredLightList;
    }

    Material material = geom.getMaterial();

    //if forcedTechnique we try to force it for render,
    //if it does not exists in the mat def, we check for forcedMaterial and render the geom if not null
    //else the geom is not rendered
    if (forcedTechnique != null) {
        MaterialDef matDef = material.getMaterialDef();
        if (matDef.getTechniqueDefs(forcedTechnique) != null) {

            Technique activeTechnique = material.getActiveTechnique();

            String previousTechniqueName = activeTechnique != null
                    ? activeTechnique.getDef().getName()
                    : TechniqueDef.DEFAULT_TECHNIQUE_NAME;

            geom.getMaterial().selectTechnique(forcedTechnique, this);
            //saving forcedRenderState for future calls
            RenderState tmpRs = forcedRenderState;
            if (geom.getMaterial().getActiveTechnique().getDef().getForcedRenderState() != null) {
                //forcing forced technique renderState
                forcedRenderState = geom.getMaterial().getActiveTechnique().getDef().getForcedRenderState();
            }
            // use geometry's material
            material.render(geom, lightList, this);
            material.selectTechnique(previousTechniqueName, this);

            //restoring forcedRenderState
            forcedRenderState = tmpRs;

            //Reverted this part from revision 6197
            //If forcedTechnique does not exists, and forcedMaterial is not set, the geom MUST NOT be rendered
        } else if (forcedMaterial != null) {
            // use forced material
            forcedMaterial.render(geom, lightList, this);
        }
    } else if (forcedMaterial != null) {
        // use forced material
        forcedMaterial.render(geom, lightList, this);
    } else {
        material.render(geom, lightList, this);
    }
}