Examples with PipelineRenderingContext com.gempukku.libgdx.graph.pipeline.producer.PipelineRenderingContext used on opensource projects

Example 11 with PipelineRenderingContext

use of com.gempukku.libgdx.graph.pipeline.producer.PipelineRenderingContext in project gdx-graph by MarcinSc.

the class RenderSizePipelineNodeProducer method createNodeForSingleInputs.

@Override
public PipelineNode createNodeForSingleInputs(JsonValue data, ObjectMap<String, String> inputTypes, ObjectMap<String, String> outputTypes) {
    final Vector2 size = new Vector2();
    final DefaultFieldOutput<Vector2> sizeOutput = new DefaultFieldOutput<>(PipelineFieldType.Vector2);
    sizeOutput.setValue(size);
    final DefaultFieldOutput<Float> widthOutput = new DefaultFieldOutput<>(PipelineFieldType.Float);
    final DefaultFieldOutput<Float> heightOutput = new DefaultFieldOutput<>(PipelineFieldType.Float);
    final ObjectMap<String, PipelineNode.FieldOutput<?>> result = new ObjectMap<>();
    result.put("size", sizeOutput);
    result.put("width", widthOutput);
    result.put("height", heightOutput);
    return new SingleInputsPipelineNode(result) {

        @Override
        public void executeNode(PipelineRenderingContext pipelineRenderingContext, PipelineRequirementsCallback pipelineRequirementsCallback) {
            int width = pipelineRenderingContext.getRenderWidth();
            int height = pipelineRenderingContext.getRenderHeight();
            size.set(width, height);
            widthOutput.setValue(width * 1f);
            heightOutput.setValue(height * 1f);
        }
    };
}

Example 12 with PipelineRenderingContext

use of com.gempukku.libgdx.graph.pipeline.producer.PipelineRenderingContext in project gdx-graph by MarcinSc.

the class MultiplyPipelineNodeProducer method createNode.

@Override
public PipelineNode createNode(JsonValue data, ObjectMap<String, Array<String>> inputTypes, ObjectMap<String, String> outputTypes) {
    final String resultType = outputTypes.get("output");
    final Object resultValue = createDefaultValue(resultType);
    final ObjectMap<String, PipelineNode.FieldOutput<?>> result = new ObjectMap<>();
    final DefaultFieldOutput resultOutput = new DefaultFieldOutput(resultType);
    result.put("output", resultOutput);
    return new AbstractPipelineNode(result) {

        private Array<FieldOutput<?>> inputs;

        @Override
        public void setInputs(ObjectMap<String, Array<FieldOutput<?>>> inputs) {
            this.inputs = inputs.get("inputs");
        }

        @Override
        public void executeNode(PipelineRenderingContext pipelineRenderingContext, PipelineRequirementsCallback pipelineRequirementsCallback) {
            Object returnValue = resetDefaultValue(resultType, resultValue);
            for (FieldOutput<?> input : inputs) {
                Object value = input.getValue();
                returnValue = multiply(returnValue, value);
            }
            resultOutput.setValue(returnValue);
        }
    };
}

Example 13 with PipelineRenderingContext

use of com.gempukku.libgdx.graph.pipeline.producer.PipelineRenderingContext in project gdx-graph by MarcinSc.

the class BloomPipelineNodeProducer method createNodeForSingleInputs.

@Override
public PipelineNode createNodeForSingleInputs(JsonValue data, ObjectMap<String, String> inputTypes, ObjectMap<String, String> outputTypes) {
    final ShaderProgram brightnessFilterPassProgram = new ShaderProgram(Gdx.files.classpath("shader/viewToScreenCoords.vert"), Gdx.files.classpath("shader/brightnessFilter.frag"));
    if (!brightnessFilterPassProgram.isCompiled())
        throw new IllegalArgumentException("Error compiling shader: " + brightnessFilterPassProgram.getLog());
    final ShaderProgram gaussianBlurPassProgram = new ShaderProgram(Gdx.files.classpath("shader/viewToScreenCoords.vert"), Gdx.files.classpath("shader/gaussianBlur.frag"));
    if (!gaussianBlurPassProgram.isCompiled())
        throw new IllegalArgumentException("Error compiling shader: " + gaussianBlurPassProgram.getLog());
    final ShaderProgram bloomSumProgram = new ShaderProgram(Gdx.files.classpath("shader/viewToScreenCoords.vert"), Gdx.files.classpath("shader/bloomSum.frag"));
    if (!bloomSumProgram.isCompiled())
        throw new IllegalArgumentException("Error compiling shader: " + bloomSumProgram.getLog());
    final ObjectMap<String, PipelineNode.FieldOutput<?>> result = new ObjectMap<>();
    final DefaultFieldOutput<RenderPipeline> pipelineOutput = new DefaultFieldOutput<>(PipelineFieldType.RenderPipeline);
    result.put("output", pipelineOutput);
    return new SingleInputsPipelineNode(result) {

        private FullScreenRender fullScreenRender;

        @Override
        public void initializePipeline(PipelineDataProvider pipelineDataProvider) {
            fullScreenRender = pipelineDataProvider.getFullScreenRender();
        }

        @Override
        public void executeNode(PipelineRenderingContext pipelineRenderingContext, PipelineRequirementsCallback pipelineRequirementsCallback) {
            PipelineNode.FieldOutput<RenderPipeline> renderPipelineInput = (PipelineNode.FieldOutput<RenderPipeline>) inputs.get("input");
            PipelineNode.FieldOutput<Boolean> processorEnabled = (PipelineNode.FieldOutput<Boolean>) inputs.get("enabled");
            PipelineNode.FieldOutput<Float> minimalBrightness = (PipelineNode.FieldOutput<Float>) inputs.get("minimalBrightness");
            PipelineNode.FieldOutput<Float> bloomRadius = (PipelineNode.FieldOutput<Float>) inputs.get("bloomRadius");
            PipelineNode.FieldOutput<Float> bloomStrength = (PipelineNode.FieldOutput<Float>) inputs.get("bloomStrength");
            RenderPipeline renderPipeline = renderPipelineInput.getValue();
            boolean enabled = processorEnabled == null || processorEnabled.getValue();
            float bloomStrengthValue = bloomStrength != null ? bloomStrength.getValue() : 0f;
            int bloomRadiusValue = MathUtils.round(bloomRadius != null ? bloomRadius.getValue() : 1f);
            if (enabled && bloomStrengthValue > 0 && bloomRadiusValue > 0) {
                float minimalBrightnessValue = minimalBrightness != null ? minimalBrightness.getValue() : 0.7f;
                RenderPipelineBuffer originalBuffer = renderPipeline.getDefaultBuffer();
                OpenGLContext renderContext = pipelineRenderingContext.getRenderContext();
                renderContext.setDepthTest(0);
                renderContext.setDepthMask(false);
                renderContext.setBlending(false, 0, 0);
                renderContext.setCullFace(GL20.GL_BACK);
                RenderPipelineBuffer brightnessFilterBuffer = runBrightnessPass(minimalBrightnessValue, renderPipeline, originalBuffer, brightnessFilterPassProgram, pipelineRenderingContext.getRenderContext(), fullScreenRender);
                RenderPipelineBuffer gaussianBlur = applyGaussianBlur(bloomRadiusValue, renderPipeline, brightnessFilterBuffer, gaussianBlurPassProgram, pipelineRenderingContext.getRenderContext(), fullScreenRender);
                renderPipeline.returnFrameBuffer(brightnessFilterBuffer);
                RenderPipelineBuffer result = applyTheBloom(bloomStrengthValue, renderPipeline, originalBuffer, gaussianBlur, bloomSumProgram, pipelineRenderingContext.getRenderContext(), fullScreenRender);
                renderPipeline.returnFrameBuffer(gaussianBlur);
                renderPipeline.swapColorTextures(originalBuffer, result);
                renderPipeline.returnFrameBuffer(result);
            }
            pipelineOutput.setValue(renderPipeline);
        }

        @Override
        public void dispose() {
            bloomSumProgram.dispose();
            gaussianBlurPassProgram.dispose();
            brightnessFilterPassProgram.dispose();
        }
    };
}

Example 14 with PipelineRenderingContext

use of com.gempukku.libgdx.graph.pipeline.producer.PipelineRenderingContext in project gdx-graph by MarcinSc.

the class CrossProductPipelineNodeProducer method createNodeForSingleInputs.

@Override
public PipelineNode createNodeForSingleInputs(JsonValue data, ObjectMap<String, String> inputTypes, ObjectMap<String, String> outputTypes) {
    final Vector3 tmpVector = new Vector3();
    final ObjectMap<String, PipelineNode.FieldOutput<?>> result = new ObjectMap<>();
    final DefaultFieldOutput resultOutput = new DefaultFieldOutput(PipelineFieldType.Vector3);
    result.put("output", resultOutput);
    return new SingleInputsPipelineNode(result) {

        @Override
        public void executeNode(PipelineRenderingContext pipelineRenderingContext, PipelineRequirementsCallback pipelineRequirementsCallback) {
            FieldOutput<?> aFunction = inputs.get("a");
            FieldOutput<?> bFunction = inputs.get("b");
            Vector3 a = (Vector3) aFunction.getValue();
            Vector3 b = (Vector3) bFunction.getValue();
            Vector3 returnValue = tmpVector.set(a).crs(b);
            resultOutput.setValue(returnValue);
        }
    };
}

Example 15 with PipelineRenderingContext

use of com.gempukku.libgdx.graph.pipeline.producer.PipelineRenderingContext in project gdx-graph by MarcinSc.

the class NormalizePipelineNodeProducer method createNodeForSingleInputs.

@Override
public PipelineNode createNodeForSingleInputs(JsonValue data, ObjectMap<String, String> inputTypes, ObjectMap<String, String> outputTypes) {
    final String resultType = inputTypes.get("input");
    final Object resultValue = createResult(resultType);
    final ObjectMap<String, PipelineNode.FieldOutput<?>> result = new ObjectMap<>();
    final DefaultFieldOutput resultOutput = new DefaultFieldOutput(resultType);
    result.put("output", resultOutput);
    return new SingleInputsPipelineNode(result) {

        private FieldOutput<?> aFunction;

        @Override
        public void executeNode(PipelineRenderingContext pipelineRenderingContext, PipelineRequirementsCallback pipelineRequirementsCallback) {
            aFunction = inputs.get("input");
            Object a = aFunction.getValue();
            Object returnValue;
            if (a instanceof Float) {
                returnValue = Math.signum((float) a);
            } else if (a instanceof Vector2) {
                returnValue = ((Vector2) resultValue).set((Vector2) a).nor();
            } else if (a instanceof Vector3) {
                returnValue = ((Vector3) resultValue).set((Vector3) a).nor();
            } else {
                Color aColor = (Color) a;
                float length = (float) Math.sqrt(aColor.r * aColor.r + aColor.g * aColor.g + aColor.b * aColor.b + aColor.a * aColor.a);
                returnValue = ((Color) resultValue).set(aColor.r / length, aColor.b / length, aColor.b / length, aColor.a / length);
            }
            resultOutput.setValue(returnValue);
        }
    };
}