Examples with Caps com.jme3.renderer.Caps used on opensource projects

Example 6 with Caps

use of com.jme3.renderer.Caps in project jmonkeyengine by jMonkeyEngine.

the class TechniqueDef method setShaderFile.

/**
     * Sets the shaders that this technique definition will use.
     *
     * @param vertexShader The name of the vertex shader
     * @param fragmentShader The name of the fragment shader
     * @param vertLanguage The vertex shader language
     * @param fragLanguage The fragment shader language
     */
public void setShaderFile(String vertexShader, String fragmentShader, String vertLanguage, String fragLanguage) {
    this.shaderLanguages.put(Shader.ShaderType.Vertex, vertLanguage);
    this.shaderNames.put(Shader.ShaderType.Vertex, vertexShader);
    this.shaderLanguages.put(Shader.ShaderType.Fragment, fragLanguage);
    this.shaderNames.put(Shader.ShaderType.Fragment, fragmentShader);
    requiredCaps.clear();
    Caps vertCap = Caps.valueOf(vertLanguage);
    requiredCaps.add(vertCap);
    Caps fragCap = Caps.valueOf(fragLanguage);
    requiredCaps.add(fragCap);
    weight = Math.max(vertCap.ordinal(), fragCap.ordinal());
}

Example 7 with Caps

use of com.jme3.renderer.Caps in project jmonkeyengine by jMonkeyEngine.

the class FilterPostProcessor method reshape.

public void reshape(ViewPort vp, int w, int h) {
    Camera cam = vp.getCamera();
    //this has no effect at first init but is useful when resizing the canvas with multi views
    cam.setViewPort(left, right, bottom, top);
    //resizing the camera to fit the new viewport and saving original dimensions
    cam.resize(w, h, false);
    left = cam.getViewPortLeft();
    right = cam.getViewPortRight();
    top = cam.getViewPortTop();
    bottom = cam.getViewPortBottom();
    originalWidth = w;
    originalHeight = h;
    //computing real dimension of the viewport and resizing the camera 
    width = (int) (w * (Math.abs(right - left)));
    height = (int) (h * (Math.abs(bottom - top)));
    width = Math.max(1, width);
    height = Math.max(1, height);
    //camera must be handled differently
    if (originalWidth != width || originalHeight != height) {
        multiView = true;
    }
    cameraInit = true;
    computeDepth = false;
    if (renderFrameBuffer == null && renderFrameBufferMS == null) {
        outputBuffer = viewPort.getOutputFrameBuffer();
    }
    Collection<Caps> caps = renderer.getCaps();
    //antialiasing on filters only supported in opengl 3 due to depth read problem
    if (numSamples > 1 && caps.contains(Caps.FrameBufferMultisample)) {
        renderFrameBufferMS = new FrameBuffer(width, height, numSamples);
        if (caps.contains(Caps.OpenGL32)) {
            Texture2D msColor = new Texture2D(width, height, numSamples, fbFormat);
            Texture2D msDepth = new Texture2D(width, height, numSamples, Format.Depth);
            renderFrameBufferMS.setDepthTexture(msDepth);
            renderFrameBufferMS.setColorTexture(msColor);
            filterTexture = msColor;
            depthTexture = msDepth;
        } else {
            renderFrameBufferMS.setDepthBuffer(Format.Depth);
            renderFrameBufferMS.setColorBuffer(fbFormat);
        }
    }
    if (numSamples <= 1 || !caps.contains(Caps.OpenGL32)) {
        renderFrameBuffer = new FrameBuffer(width, height, 1);
        renderFrameBuffer.setDepthBuffer(Format.Depth);
        filterTexture = new Texture2D(width, height, fbFormat);
        renderFrameBuffer.setColorTexture(filterTexture);
    }
    for (Filter filter : filters.getArray()) {
        initFilter(filter, vp);
    }
    setupViewPortFrameBuffer();
}

Example 8 with Caps

use of com.jme3.renderer.Caps in project jmonkeyengine by jMonkeyEngine.

the class TextureUtil method initialize.

public void initialize(EnumSet<Caps> caps) {
    this.formats = GLImageFormats.getFormatsForCaps(caps);
    if (logger.isLoggable(Level.FINE)) {
        StringBuilder sb = new StringBuilder();
        sb.append("Supported texture formats: \n");
        for (int i = 0; i < Format.values().length; i++) {
            Format format = Format.values()[i];
            if (formats[0][i] != null) {
                boolean srgb = formats[1][i] != null;
                sb.append("\t").append(format.toString());
                sb.append(" (Linear");
                if (srgb)
                    sb.append("/sRGB");
                sb.append(")\n");
            }
        }
        logger.log(Level.FINE, sb.toString());
    }
}

Example 9 with Caps

use of com.jme3.renderer.Caps in project jmonkeyengine by jMonkeyEngine.

the class TestTextureArray method simpleInitApp.

@Override
public void simpleInitApp() {
    Material mat = new Material(assetManager, "jme3test/texture/UnshadedArray.j3md");
    for (Caps caps : renderManager.getRenderer().getCaps()) {
        System.out.println(caps.name());
    }
    if (!renderManager.getRenderer().getCaps().contains(Caps.TextureArray)) {
        throw new UnsupportedOperationException("Your hardware does not support TextureArray");
    }
    Texture tex1 = assetManager.loadTexture("Textures/Terrain/Pond/Pond.jpg");
    Texture tex2 = assetManager.loadTexture("Textures/Terrain/Rock2/rock.jpg");
    List<Image> images = new ArrayList<Image>();
    images.add(tex1.getImage());
    images.add(tex2.getImage());
    TextureArray tex3 = new TextureArray(images);
    tex3.setMinFilter(Texture.MinFilter.Trilinear);
    mat.setTexture("ColorMap", tex3);
    Mesh m = new Mesh();
    Vector3f[] vertices = new Vector3f[8];
    vertices[0] = new Vector3f(0, 0, 0);
    vertices[1] = new Vector3f(3, 0, 0);
    vertices[2] = new Vector3f(0, 3, 0);
    vertices[3] = new Vector3f(3, 3, 0);
    vertices[4] = new Vector3f(3, 0, 0);
    vertices[5] = new Vector3f(6, 0, 0);
    vertices[6] = new Vector3f(3, 3, 0);
    vertices[7] = new Vector3f(6, 3, 0);
    Vector3f[] texCoord = new Vector3f[8];
    texCoord[0] = new Vector3f(0, 0, 0);
    texCoord[1] = new Vector3f(1, 0, 0);
    texCoord[2] = new Vector3f(0, 1, 0);
    texCoord[3] = new Vector3f(1, 1, 0);
    texCoord[4] = new Vector3f(0, 0, 1);
    texCoord[5] = new Vector3f(1, 0, 1);
    texCoord[6] = new Vector3f(0, 1, 1);
    texCoord[7] = new Vector3f(1, 1, 1);
    int[] indexes = { 2, 0, 1, 1, 3, 2, 6, 4, 5, 5, 7, 6 };
    m.setBuffer(Type.Position, 3, BufferUtils.createFloatBuffer(vertices));
    m.setBuffer(Type.TexCoord, 3, BufferUtils.createFloatBuffer(texCoord));
    m.setBuffer(Type.Index, 1, BufferUtils.createIntBuffer(indexes));
    m.updateBound();
    Geometry geom = new Geometry("Mesh", m);
    geom.setMaterial(mat);
    rootNode.attachChild(geom);
}

Example 10 with Caps

use of com.jme3.renderer.Caps in project jmonkeyengine by jMonkeyEngine.

the class CurvesTemporalMesh method applyBevelAndTaper.

/**
     * This method applies bevel and taper objects to the curve.
     * @param curve
     *            the curve we apply the objects to
     * @param bevelObject
     *            the bevel object
     * @param taperObject
     *            the taper object
     * @param blenderContext
     *            the blender context
     * @return a list of geometries representing the beveled and/or tapered curve
     * @throws BlenderFileException
     *             an exception is thrown when problems with reading occur
     */
private CurvesTemporalMesh applyBevelAndTaper(CurvesTemporalMesh curve, CurvesTemporalMesh bevelObject, CurvesTemporalMesh taperObject, BlenderContext blenderContext) throws BlenderFileException {
    List<BezierLine> bevelBezierLines = bevelObject.getScaledBeziers();
    List<BezierLine> curveLines = curve.beziers;
    if (bevelBezierLines.size() == 0 || curveLines.size() == 0) {
        return null;
    }
    CurvesTemporalMesh result = new CurvesTemporalMesh(blenderContext);
    for (BezierLine curveLine : curveLines) {
        Vector3f[] curveLineVertices = curveLine.getVertices(bevelStart, bevelEnd);
        for (BezierLine bevelBezierLine : bevelBezierLines) {
            CurvesTemporalMesh partResult = new CurvesTemporalMesh(blenderContext);
            Vector3f[] bevelLineVertices = bevelBezierLine.getVertices();
            List<Vector3f[]> bevels = new ArrayList<Vector3f[]>();
            Vector3f[] bevelPoints = curvesHelper.transformToFirstLineOfBevelPoints(bevelLineVertices, curveLineVertices[0], curveLineVertices[1]);
            bevels.add(bevelPoints);
            for (int i = 1; i < curveLineVertices.length - 1; ++i) {
                bevelPoints = curvesHelper.transformBevel(bevelPoints, curveLineVertices[i - 1], curveLineVertices[i], curveLineVertices[i + 1]);
                bevels.add(bevelPoints);
            }
            bevelPoints = curvesHelper.transformBevel(bevelPoints, curveLineVertices[curveLineVertices.length - 2], curveLineVertices[curveLineVertices.length - 1], null);
            bevels.add(bevelPoints);
            Vector3f subtractResult = new Vector3f();
            if (bevels.size() > 2) {
                // changing the first and last bevel so that they are parallel to their neighbours (blender works this way)
                // notice this implicates that the distances of every corresponding point in the two bevels must be identical and
                // equal to the distance between the points on curve that define the bevel position
                // so instead doing complicated rotations on each point we will simply properly translate each of them
                int[][] pointIndexes = new int[][] { { 0, 1 }, { curveLineVertices.length - 1, curveLineVertices.length - 2 } };
                for (int[] indexes : pointIndexes) {
                    float distance = curveLineVertices[indexes[1]].subtract(curveLineVertices[indexes[0]], subtractResult).length();
                    Vector3f[] bevel = bevels.get(indexes[0]);
                    Vector3f[] nextBevel = bevels.get(indexes[1]);
                    for (int i = 0; i < bevel.length; ++i) {
                        float d = bevel[i].subtract(nextBevel[i], subtractResult).length();
                        subtractResult.normalizeLocal().multLocal(distance - d);
                        bevel[i].addLocal(subtractResult);
                    }
                }
            }
            if (taperObject != null) {
                float curveLength = curveLine.getLength(), lengthAlongCurve = bevelStart;
                for (int i = 0; i < curveLineVertices.length; ++i) {
                    if (i > 0) {
                        lengthAlongCurve += curveLineVertices[i].subtract(curveLineVertices[i - 1], subtractResult).length();
                    }
                    float taperScale = -taperObject.getValueAlongCurve(lengthAlongCurve / curveLength).z * taperObject.scale.z;
                    if (taperScale != 1) {
                        this.applyScale(bevels.get(i), curveLineVertices[i], taperScale);
                    }
                }
            }
            // adding vertices to the part result
            for (Vector3f[] bevel : bevels) {
                for (Vector3f d : bevel) {
                    partResult.getVertices().add(d);
                }
            }
            // preparing faces for the part result (each face is a quad)
            int bevelVertCount = bevelPoints.length;
            for (int i = 0; i < bevels.size() - 1; ++i) {
                for (int j = 0; j < bevelVertCount - 1; ++j) {
                    Integer[] indexes = new Integer[] { i * bevelVertCount + j + 1, (i + 1) * bevelVertCount + j + 1, (i + 1) * bevelVertCount + j, i * bevelVertCount + j };
                    partResult.getFaces().add(new Face(indexes, curveLine.isSmooth(), curveLine.getMaterialNumber(), null, null, partResult));
                    partResult.getEdges().add(new Edge(indexes[0], indexes[1], 0, true, partResult));
                    partResult.getEdges().add(new Edge(indexes[1], indexes[2], 0, true, partResult));
                    partResult.getEdges().add(new Edge(indexes[2], indexes[3], 0, true, partResult));
                    partResult.getEdges().add(new Edge(indexes[3], indexes[0], 0, true, partResult));
                }
                if (bevelBezierLine.isCyclic()) {
                    int j = bevelVertCount - 1;
                    Integer[] indexes = new Integer[] { i * bevelVertCount, (i + 1) * bevelVertCount, (i + 1) * bevelVertCount + j, i * bevelVertCount + j };
                    partResult.getFaces().add(new Face(indexes, curveLine.isSmooth(), curveLine.getMaterialNumber(), null, null, partResult));
                    partResult.getEdges().add(new Edge(indexes[0], indexes[1], 0, true, partResult));
                    partResult.getEdges().add(new Edge(indexes[1], indexes[2], 0, true, partResult));
                    partResult.getEdges().add(new Edge(indexes[2], indexes[3], 0, true, partResult));
                    partResult.getEdges().add(new Edge(indexes[3], indexes[0], 0, true, partResult));
                }
            }
            partResult.generateNormals();
            if (fillCaps) {
                // caps in blender behave as if they weren't affected by the smooth factor
                // START CAP
                Vector3f[] cap = bevels.get(0);
                List<Integer> capIndexes = new ArrayList<Integer>(cap.length);
                Vector3f capNormal = curveLineVertices[0].subtract(curveLineVertices[1]).normalizeLocal();
                for (int i = 0; i < cap.length; ++i) {
                    capIndexes.add(partResult.getVertices().size());
                    partResult.getVertices().add(cap[i]);
                    partResult.getNormals().add(capNormal);
                }
                // the indexes ned to be reversed for the face to have fron face outside the beveled line
                Collections.reverse(capIndexes);
                partResult.getFaces().add(new Face(capIndexes.toArray(new Integer[capIndexes.size()]), false, curveLine.getMaterialNumber(), null, null, partResult));
                for (int i = 1; i < capIndexes.size(); ++i) {
                    partResult.getEdges().add(new Edge(capIndexes.get(i - 1), capIndexes.get(i), 0, true, partResult));
                }
                // END CAP
                cap = bevels.get(bevels.size() - 1);
                capIndexes.clear();
                capNormal = curveLineVertices[curveLineVertices.length - 1].subtract(curveLineVertices[curveLineVertices.length - 2]).normalizeLocal();
                for (int i = 0; i < cap.length; ++i) {
                    capIndexes.add(partResult.getVertices().size());
                    partResult.getVertices().add(cap[i]);
                    partResult.getNormals().add(capNormal);
                }
                partResult.getFaces().add(new Face(capIndexes.toArray(new Integer[capIndexes.size()]), false, curveLine.getMaterialNumber(), null, null, partResult));
                for (int i = 1; i < capIndexes.size(); ++i) {
                    partResult.getEdges().add(new Edge(capIndexes.get(i - 1), capIndexes.get(i), 0, true, partResult));
                }
            }
            result.append(partResult);
        }
    }
    return result;
}