Java Shader类代码示例

import com.jme3.shader.Shader; //导入依赖的package包/类
public void deleteShader(Shader shader) {
        if (shader.getId() == -1) {
            logger.warning("Shader is not uploaded to GPU, cannot delete.");
            return;
        }
        for (ShaderSource source : shader.getSources()) {
            if (source.getId() != -1) {
                glDetachShader(shader.getId(), source.getId());
                // the next part is done by the GLObjectManager automatically
//                glDeleteShader(source.getId());
            }
        }
        // kill all references so sources can be collected
        // if needed.
        shader.resetSources();
        glDeleteProgram(shader.getId());

        statistics.onDeleteShader();
    }
 

import com.jme3.shader.Shader; //导入依赖的package包/类
/**
 * Creates new form NodePanel
 */
@SuppressWarnings("LeakingThisInConstructor")
public NodePanel(ShaderNodeBlock node, ShaderNodeDefinition def) {
    super();
    shaderType = def.getType();
    if (def.getType() == Shader.ShaderType.Vertex) {
        type = NodePanel.NodeType.Vertex;
    } else {
        type = NodePanel.NodeType.Fragment;
    }
    init(def.getInputs(), def.getOutputs());

    node.addPropertyChangeListener(WeakListeners.propertyChange(this, node));
    this.addPropertyChangeListener(WeakListeners.propertyChange(node, this));
    refresh(node);
    addKeyListener(this);
    this.filePaths.addAll(def.getShadersPath());
    String defPath = ((DefinitionBlock) node.getContents().get(0)).getPath();
    this.filePaths.add(defPath);
    toolBar = new NodeToolBar(this);        
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
/*********************************************************************\
 |* Shaders                                                           *|
 \*********************************************************************/
protected void updateUniformLocation(Shader shader, Uniform uniform) {
    stringBuf.setLength(0);
    stringBuf.append(uniform.getName()).append('\0');
    updateNameBuffer();
    if (verboseLogging) {
        logger.log(Level.INFO, "GLES20.glGetUniformLocation({0}, {1})", new Object[]{shader.getId(), uniform.getName()});
    }
    int loc = Gdx.gl20.glGetUniformLocation(shader.getId(), uniform.getName());
    checkGLError();
    if (loc < 0) {
        uniform.setLocation(-1);
        // uniform is not declared in shader
        if (verboseLogging) {
            logger.log(Level.WARNING, "Uniform [{0}] is not declared in shader.", uniform.getName());
        }
    } else {
        uniform.setLocation(loc);
    }
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
/*********************************************************************\
|* Shaders                                                           *|
\*********************************************************************/
protected void updateUniformLocation(Shader shader, Uniform uniform) {
    stringBuf.setLength(0);
    stringBuf.append(uniform.getName()).append('\0');
    updateNameBuffer();
    if (verboseLogging) {
        logger.log(Level.INFO, "GLES20.glGetUniformLocation({0}, {1})", new Object[]{shader.getId(), uniform.getName()});
    }
    int loc = GLES20.glGetUniformLocation(shader.getId(), uniform.getName());
    checkGLError();
    if (loc < 0) {
        uniform.setLocation(-1);
        // uniform is not declared in shader
        if (verboseLogging) {
            logger.log(Level.WARNING, "Uniform [{0}] is not declared in shader.", uniform.getName());
        }
    } else {
        uniform.setLocation(loc);
    }
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
protected void updateUniform(Shader shader, Uniform uniform) {
    if (glslVer != -1) {
        int shaderId = shader.getId();

        assert uniform.getName() != null;
        assert shader.getId() > 0;
        if (context.boundShaderProgram != shaderId) {
            helper.useProgram(shaderId);
            statistics.onShaderUse(shader, true);
            boundShader = shader;
            context.boundShaderProgram = shaderId;
        }
        else {
            statistics.onShaderUse(shader, false);
        }

        updateUniformVar(shader, uniform);
    }
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
protected void updateUniformLocation(Shader shader, Uniform uniform) {
    if (glslVer != -1) {
        stringBuf.setLength(0);
        stringBuf.append(uniform.getName()).append('\0');
        updateNameBuffer();
        int loc = getUniformLocation(shader);
        if (loc < 0) {
            uniform.setLocation(-1);
            // uniform is not declared in shader
            logger.log(Level.WARNING, "Uniform {0} is not declared in shader.",
                    uniform.getName());
        }
        else {
            uniform.setLocation(loc);
        }
    }
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
public void deleteShader(Shader shader) {
    if (glslVer != -1) {
        if (shader.getId() == -1) {
            logger.warning("Shader is not uploaded to GPU, cannot delete.");
            return;
        }
        GL gl = GLContext.getCurrentGL();
        for (ShaderSource source : shader.getSources()) {
            if (source.getId() != -1) {
                gl.getGL2().glDetachShader(shader.getId(), source.getId());
                // the next part is done by the GLObjectManager automatically
                // glDeleteShader(source.getId());
            }
        }
        // kill all references so sources can be collected
        // if needed.
        shader.resetSources();
        gl.getGL2().glDeleteProgram(shader.getId());

        statistics.onDeleteShader();
    }
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
public void deleteShader(Shader shader) {
    if (shader.getId() == -1) {
        logger.warning("Shader is not uploaded to GPU, cannot delete.");
        return;
    }

    for (ShaderSource source : shader.getSources()) {
        if (source.getId() != -1) {
            glDetachShader(shader.getId(), source.getId());
            deleteShaderSource(source);
        }
    }

    // kill all references so sources can be collected
    // if needed.
    shader.resetSources();
    glDeleteProgram(shader.getId());

    statistics.onDeleteShader();
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
/**
 * Check a material definition on containing a shader.
 *
 * @param materialDef the material definition.
 * @param assetPath   the path of the shader.
 * @return true if the material definition contains the shader.
 */
private static boolean containsShader(@NotNull final MaterialDef materialDef, @NotNull final String assetPath) {

    final List<TechniqueDef> defaultTechniques = materialDef.getTechniqueDefs("Default");

    for (final TechniqueDef technique : defaultTechniques) {
        final EnumMap<Shader.ShaderType, String> shaderProgramNames = technique.getShaderProgramNames();
        if (shaderProgramNames.containsValue(assetPath)) return true;
    }

    return false;
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
/*********************************************************************\
|* Shaders                                                           *|
\*********************************************************************/
protected void updateUniformLocation(Shader shader, Uniform uniform) {
    stringBuf.setLength(0);
    stringBuf.append(uniform.getName()).append('\0');
    updateNameBuffer();
    int loc = glGetUniformLocation(shader.getId(), nameBuf);
    if (loc < 0) {
        uniform.setLocation(-1);
        // uniform is not declared in shader
        logger.log(Level.INFO, "Uniform {0} is not declared in shader.", uniform.getName());
    } else {
        uniform.setLocation(loc);
    }
}
 

import com.jme3.shader.Shader; //导入依赖的package包/类
protected void updateShaderUniforms(Shader shader) {
        ListMap<String, Uniform> uniforms = shader.getUniformMap();
//        for (Uniform uniform : shader.getUniforms()){
        for (int i = 0; i < uniforms.size(); i++) {
            Uniform uniform = uniforms.getValue(i);
            if (uniform.isUpdateNeeded()) {
                updateUniform(shader, uniform);
            }
        }
    }
 

import com.jme3.shader.Shader; //导入依赖的package包/类
protected void resetUniformLocations(Shader shader) {
        ListMap<String, Uniform> uniforms = shader.getUniformMap();
//        for (Uniform uniform : shader.getUniforms()){
        for (int i = 0; i < uniforms.size(); i++) {
            Uniform uniform = uniforms.getValue(i);
            uniform.reset(); // e.g check location again
        }
    }
 

import com.jme3.shader.Shader; //导入依赖的package包/类
/**
 * Called by the Renderer when a shader has been utilized.
 * 
 * @param shader The shader that was used
 * @param wasSwitched If true, the shader has required a state switch
 */
public void onShaderUse(Shader shader, boolean wasSwitched){
    assert shader.id >= 1;

    if (!shadersUsed.contains(shader.id))
        shadersUsed.add(shader.id);

    if (wasSwitched)
        numShaderSwitches++;
}
 

import com.jme3.shader.Shader; //导入依赖的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.shader.Shader; //导入依赖的package包/类
private void clearUniformsSetByCurrent(Shader shader) {
    ListMap<String, Uniform> uniforms = shader.getUniformMap();
    for (int i = 0; i < uniforms.size(); i++) {
        Uniform u = uniforms.getValue(i);
        u.clearSetByCurrentMaterial();
    }
}