Examples with Mode com.jme3.scene.Mesh.Mode used on opensource projects

Example 21 with Mode

use of com.jme3.scene.Mesh.Mode in project jmonkeyengine by jMonkeyEngine.

the class HDRRenderer method createLumShader.

private Material createLumShader(int srcW, int srcH, int bufW, int bufH, int mode, int iters, Texture tex) {
    Material mat = new Material(manager, "Common/MatDefs/Hdr/LogLum.j3md");
    Vector2f blockSize = new Vector2f(1f / bufW, 1f / bufH);
    Vector2f pixelSize = new Vector2f(1f / srcW, 1f / srcH);
    Vector2f blocks = new Vector2f();
    float numPixels = Float.POSITIVE_INFINITY;
    if (iters != -1) {
        do {
            pixelSize.multLocal(2);
            blocks.set(blockSize.x / pixelSize.x, blockSize.y / pixelSize.y);
            numPixels = blocks.x * blocks.y;
        } while (numPixels > iters);
    } else {
        blocks.set(blockSize.x / pixelSize.x, blockSize.y / pixelSize.y);
        numPixels = blocks.x * blocks.y;
    }
    mat.setBoolean("Blocks", true);
    if (mode == LUMMODE_ENCODE_LUM)
        mat.setBoolean("EncodeLum", true);
    else if (mode == LUMMODE_DECODE_LUM)
        mat.setBoolean("DecodeLum", true);
    mat.setTexture("Texture", tex);
    mat.setVector2("BlockSize", blockSize);
    mat.setVector2("PixelSize", pixelSize);
    mat.setFloat("NumPixels", numPixels);
    return mat;
}

Example 22 with Mode

use of com.jme3.scene.Mesh.Mode in project jmonkeyengine by jMonkeyEngine.

the class GLRenderer method updateRenderTexture.

public void updateRenderTexture(FrameBuffer fb, RenderBuffer rb) {
    Texture tex = rb.getTexture();
    Image image = tex.getImage();
    if (image.isUpdateNeeded()) {
        // Check NPOT requirements
        checkNonPowerOfTwo(tex);
        updateTexImageData(image, tex.getType(), 0, false);
        // NOTE: For depth textures, sets nearest/no-mips mode
        // Required to fix "framebuffer unsupported"
        // for old NVIDIA drivers!
        setupTextureParams(0, tex);
    }
    if (rb.getLayer() < 0) {
        glfbo.glFramebufferTexture2DEXT(GLFbo.GL_FRAMEBUFFER_EXT, convertAttachmentSlot(rb.getSlot()), convertTextureType(tex.getType(), image.getMultiSamples(), rb.getFace()), image.getId(), 0);
    } else {
        gl3.glFramebufferTextureLayer(GLFbo.GL_FRAMEBUFFER_EXT, convertAttachmentSlot(rb.getSlot()), image.getId(), 0, rb.getLayer());
    }
}

Example 23 with Mode

use of com.jme3.scene.Mesh.Mode in project jmonkeyengine by jMonkeyEngine.

the class Material method render.

/**
     * Called by {@link RenderManager} to render the geometry by
     * using this material.
     * <p>
     * The material is rendered as follows:
     * <ul>
     * <li>Determine which technique to use to render the material -
     * either what the user selected via
     * {@link #selectTechnique(java.lang.String, com.jme3.renderer.RenderManager)
     * Material.selectTechnique()},
     * or the first default technique that the renderer supports
     * (based on the technique's {@link TechniqueDef#getRequiredCaps() requested rendering capabilities})<ul>
     * <li>If the technique has been changed since the last frame, then it is notified via
     * {@link Technique#makeCurrent(com.jme3.asset.AssetManager, boolean, java.util.EnumSet)
     * Technique.makeCurrent()}.
     * If the technique wants to use a shader to render the model, it should load it at this part -
     * the shader should have all the proper defines as declared in the technique definition,
     * including those that are bound to material parameters.
     * The technique can re-use the shader from the last frame if
     * no changes to the defines occurred.</li></ul>
     * <li>Set the {@link RenderState} to use for rendering. The render states are
     * applied in this order (later RenderStates override earlier RenderStates):<ol>
     * <li>{@link TechniqueDef#getRenderState() Technique Definition's RenderState}
     * - i.e. specific renderstate that is required for the shader.</li>
     * <li>{@link #getAdditionalRenderState() Material Instance Additional RenderState}
     * - i.e. ad-hoc renderstate set per model</li>
     * <li>{@link RenderManager#getForcedRenderState() RenderManager's Forced RenderState}
     * - i.e. renderstate requested by a {@link com.jme3.post.SceneProcessor} or
     * post-processing filter.</li></ol>
     * <li>If the technique {@link TechniqueDef#isUsingShaders() uses a shader}, then the uniforms of the shader must be updated.<ul>
     * <li>Uniforms bound to material parameters are updated based on the current material parameter values.</li>
     * <li>Uniforms bound to world parameters are updated from the RenderManager.
     * Internally {@link UniformBindingManager} is used for this task.</li>
     * <li>Uniforms bound to textures will cause the texture to be uploaded as necessary.
     * The uniform is set to the texture unit where the texture is bound.</li></ul>
     * <li>If the technique uses a shader, the model is then rendered according
     * to the lighting mode specified on the technique definition.<ul>
     * <li>{@link LightMode#SinglePass single pass light mode} fills the shader's light uniform arrays
     * with the first 4 lights and renders the model once.</li>
     * <li>{@link LightMode#MultiPass multi pass light mode} light mode renders the model multiple times,
     * for the first light it is rendered opaque, on subsequent lights it is
     * rendered with {@link BlendMode#AlphaAdditive alpha-additive} blending and depth writing disabled.</li>
     * </ul>
     * <li>For techniques that do not use shaders,
     * fixed function OpenGL is used to render the model (see {@link GL1Renderer} interface):<ul>
     * <li>OpenGL state ({@link FixedFuncBinding}) that is bound to material parameters is updated. </li>
     * <li>The texture set on the material is uploaded and bound.
     * Currently only 1 texture is supported for fixed function techniques.</li>
     * <li>If the technique uses lighting, then OpenGL lighting state is updated
     * based on the light list on the geometry, otherwise OpenGL lighting is disabled.</li>
     * <li>The mesh is uploaded and rendered.</li>
     * </ul>
     * </ul>
     *
     * @param geometry The geometry to render
     * @param lights Presorted and filtered light list to use for rendering
     * @param renderManager The render manager requesting the rendering
     */
public void render(Geometry geometry, LightList lights, RenderManager renderManager) {
    if (technique == null) {
        selectTechnique(TechniqueDef.DEFAULT_TECHNIQUE_NAME, renderManager);
    }
    TechniqueDef techniqueDef = technique.getDef();
    Renderer renderer = renderManager.getRenderer();
    EnumSet<Caps> rendererCaps = renderer.getCaps();
    if (techniqueDef.isNoRender()) {
        return;
    }
    // Apply render state
    updateRenderState(renderManager, renderer, techniqueDef);
    // Get world overrides
    SafeArrayList<MatParamOverride> overrides = geometry.getWorldMatParamOverrides();
    // Select shader to use
    Shader shader = technique.makeCurrent(renderManager, overrides, renderManager.getForcedMatParams(), lights, rendererCaps);
    // Begin tracking which uniforms were changed by material.
    clearUniformsSetByCurrent(shader);
    // Set uniform bindings
    renderManager.updateUniformBindings(shader);
    // Set material parameters
    int unit = updateShaderMaterialParameters(renderer, shader, overrides, renderManager.getForcedMatParams());
    // Clear any uniforms not changed by material.
    resetUniformsNotSetByCurrent(shader);
    // Delegate rendering to the technique
    technique.render(renderManager, shader, geometry, lights, unit);
}

Example 24 with Mode

use of com.jme3.scene.Mesh.Mode in project jmonkeyengine by jMonkeyEngine.

the class TestApplication method main.

public static void main(String[] args) throws InterruptedException {
    System.out.println("Creating application..");
    LegacyApplication app = new LegacyApplication();
    System.out.println("Starting application in LWJGL mode..");
    app.start();
    System.out.println("Waiting 5 seconds");
    Thread.sleep(5000);
    System.out.println("Closing application..");
    app.stop();
    Thread.sleep(2000);
    System.out.println("Starting in fullscreen mode");
    app = new LegacyApplication();
    AppSettings settings = new AppSettings(true);
    settings.setFullscreen(true);
    // current width/height
    settings.setResolution(-1, -1);
    app.setSettings(settings);
    app.start();
    Thread.sleep(5000);
    app.stop();
    Thread.sleep(2000);
    System.out.println("Creating offscreen buffer application");
    app = new LegacyApplication();
    app.start(Type.OffscreenSurface);
    Thread.sleep(3000);
    System.out.println("Destroying offscreen buffer");
    app.stop();
}

Example 25 with Mode

use of com.jme3.scene.Mesh.Mode in project jmonkeyengine by jMonkeyEngine.

the class TestPssmShadow method onAction.

public void onAction(String name, boolean keyPressed, float tpf) {
    if (name.equals("toggle") && keyPressed) {
        renderModeIndex += 1;
        renderModeIndex %= 3;
        switch(renderModeIndex) {
            case 0:
                viewPort.addProcessor(pssmRenderer);
                break;
            case 1:
                viewPort.removeProcessor(pssmRenderer);
                pssmFilter.setEnabled(true);
                break;
            case 2:
                pssmFilter.setEnabled(false);
                break;
        }
    } else if (name.equals("toggleHW") && keyPressed) {
        hardwareShadows = !hardwareShadows;
        pssmRenderer.setCompareMode(hardwareShadows ? CompareMode.Hardware : CompareMode.Software);
        pssmFilter.setCompareMode(hardwareShadows ? CompareMode.Hardware : CompareMode.Software);
        System.out.println("HW Shadows: " + hardwareShadows);
    }
    if (name.equals("changeFiltering") && keyPressed) {
        filteringIndex = (filteringIndex + 1) % FilterMode.values().length;
        FilterMode m = FilterMode.values()[filteringIndex];
        pssmRenderer.setFilterMode(m);
        pssmFilter.setFilterMode(m);
        print("Filter mode : " + m.toString());
    }
    if (name.equals("lambdaUp") && keyPressed) {
        pssmRenderer.setLambda(pssmRenderer.getLambda() + 0.01f);
        pssmFilter.setLambda(pssmRenderer.getLambda() + 0.01f);
        System.out.println("Lambda : " + pssmRenderer.getLambda());
    } else if (name.equals("lambdaDown") && keyPressed) {
        pssmRenderer.setLambda(pssmRenderer.getLambda() - 0.01f);
        pssmFilter.setLambda(pssmRenderer.getLambda() - 0.01f);
        System.out.println("Lambda : " + pssmRenderer.getLambda());
    }
    if (name.equals("ShadowUp") && keyPressed) {
        pssmRenderer.setShadowIntensity(pssmRenderer.getShadowIntensity() + 0.1f);
        pssmFilter.setShadowIntensity(pssmRenderer.getShadowIntensity() + 0.1f);
        System.out.println("Shadow intensity : " + pssmRenderer.getShadowIntensity());
    }
    if (name.equals("ShadowDown") && keyPressed) {
        pssmRenderer.setShadowIntensity(pssmRenderer.getShadowIntensity() - 0.1f);
        pssmFilter.setShadowIntensity(pssmRenderer.getShadowIntensity() - 0.1f);
        System.out.println("Shadow intensity : " + pssmRenderer.getShadowIntensity());
    }
    if (name.equals("ThicknessUp") && keyPressed) {
        pssmRenderer.setEdgesThickness(pssmRenderer.getEdgesThickness() + 1);
        pssmFilter.setEdgesThickness(pssmRenderer.getEdgesThickness() + 1);
        System.out.println("Shadow thickness : " + pssmRenderer.getEdgesThickness());
    }
    if (name.equals("ThicknessDown") && keyPressed) {
        pssmRenderer.setEdgesThickness(pssmRenderer.getEdgesThickness() - 1);
        pssmFilter.setEdgesThickness(pssmRenderer.getEdgesThickness() - 1);
        System.out.println("Shadow thickness : " + pssmRenderer.getEdgesThickness());
    }
    if (name.equals("switchGroundMat") && keyPressed) {
        if (ground.getMaterial() == matGroundL) {
            ground.setMaterial(matGroundU);
        } else {
            ground.setMaterial(matGroundL);
        }
    }
    if (name.equals("up")) {
        up = keyPressed;
    }
    if (name.equals("down")) {
        down = keyPressed;
    }
    if (name.equals("right")) {
        right = keyPressed;
    }
    if (name.equals("left")) {
        left = keyPressed;
    }
    if (name.equals("fwd")) {
        fwd = keyPressed;
    }
    if (name.equals("back")) {
        back = keyPressed;
    }
}