Java Renderer类代码示例

import com.jme3.renderer.Renderer; //导入依赖的package包/类
/**
 * Start the new jME application.
 *
 * @param application the new jME application.
 */
@JMEThread
private static void startJMEApplication(@NotNull final JmeToJFXApplication application) {

    final InitializationManager initializationManager = InitializationManager.getInstance();
    initializationManager.onBeforeCreateJMEContext();

    application.start();

    final JmeContext context = application.getContext();
    final Renderer renderer = context.getRenderer();

    if (renderer == null) {
        final EditorConfig editorConfig = EditorConfig.getInstance();
        editorConfig.setOpenGLVersion(OpenGLVersion.GL_20);
        editorConfig.save();
    }
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
@Override
public void simpleRender(RenderManager rm){
    Renderer r = rm.getRenderer();

    //do FBO rendering
    r.setFrameBuffer(fb);

    rm.setCamera(cam, false); // FBO uses current camera
    r.clearBuffers(true, true, true);
    rm.renderScene(fbNode, viewPort);
    rm.flushQueue(viewPort);

    //go back to default rendering and let
    //SimpleApplication render the default scene
    r.setFrameBuffer(null);
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
private void renderProcessing(Renderer r, FrameBuffer dst, Material mat){
    if (dst == null){
        fsQuad.setWidth(mainSceneFB.getWidth());
        fsQuad.setHeight(mainSceneFB.getHeight());
        fbCam.resize(mainSceneFB.getWidth(), mainSceneFB.getHeight(), true);
    }else{
        fsQuad.setWidth(dst.getWidth());
        fsQuad.setHeight(dst.getHeight());
        fbCam.resize(dst.getWidth(), dst.getHeight(), true);
    }
    fsQuad.setMaterial(mat);
    fsQuad.updateGeometricState();
    renderManager.setCamera(fbCam, true);

    r.setFrameBuffer(dst);
    r.clearBuffers(true, true, true);
    renderManager.renderGeometry(fsQuad);
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
/**
 * Instantiates a new JM e3 content system factory.
 *
 * @param renderer
 *            the renderer
 * @param audioRenderer
 *            the audio renderer
 * @param assetManager
 *            the asset manager
 * @param updateList
 *            the update list
 * @throws ClassNotFoundException
 *             the class not found exception
 * @throws IOException
 *             Signals that an I/O exception has occurred.
 * @throws ContentTypeAlreadyBoundException
 *             the content type already bound exception
 * @throws ContentTypeInvalidException
 *             the content type invalid exception
 */
public JME3ContentSystemFactory(Renderer renderer, AudioRenderer audioRenderer, AssetManager assetManager, List<IUpdateable> updateList) throws ClassNotFoundException, IOException, ContentTypeAlreadyBoundException, ContentTypeInvalidException
{
	super("multiplicity3.jme3csys.items", new IResourceFinderFilter()
	{
		@Override
		public boolean accept(String dottedResourcePathname)
		{
			String[] components = dottedResourcePathname.split("\\.");
			if (components.length < 2)
			{
				return false;
			}
			String extension = components[components.length - 1];
			String name = components[components.length - 2];
			return extension.equals("class") && name.startsWith("JME") && !name.endsWith("Delegate") && !name.endsWith("$1");
		}
	});
	this.setRenderer(renderer);
	this.setAudioRenderer(audioRenderer);
	this.assetManager = assetManager;
	this.updateList = updateList;
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
public static void checkCapabilities(Renderer renderer) {
    shader_dof = false;
    texture_anistrophy = false;

    Collection<Caps> caps = renderer.getCaps();
    System.out.println("caps: " + caps.toString());

    for (Caps c : caps) {
        switch (c) {
            case DepthTexture: {
                shader_dof = true;
            }
            case TextureFilterAnisotropic: {
                texture_anistrophy = true;
            }
        }
    }
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
@Override
public void postQueue(RenderQueue rq) {
    if (occluders == null) {
        return;
    }
    Renderer renderer = renderManager.getRenderer();

    renderer.setFrameBuffer(fogFb);
    renderer.clearBuffers(true, true, true);

    if (fogPreventers == 0) {

        renderManager.setForcedMaterial(fogShapeMaterial);
        for (Geometry geometry : occluders) {
            renderManager.renderGeometry(geometry);
        }

        renderManager.setForcedMaterial(null);
    }

    renderer.setFrameBuffer(viewPort.getOutputFrameBuffer());
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
public HDRRenderer(AssetManager manager, Renderer renderer){
    this.manager = manager;
    this.renderer = renderer;
    
    Collection<Caps> caps = renderer.getCaps();
    if (caps.contains(Caps.PackedFloatColorBuffer))
        bufFormat = Format.RGB111110F;
    else if (caps.contains(Caps.FloatColorBuffer))
        bufFormat = Format.RGB16F;
    else{
        enabled = false;
        return;
    }
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
private void renderToneMap(Renderer r, FrameBuffer out){
    tone.setFloat("A", exposure);
    tone.setFloat("White", whiteLevel);
    tone.setTexture("Lum", scene1[oppSrc]);
    tone.setTexture("Lum2", scene1[curSrc]);
    tone.setFloat("BlendFactor", blendFactor);
    renderProcessing(r, out, tone);
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
/**
 * cleanup this filter
 * @param r 
 */
protected final void cleanup(Renderer r) {
    processor = null;
    if (defaultPass != null) {
        defaultPass.cleanup(r);
    }
    if (postRenderPasses != null) {
        for (Iterator<Pass> it = postRenderPasses.iterator(); it.hasNext();) {
            Pass pass = it.next();
            pass.cleanup(r);
        }
    }
    cleanUpFilter(r);
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
@Override
protected void postQueue(RenderManager renderManager, ViewPort viewPort) {
    Renderer r = renderManager.getRenderer();
    r.setFrameBuffer(normalPass.getRenderFrameBuffer());
    renderManager.getRenderer().clearBuffers(true, true, true);
    renderManager.setForcedTechnique("PreNormalPass");
    renderManager.renderViewPortQueues(viewPort, false);
    renderManager.setForcedTechnique(null);
    renderManager.getRenderer().setFrameBuffer(viewPort.getOutputFrameBuffer());
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
/**
 * renders a filter on a fullscreen quad
 * @param r
 * @param buff
 * @param mat 
 */
private void renderProcessing(Renderer r, FrameBuffer buff, Material mat) {
    if (buff == outputBuffer) {
        fsQuad.setWidth(width);
        fsQuad.setHeight(height);
        filterCam.resize(originalWidth, originalHeight, true);
        fsQuad.setPosition(left * originalWidth, bottom * originalHeight);
    } else {
        fsQuad.setWidth(buff.getWidth());
        fsQuad.setHeight(buff.getHeight());
        filterCam.resize(buff.getWidth(), buff.getHeight(), true);
        fsQuad.setPosition(0, 0);
    }

    if (mat.getAdditionalRenderState().isDepthWrite()) {
        mat.getAdditionalRenderState().setDepthTest(false);
        mat.getAdditionalRenderState().setDepthWrite(false);
    }

    fsQuad.setMaterial(mat);
    fsQuad.updateGeometricState();

    renderManager.setCamera(filterCam, true);
    r.setFrameBuffer(buff);
    r.clearBuffers(false, true, true);
    renderManager.renderGeometry(fsQuad);

}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
protected void displayMap(Renderer r, Picture pic, int left) {
    Camera cam = vp.getCamera();
    rm.setCamera(cam, true);
    int h = cam.getHeight();

    pic.setPosition(left, h / 20f);

    pic.setWidth(128);
    pic.setHeight(128);
    pic.updateGeometricState();
    rm.renderGeometry(pic);
    rm.setCamera(cam, false);
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
/**
 * Preloads this material for the given render manager.
 * <p>
 * Preloading the material can ensure that when the material is first
 * used for rendering, there won't be any delay since the material has
 * been already been setup for rendering.
 * 
 * @param rm The render manager to preload for
 */
public void preload(RenderManager rm) {
    autoSelectTechnique(rm);

    Renderer r = rm.getRenderer();
    TechniqueDef techDef = technique.getDef();

    Collection<MatParam> params = paramValues.values();
    for (MatParam param : params) {
        if (param instanceof MatParamTexture) {
            MatParamTexture texParam = (MatParamTexture) param;
            r.setTexture(0, texParam.getTextureValue());
        } else {
            if (!techDef.isUsingShaders()) {
                continue;
            }

            technique.updateUniformParam(param.getName(),
                    param.getVarType(),
                    param.getValue(), true);
        }
    }

    Shader shader = technique.getShader();
    if (techDef.isUsingShaders()) {
        r.setShader(shader);
    }
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
@Override
public void apply(Renderer r, Technique technique) {
    TechniqueDef techDef = technique.getDef();
    r.setTexture(getUnit(), getTextureValue());
    if (techDef.isUsingShaders()) {
        technique.updateUniformParam(getPrefixedName(), getVarType(), getUnit(), true);
    }
}
 

import com.jme3.renderer.Renderer; //导入依赖的package包/类
void apply(Renderer r, Technique technique) {
    TechniqueDef techDef = technique.getDef();
    if (techDef.isUsingShaders()) {
        technique.updateUniformParam(getPrefixedName(), getVarType(), getValue(), true);
    }
    if (ffBinding != null && r instanceof GL1Renderer) {
        ((GL1Renderer) r).setFixedFuncBinding(ffBinding, getValue());
    }
}