io.qt.qt3d.render.QShaderProgram Maven / Gradle / Ivy

Go to download
package io.qt.qt3d.render;

import io.qt.*;


/**
 * Encapsulates a Shader Program
 * Java wrapper for Qt class Qt3DRender::QShaderProgram
 */
public class QShaderProgram extends io.qt.qt3d.core.QNode
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * This variable stores the meta-object for the class.
     */
    public static final io.qt.core.@NonNull QMetaObject staticMetaObject = io.qt.core.QMetaObject.forType(QShaderProgram.class);
    
    /**
     * Java wrapper for Qt enum Qt3DRender::QShaderProgram::Format
     */
    public enum Format implements QtEnumerator {
        /**
         * Representing Qt3DRender::QShaderProgram::GLSL
         */
        GLSL(0),
        /**
         * Representing Qt3DRender::QShaderProgram::SPIRV
         */
        SPIRV(1);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private Format(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull Format resolve(int value) {
            switch (value) {
            case 0: return GLSL;
            case 1: return SPIRV;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum Qt3DRender::QShaderProgram::ShaderType
     */
    public enum ShaderType implements QtEnumerator {
        /**
         * Representing Qt3DRender::QShaderProgram::Vertex
         */
        Vertex(0),
        /**
         * Representing Qt3DRender::QShaderProgram::Fragment
         */
        Fragment(1),
        /**
         * Representing Qt3DRender::QShaderProgram::TessellationControl
         */
        TessellationControl(2),
        /**
         * Representing Qt3DRender::QShaderProgram::TessellationEvaluation
         */
        TessellationEvaluation(3),
        /**
         * Representing Qt3DRender::QShaderProgram::Geometry
         */
        Geometry(4),
        /**
         * Representing Qt3DRender::QShaderProgram::Compute
         */
        Compute(5);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private ShaderType(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull ShaderType resolve(int value) {
            switch (value) {
            case 0: return Vertex;
            case 1: return Fragment;
            case 2: return TessellationControl;
            case 3: return TessellationEvaluation;
            case 4: return Geometry;
            case 5: return Compute;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum Qt3DRender::QShaderProgram::Status
     */
    public enum Status implements QtEnumerator {
        /**
         * Representing Qt3DRender::QShaderProgram::NotReady
         */
        NotReady(0),
        /**
         * Representing Qt3DRender::QShaderProgram::Ready
         */
        Ready(1),
        /**
         * Representing Qt3DRender::QShaderProgram::Error
         */
        Error(2);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private Status(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull Status resolve(int value) {
            switch (value) {
            case 0: return NotReady;
            case 1: return Ready;
            case 2: return Error;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    

    /**
     * See Qt3DRender::QShaderProgram::computeShaderCodeChanged(QByteArray)
     */
    @QtPropertyNotify(name="computeShaderCode")
    public final @NonNull Signal1 computeShaderCodeChanged = new Signal1<>();

    /**
     * See Qt3DRender::QShaderProgram::formatChanged(Qt3DRender::QShaderProgram::Format)
     */
    @QtPropertyNotify(name="format")
    public final @NonNull Signal1 formatChanged = new Signal1<>();

    /**
     * See Qt3DRender::QShaderProgram::fragmentShaderCodeChanged(QByteArray)
     */
    @QtPropertyNotify(name="fragmentShaderCode")
    public final @NonNull Signal1 fragmentShaderCodeChanged = new Signal1<>();

    /**
     * See Qt3DRender::QShaderProgram::geometryShaderCodeChanged(QByteArray)
     */
    @QtPropertyNotify(name="geometryShaderCode")
    public final @NonNull Signal1 geometryShaderCodeChanged = new Signal1<>();

    /**
     * See Qt3DRender::QShaderProgram::logChanged(QString)
     */
    @QtPropertyNotify(name="log")
    public final @NonNull Signal1 logChanged = new Signal1<>();

    /**
     * See Qt3DRender::QShaderProgram::statusChanged(Qt3DRender::QShaderProgram::Status)
     */
    @QtPropertyNotify(name="status")
    public final @NonNull Signal1 statusChanged = new Signal1<>();

    /**
     * See Qt3DRender::QShaderProgram::tessellationControlShaderCodeChanged(QByteArray)
     */
    @QtPropertyNotify(name="tessellationControlShaderCode")
    public final @NonNull Signal1 tessellationControlShaderCodeChanged = new Signal1<>();

    /**
     * See Qt3DRender::QShaderProgram::tessellationEvaluationShaderCodeChanged(QByteArray)
     */
    @QtPropertyNotify(name="tessellationEvaluationShaderCode")
    public final @NonNull Signal1 tessellationEvaluationShaderCodeChanged = new Signal1<>();

    /**
     * See Qt3DRender::QShaderProgram::vertexShaderCodeChanged(QByteArray)
     */
    @QtPropertyNotify(name="vertexShaderCode")
    public final @NonNull Signal1 vertexShaderCodeChanged = new Signal1<>();
    
    /**
     * See Qt3DRender::QShaderProgram::QShaderProgram(Qt3DCore::QNode*)
     * @param parent
     */
    @SuppressWarnings({"exports"})
    public QShaderProgram(io.qt.qt3d.core.@Nullable QNode parent){
        super((QPrivateConstructor)null);
        initialize_native(this, parent);
    }
    
    private native static void initialize_native(QShaderProgram instance, io.qt.qt3d.core.QNode parent);
    
    /**
     * See Qt3DRender::QShaderProgram::computeShaderCode()const
     * @return
     */
    @QtPropertyReader(name="computeShaderCode")
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray computeShaderCode(){
        return computeShaderCode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray computeShaderCode_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::format()const
     * @return
     */
    @QtPropertyReader(name="format")
    @QtUninvokable
    public final io.qt.qt3d.render.QShaderProgram.@NonNull Format format(){
        return io.qt.qt3d.render.QShaderProgram.Format.resolve(format_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int format_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::fragmentShaderCode()const
     * @return
     */
    @QtPropertyReader(name="fragmentShaderCode")
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray fragmentShaderCode(){
        return fragmentShaderCode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray fragmentShaderCode_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::geometryShaderCode()const
     * @return
     */
    @QtPropertyReader(name="geometryShaderCode")
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray geometryShaderCode(){
        return geometryShaderCode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray geometryShaderCode_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::log()const
     * @return
     */
    @QtPropertyReader(name="log")
    @QtUninvokable
    public final java.lang.@NonNull String log(){
        return log_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String log_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::setComputeShaderCode(QByteArray)
     * @param computeShaderCode
     */
    @QtPropertyWriter(name="computeShaderCode")
    public final void setComputeShaderCode(io.qt.core.@NonNull QByteArray computeShaderCode){
        setComputeShaderCode_native_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(computeShaderCode));
    }
    
    private native void setComputeShaderCode_native_cref_QByteArray(long __this__nativeId, long computeShaderCode);
    
    /**
     * See Qt3DRender::QShaderProgram::setFormat(Qt3DRender::QShaderProgram::Format)
     * @param format
     */
    @QtPropertyWriter(name="format")
    @QtUninvokable
    public final void setFormat(io.qt.qt3d.render.QShaderProgram.@NonNull Format format){
        setFormat_native_Qt3DRender_QShaderProgram_Format(QtJambi_LibraryUtilities.internal.nativeId(this), format.value());
    }
    
    @QtUninvokable
    private native void setFormat_native_Qt3DRender_QShaderProgram_Format(long __this__nativeId, int format);
    
    /**
     * See Qt3DRender::QShaderProgram::setFragmentShaderCode(QByteArray)
     * @param fragmentShaderCode
     */
    @QtPropertyWriter(name="fragmentShaderCode")
    public final void setFragmentShaderCode(io.qt.core.@NonNull QByteArray fragmentShaderCode){
        setFragmentShaderCode_native_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(fragmentShaderCode));
    }
    
    private native void setFragmentShaderCode_native_cref_QByteArray(long __this__nativeId, long fragmentShaderCode);
    
    /**
     * See Qt3DRender::QShaderProgram::setGeometryShaderCode(QByteArray)
     * @param geometryShaderCode
     */
    @QtPropertyWriter(name="geometryShaderCode")
    public final void setGeometryShaderCode(io.qt.core.@NonNull QByteArray geometryShaderCode){
        setGeometryShaderCode_native_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(geometryShaderCode));
    }
    
    private native void setGeometryShaderCode_native_cref_QByteArray(long __this__nativeId, long geometryShaderCode);
    
    /**
     * See Qt3DRender::QShaderProgram::setShaderCode(Qt3DRender::QShaderProgram::ShaderType,QByteArray)
     * @param type
     * @param shaderCode
     */
    @QtUninvokable
    public final void setShaderCode(io.qt.qt3d.render.QShaderProgram.@NonNull ShaderType type, io.qt.core.@NonNull QByteArray shaderCode){
        setShaderCode_native_Qt3DRender_QShaderProgram_ShaderType_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), type.value(), QtJambi_LibraryUtilities.internal.checkedNativeId(shaderCode));
    }
    
    @QtUninvokable
    private native void setShaderCode_native_Qt3DRender_QShaderProgram_ShaderType_cref_QByteArray(long __this__nativeId, int type, long shaderCode);
    
    /**
     * See Qt3DRender::QShaderProgram::setTessellationControlShaderCode(QByteArray)
     * @param tessellationControlShaderCode
     */
    @QtPropertyWriter(name="tessellationControlShaderCode")
    public final void setTessellationControlShaderCode(io.qt.core.@NonNull QByteArray tessellationControlShaderCode){
        setTessellationControlShaderCode_native_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(tessellationControlShaderCode));
    }
    
    private native void setTessellationControlShaderCode_native_cref_QByteArray(long __this__nativeId, long tessellationControlShaderCode);
    
    /**
     * See Qt3DRender::QShaderProgram::setTessellationEvaluationShaderCode(QByteArray)
     * @param tessellationEvaluationShaderCode
     */
    @QtPropertyWriter(name="tessellationEvaluationShaderCode")
    public final void setTessellationEvaluationShaderCode(io.qt.core.@NonNull QByteArray tessellationEvaluationShaderCode){
        setTessellationEvaluationShaderCode_native_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(tessellationEvaluationShaderCode));
    }
    
    private native void setTessellationEvaluationShaderCode_native_cref_QByteArray(long __this__nativeId, long tessellationEvaluationShaderCode);
    
    /**
     * See Qt3DRender::QShaderProgram::setVertexShaderCode(QByteArray)
     * @param vertexShaderCode
     */
    @QtPropertyWriter(name="vertexShaderCode")
    public final void setVertexShaderCode(io.qt.core.@NonNull QByteArray vertexShaderCode){
        setVertexShaderCode_native_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(vertexShaderCode));
    }
    
    private native void setVertexShaderCode_native_cref_QByteArray(long __this__nativeId, long vertexShaderCode);
    
    /**
     * See Qt3DRender::QShaderProgram::shaderCode(Qt3DRender::QShaderProgram::ShaderType)const
     * @param type
     * @return
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray shaderCode(io.qt.qt3d.render.QShaderProgram.@NonNull ShaderType type){
        return shaderCode_native_Qt3DRender_QShaderProgram_ShaderType_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), type.value());
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray shaderCode_native_Qt3DRender_QShaderProgram_ShaderType_constfct(long __this__nativeId, int type);
    
    /**
     * See Qt3DRender::QShaderProgram::status()const
     * @return
     */
    @QtPropertyReader(name="status")
    @QtUninvokable
    public final io.qt.qt3d.render.QShaderProgram.@NonNull Status status(){
        return io.qt.qt3d.render.QShaderProgram.Status.resolve(status_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int status_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::tessellationControlShaderCode()const
     * @return
     */
    @QtPropertyReader(name="tessellationControlShaderCode")
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray tessellationControlShaderCode(){
        return tessellationControlShaderCode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray tessellationControlShaderCode_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::tessellationEvaluationShaderCode()const
     * @return
     */
    @QtPropertyReader(name="tessellationEvaluationShaderCode")
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray tessellationEvaluationShaderCode(){
        return tessellationEvaluationShaderCode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray tessellationEvaluationShaderCode_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::vertexShaderCode()const
     * @return
     */
    @QtPropertyReader(name="vertexShaderCode")
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray vertexShaderCode(){
        return vertexShaderCode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray vertexShaderCode_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QShaderProgram::loadSource(QUrl)
     * @param sourceUrl
     * @return
     */
    public static io.qt.core.@NonNull QByteArray loadSource(io.qt.core.@NonNull QUrl sourceUrl){
        return loadSource_native_cref_QUrl(QtJambi_LibraryUtilities.internal.checkedNativeId(sourceUrl));
    }
    
    private native static io.qt.core.QByteArray loadSource_native_cref_QUrl(long sourceUrl);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QShaderProgram(QPrivateConstructor p) { super(p); } 
    
    /**
     * Constructor for internal use only.
     * It is not allowed to call the declarative constructor from inside Java.
     * @hidden
     */
    @NativeAccess
    protected QShaderProgram(QDeclarativeConstructor constructor) {
        super((QPrivateConstructor)null);
        initialize_native(this, constructor);
    } 
    
    @QtUninvokable
    private static native void initialize_native(QShaderProgram instance, QDeclarativeConstructor constructor);
    
    
    /**
     * Overloaded constructor for {@link #QShaderProgram(io.qt.qt3d.core.QNode)}
     *  with parent = null.
     */
    public QShaderProgram() {
        this((io.qt.qt3d.core.QNode)null);
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #computeShaderCode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray getComputeShaderCode() {
        return computeShaderCode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #format()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.qt3d.render.QShaderProgram.@NonNull Format getFormat() {
        return format();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #fragmentShaderCode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray getFragmentShaderCode() {
        return fragmentShaderCode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #geometryShaderCode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray getGeometryShaderCode() {
        return geometryShaderCode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #log()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final java.lang.@NonNull String getLog() {
        return log();
    }
    
    /**
     * Overloaded function for {@link #setComputeShaderCode(io.qt.core.QByteArray)}.
     */
    public final void setComputeShaderCode(byte @NonNull[] computeShaderCode) {
        setComputeShaderCode(new io.qt.core.QByteArray(computeShaderCode));
    }
    
    /**
     * Overloaded function for {@link #setFragmentShaderCode(io.qt.core.QByteArray)}.
     */
    public final void setFragmentShaderCode(byte @NonNull[] fragmentShaderCode) {
        setFragmentShaderCode(new io.qt.core.QByteArray(fragmentShaderCode));
    }
    
    /**
     * Overloaded function for {@link #setGeometryShaderCode(io.qt.core.QByteArray)}.
     */
    public final void setGeometryShaderCode(byte @NonNull[] geometryShaderCode) {
        setGeometryShaderCode(new io.qt.core.QByteArray(geometryShaderCode));
    }
    
    /**
     * Overloaded function for {@link #setShaderCode(io.qt.qt3d.render.QShaderProgram.ShaderType, io.qt.core.QByteArray)}.
     */
    @QtUninvokable
    public final void setShaderCode(io.qt.qt3d.render.QShaderProgram.@NonNull ShaderType type, byte @NonNull[] shaderCode) {
        setShaderCode(type, new io.qt.core.QByteArray(shaderCode));
    }
    
    /**
     * Overloaded function for {@link #setTessellationControlShaderCode(io.qt.core.QByteArray)}.
     */
    public final void setTessellationControlShaderCode(byte @NonNull[] tessellationControlShaderCode) {
        setTessellationControlShaderCode(new io.qt.core.QByteArray(tessellationControlShaderCode));
    }
    
    /**
     * Overloaded function for {@link #setTessellationEvaluationShaderCode(io.qt.core.QByteArray)}.
     */
    public final void setTessellationEvaluationShaderCode(byte @NonNull[] tessellationEvaluationShaderCode) {
        setTessellationEvaluationShaderCode(new io.qt.core.QByteArray(tessellationEvaluationShaderCode));
    }
    
    /**
     * Overloaded function for {@link #setVertexShaderCode(io.qt.core.QByteArray)}.
     */
    public final void setVertexShaderCode(byte @NonNull[] vertexShaderCode) {
        setVertexShaderCode(new io.qt.core.QByteArray(vertexShaderCode));
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #status()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.qt3d.render.QShaderProgram.@NonNull Status getStatus() {
        return status();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #tessellationControlShaderCode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray getTessellationControlShaderCode() {
        return tessellationControlShaderCode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #tessellationEvaluationShaderCode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray getTessellationEvaluationShaderCode() {
        return tessellationEvaluationShaderCode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #vertexShaderCode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray getVertexShaderCode() {
        return vertexShaderCode();
    }
    
    /**
     * Overloaded function for {@link #loadSource(io.qt.core.QUrl)}.
     */
    public static io.qt.core.@NonNull QByteArray loadSource(java.lang.@NonNull String sourceUrl) {
        return loadSource(new io.qt.core.QUrl(sourceUrl));
    }
}