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

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

import io.qt.*;


/**
 * Defines a view point through which the scene will be rendered
 * Java wrapper for Qt class Qt3DRender::QCamera
 */
public class QCamera extends io.qt.qt3d.core.QEntity
{
    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(QCamera.class);
    
    /**
     * Java wrapper for Qt enum Qt3DRender::QCamera::CameraTranslationOption
     */
    public enum CameraTranslationOption implements QtEnumerator {
        /**
         * Representing Qt3DRender::QCamera::TranslateViewCenter
         */
        TranslateViewCenter(0),
        /**
         * Representing Qt3DRender::QCamera::DontTranslateViewCenter
         */
        DontTranslateViewCenter(1);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private CameraTranslationOption(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 CameraTranslationOption resolve(int value) {
            switch (value) {
            case 0: return TranslateViewCenter;
            case 1: return DontTranslateViewCenter;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    

    /**
     * See Qt3DRender::QCamera::aspectRatioChanged(float)
     */
    @QtPropertyNotify(name="aspectRatio")
    public final @NonNull Signal1 aspectRatioChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::bottomChanged(float)
     */
    @QtPropertyNotify(name="bottom")
    public final @NonNull Signal1 bottomChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::exposureChanged(float)
     */
    @QtPropertyNotify(name="exposure")
    public final @NonNull Signal1 exposureChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::farPlaneChanged(float)
     */
    @QtPropertyNotify(name="farPlane")
    public final @NonNull Signal1 farPlaneChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::fieldOfViewChanged(float)
     */
    @QtPropertyNotify(name="fieldOfView")
    public final @NonNull Signal1 fieldOfViewChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::leftChanged(float)
     */
    @QtPropertyNotify(name="left")
    public final @NonNull Signal1 leftChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::nearPlaneChanged(float)
     */
    @QtPropertyNotify(name="nearPlane")
    public final @NonNull Signal1 nearPlaneChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::positionChanged(QVector3D)
     */
    @QtPropertyNotify(name="position")
    public final @NonNull Signal1 positionChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::projectionMatrixChanged(QMatrix4x4)
     */
    @QtPropertyNotify(name="projectionMatrix")
    public final @NonNull Signal1 projectionMatrixChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::projectionTypeChanged(Qt3DRender::QCameraLens::ProjectionType)
     */
    @QtPropertyNotify(name="projectionType")
    public final @NonNull Signal1 projectionTypeChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::rightChanged(float)
     */
    @QtPropertyNotify(name="right")
    public final @NonNull Signal1 rightChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::topChanged(float)
     */
    @QtPropertyNotify(name="top")
    public final @NonNull Signal1 topChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::upVectorChanged(QVector3D)
     */
    @QtPropertyNotify(name="upVector")
    public final @NonNull Signal1 upVectorChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::viewCenterChanged(QVector3D)
     */
    @QtPropertyNotify(name="viewCenter")
    public final @NonNull Signal1 viewCenterChanged = new Signal1<>();

    /**
     * See Qt3DRender::QCamera::viewMatrixChanged()
     */
    @QtPropertyNotify(name="viewMatrix")
    public final @NonNull Signal0 viewMatrixChanged = new Signal0();

    /**
     * See Qt3DRender::QCamera::viewVectorChanged(QVector3D)
     */
    @QtPropertyNotify(name="viewVector")
    public final @NonNull Signal1 viewVectorChanged = new Signal1<>();
    
    /**
     * See Qt3DRender::QCamera::QCamera(QNode*)
     * @param parent
     */
    @SuppressWarnings({"exports"})
    public QCamera(io.qt.qt3d.core.@Nullable QNode parent){
        super((QPrivateConstructor)null);
        initialize_native(this, parent);
    }
    
    private native static void initialize_native(QCamera instance, io.qt.qt3d.core.QNode parent);
    
    /**
     * See Qt3DRender::QCamera::aspectRatio()const
     * @return
     */
    @QtPropertyReader(name="aspectRatio")
    @QtUninvokable
    public final float aspectRatio(){
        return aspectRatio_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float aspectRatio_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::bottom()const
     * @return
     */
    @QtPropertyReader(name="bottom")
    @QtUninvokable
    public final float bottom(){
        return bottom_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float bottom_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::exposure()const
     * @return
     */
    @QtPropertyReader(name="exposure")
    @QtUninvokable
    public final float exposure(){
        return exposure_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float exposure_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::farPlane()const
     * @return
     */
    @QtPropertyReader(name="farPlane")
    @QtUninvokable
    public final float farPlane(){
        return farPlane_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float farPlane_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::fieldOfView()const
     * @return
     */
    @QtPropertyReader(name="fieldOfView")
    @QtUninvokable
    public final float fieldOfView(){
        return fieldOfView_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float fieldOfView_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::left()const
     * @return
     */
    @QtPropertyReader(name="left")
    @QtUninvokable
    public final float left(){
        return left_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float left_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::lens()const
     * @return
     */
    @QtPropertyReader(name="lens")
    @QtPropertyConstant
    @QtUninvokable
    public final io.qt.qt3d.render.@Nullable QCameraLens lens(){
        return lens_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.qt3d.render.QCameraLens lens_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::nearPlane()const
     * @return
     */
    @QtPropertyReader(name="nearPlane")
    @QtUninvokable
    public final float nearPlane(){
        return nearPlane_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float nearPlane_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::pan(float)
     * @param angle
     */
    public final void pan(float angle){
        pan_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native void pan_native_float(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::pan(float,QVector3D)
     * @param angle
     * @param axis
     */
    public final void pan(float angle, io.qt.gui.@NonNull QVector3D axis){
        pan_native_float_cref_QVector3D(QtJambi_LibraryUtilities.internal.nativeId(this), angle, QtJambi_LibraryUtilities.internal.checkedNativeId(axis));
    }
    
    private native void pan_native_float_cref_QVector3D(long __this__nativeId, float angle, long axis);
    
    /**
     * See Qt3DRender::QCamera::panAboutViewCenter(float)
     * @param angle
     */
    public final void panAboutViewCenter(float angle){
        panAboutViewCenter_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native void panAboutViewCenter_native_float(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::panAboutViewCenter(float,QVector3D)
     * @param angle
     * @param axis
     */
    public final void panAboutViewCenter(float angle, io.qt.gui.@NonNull QVector3D axis){
        panAboutViewCenter_native_float_cref_QVector3D(QtJambi_LibraryUtilities.internal.nativeId(this), angle, QtJambi_LibraryUtilities.internal.checkedNativeId(axis));
    }
    
    private native void panAboutViewCenter_native_float_cref_QVector3D(long __this__nativeId, float angle, long axis);
    
    /**
     * See Qt3DRender::QCamera::panRotation(float)const
     * @param angle
     * @return
     */
    public final io.qt.gui.@NonNull QQuaternion panRotation(float angle){
        return panRotation_native_float_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native io.qt.gui.QQuaternion panRotation_native_float_constfct(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::position()const
     * @return
     */
    @QtPropertyReader(name="position")
    @QtUninvokable
    public final io.qt.gui.@NonNull QVector3D position(){
        return position_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QVector3D position_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::projectionMatrix()const
     * @return
     */
    @QtPropertyReader(name="projectionMatrix")
    @QtUninvokable
    public final io.qt.gui.@NonNull QMatrix4x4 projectionMatrix(){
        return projectionMatrix_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QMatrix4x4 projectionMatrix_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::projectionType()const
     * @return
     */
    @QtPropertyReader(name="projectionType")
    @QtUninvokable
    public final io.qt.qt3d.render.QCameraLens.@NonNull ProjectionType projectionType(){
        return io.qt.qt3d.render.QCameraLens.ProjectionType.resolve(projectionType_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int projectionType_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::right()const
     * @return
     */
    @QtPropertyReader(name="right")
    @QtUninvokable
    public final float right(){
        return right_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float right_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::roll(float)
     * @param angle
     */
    public final void roll(float angle){
        roll_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native void roll_native_float(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::rollAboutViewCenter(float)
     * @param angle
     */
    public final void rollAboutViewCenter(float angle){
        rollAboutViewCenter_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native void rollAboutViewCenter_native_float(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::rollRotation(float)const
     * @param angle
     * @return
     */
    public final io.qt.gui.@NonNull QQuaternion rollRotation(float angle){
        return rollRotation_native_float_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native io.qt.gui.QQuaternion rollRotation_native_float_constfct(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::rotate(QQuaternion)
     * @param q
     */
    public final void rotate(io.qt.gui.@NonNull QQuaternion q){
        rotate_native_cref_QQuaternion(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(q));
    }
    
    private native void rotate_native_cref_QQuaternion(long __this__nativeId, long q);
    
    /**
     * See Qt3DRender::QCamera::rotateAboutViewCenter(QQuaternion)
     * @param q
     */
    public final void rotateAboutViewCenter(io.qt.gui.@NonNull QQuaternion q){
        rotateAboutViewCenter_native_cref_QQuaternion(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(q));
    }
    
    private native void rotateAboutViewCenter_native_cref_QQuaternion(long __this__nativeId, long q);
    
    /**
     * See Qt3DRender::QCamera::rotation(float,QVector3D)const
     * @param angle
     * @param axis
     * @return
     */
    public final io.qt.gui.@NonNull QQuaternion rotation(float angle, io.qt.gui.@NonNull QVector3D axis){
        return rotation_native_float_cref_QVector3D_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), angle, QtJambi_LibraryUtilities.internal.checkedNativeId(axis));
    }
    
    private native io.qt.gui.QQuaternion rotation_native_float_cref_QVector3D_constfct(long __this__nativeId, float angle, long axis);
    
    /**
     * See Qt3DRender::QCamera::setAspectRatio(float)
     * @param aspectRatio
     */
    @QtPropertyWriter(name="aspectRatio")
    public final void setAspectRatio(float aspectRatio){
        setAspectRatio_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), aspectRatio);
    }
    
    private native void setAspectRatio_native_float(long __this__nativeId, float aspectRatio);
    
    /**
     * See Qt3DRender::QCamera::setBottom(float)
     * @param bottom
     */
    @QtPropertyWriter(name="bottom")
    public final void setBottom(float bottom){
        setBottom_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), bottom);
    }
    
    private native void setBottom_native_float(long __this__nativeId, float bottom);
    
    /**
     * See Qt3DRender::QCamera::setExposure(float)
     * @param exposure
     */
    @QtPropertyWriter(name="exposure")
    public final void setExposure(float exposure){
        setExposure_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), exposure);
    }
    
    private native void setExposure_native_float(long __this__nativeId, float exposure);
    
    /**
     * See Qt3DRender::QCamera::setFarPlane(float)
     * @param farPlane
     */
    @QtPropertyWriter(name="farPlane")
    public final void setFarPlane(float farPlane){
        setFarPlane_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), farPlane);
    }
    
    private native void setFarPlane_native_float(long __this__nativeId, float farPlane);
    
    /**
     * See Qt3DRender::QCamera::setFieldOfView(float)
     * @param fieldOfView
     */
    @QtPropertyWriter(name="fieldOfView")
    public final void setFieldOfView(float fieldOfView){
        setFieldOfView_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), fieldOfView);
    }
    
    private native void setFieldOfView_native_float(long __this__nativeId, float fieldOfView);
    
    /**
     * See Qt3DRender::QCamera::setLeft(float)
     * @param left
     */
    @QtPropertyWriter(name="left")
    public final void setLeft(float left){
        setLeft_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), left);
    }
    
    private native void setLeft_native_float(long __this__nativeId, float left);
    
    /**
     * See Qt3DRender::QCamera::setNearPlane(float)
     * @param nearPlane
     */
    @QtPropertyWriter(name="nearPlane")
    public final void setNearPlane(float nearPlane){
        setNearPlane_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), nearPlane);
    }
    
    private native void setNearPlane_native_float(long __this__nativeId, float nearPlane);
    
    /**
     * See Qt3DRender::QCamera::setPosition(QVector3D)
     * @param position
     */
    @QtPropertyWriter(name="position")
    public final void setPosition(io.qt.gui.@NonNull QVector3D position){
        setPosition_native_cref_QVector3D(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(position));
    }
    
    private native void setPosition_native_cref_QVector3D(long __this__nativeId, long position);
    
    /**
     * See Qt3DRender::QCamera::setProjectionMatrix(QMatrix4x4)
     * @param projectionMatrix
     */
    @QtPropertyWriter(name="projectionMatrix")
    public final void setProjectionMatrix(io.qt.gui.@NonNull QMatrix4x4 projectionMatrix){
        setProjectionMatrix_native_cref_QMatrix4x4(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(projectionMatrix));
    }
    
    private native void setProjectionMatrix_native_cref_QMatrix4x4(long __this__nativeId, long projectionMatrix);
    
    /**
     * See Qt3DRender::QCamera::setProjectionType(Qt3DRender::QCameraLens::ProjectionType)
     * @param type
     */
    @QtPropertyWriter(name="projectionType")
    public final void setProjectionType(io.qt.qt3d.render.QCameraLens.@NonNull ProjectionType type){
        setProjectionType_native_Qt3DRender_QCameraLens_ProjectionType(QtJambi_LibraryUtilities.internal.nativeId(this), type.value());
    }
    
    private native void setProjectionType_native_Qt3DRender_QCameraLens_ProjectionType(long __this__nativeId, int type);
    
    /**
     * See Qt3DRender::QCamera::setRight(float)
     * @param right
     */
    @QtPropertyWriter(name="right")
    public final void setRight(float right){
        setRight_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), right);
    }
    
    private native void setRight_native_float(long __this__nativeId, float right);
    
    /**
     * See Qt3DRender::QCamera::setTop(float)
     * @param top
     */
    @QtPropertyWriter(name="top")
    public final void setTop(float top){
        setTop_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), top);
    }
    
    private native void setTop_native_float(long __this__nativeId, float top);
    
    /**
     * See Qt3DRender::QCamera::setUpVector(QVector3D)
     * @param upVector
     */
    @QtPropertyWriter(name="upVector")
    public final void setUpVector(io.qt.gui.@NonNull QVector3D upVector){
        setUpVector_native_cref_QVector3D(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(upVector));
    }
    
    private native void setUpVector_native_cref_QVector3D(long __this__nativeId, long upVector);
    
    /**
     * See Qt3DRender::QCamera::setViewCenter(QVector3D)
     * @param viewCenter
     */
    @QtPropertyWriter(name="viewCenter")
    public final void setViewCenter(io.qt.gui.@NonNull QVector3D viewCenter){
        setViewCenter_native_cref_QVector3D(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(viewCenter));
    }
    
    private native void setViewCenter_native_cref_QVector3D(long __this__nativeId, long viewCenter);
    
    /**
     * See Qt3DRender::QCamera::tilt(float)
     * @param angle
     */
    public final void tilt(float angle){
        tilt_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native void tilt_native_float(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::tiltAboutViewCenter(float)
     * @param angle
     */
    public final void tiltAboutViewCenter(float angle){
        tiltAboutViewCenter_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native void tiltAboutViewCenter_native_float(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::tiltRotation(float)const
     * @param angle
     * @return
     */
    public final io.qt.gui.@NonNull QQuaternion tiltRotation(float angle){
        return tiltRotation_native_float_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), angle);
    }
    
    private native io.qt.gui.QQuaternion tiltRotation_native_float_constfct(long __this__nativeId, float angle);
    
    /**
     * See Qt3DRender::QCamera::top()const
     * @return
     */
    @QtPropertyReader(name="top")
    @QtUninvokable
    public final float top(){
        return top_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float top_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::transform()const
     * @return
     */
    @QtPropertyReader(name="transform")
    @QtPropertyConstant
    @SuppressWarnings({"exports"})
    @QtUninvokable
    public final io.qt.qt3d.core.@Nullable QTransform transform(){
        return transform_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.qt3d.core.QTransform transform_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::translate(QVector3D,Qt3DRender::QCamera::CameraTranslationOption)
     * @param vLocal
     * @param option
     */
    public final void translate(io.qt.gui.@NonNull QVector3D vLocal, io.qt.qt3d.render.QCamera.@NonNull CameraTranslationOption option){
        translate_native_cref_QVector3D_Qt3DRender_QCamera_CameraTranslationOption(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(vLocal), option.value());
    }
    
    private native void translate_native_cref_QVector3D_Qt3DRender_QCamera_CameraTranslationOption(long __this__nativeId, long vLocal, int option);
    
    /**
     * See Qt3DRender::QCamera::translateWorld(QVector3D,Qt3DRender::QCamera::CameraTranslationOption)
     * @param vWorld
     * @param option
     */
    public final void translateWorld(io.qt.gui.@NonNull QVector3D vWorld, io.qt.qt3d.render.QCamera.@NonNull CameraTranslationOption option){
        translateWorld_native_cref_QVector3D_Qt3DRender_QCamera_CameraTranslationOption(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(vWorld), option.value());
    }
    
    private native void translateWorld_native_cref_QVector3D_Qt3DRender_QCamera_CameraTranslationOption(long __this__nativeId, long vWorld, int option);
    
    /**
     * See Qt3DRender::QCamera::upVector()const
     * @return
     */
    @QtPropertyReader(name="upVector")
    @QtUninvokable
    public final io.qt.gui.@NonNull QVector3D upVector(){
        return upVector_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QVector3D upVector_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::viewAll()
     */
    public final void viewAll(){
        viewAll_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    private native void viewAll_native(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::viewCenter()const
     * @return
     */
    @QtPropertyReader(name="viewCenter")
    @QtUninvokable
    public final io.qt.gui.@NonNull QVector3D viewCenter(){
        return viewCenter_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QVector3D viewCenter_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::viewEntity(Qt3DCore::QEntity*)
     * @param entity
     */
    @SuppressWarnings({"exports"})
    public final void viewEntity(io.qt.qt3d.core.@Nullable QEntity entity){
        viewEntity_native_Qt3DCore_QEntity_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(entity));
    }
    
    private native void viewEntity_native_Qt3DCore_QEntity_ptr(long __this__nativeId, long entity);
    
    /**
     * See Qt3DRender::QCamera::viewMatrix()const
     * @return
     */
    @QtPropertyReader(name="viewMatrix")
    @QtUninvokable
    public final io.qt.gui.@NonNull QMatrix4x4 viewMatrix(){
        return viewMatrix_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QMatrix4x4 viewMatrix_native_constfct(long __this__nativeId);
    
    /**
     * See Qt3DRender::QCamera::viewSphere(QVector3D,float)
     * @param center
     * @param radius
     */
    public final void viewSphere(io.qt.gui.@NonNull QVector3D center, float radius){
        viewSphere_native_cref_QVector3D_float(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(center), radius);
    }
    
    private native void viewSphere_native_cref_QVector3D_float(long __this__nativeId, long center, float radius);
    
    /**
     * See Qt3DRender::QCamera::viewVector()const
     * @return
     */
    @QtPropertyReader(name="viewVector")
    @QtUninvokable
    public final io.qt.gui.@NonNull QVector3D viewVector(){
        return viewVector_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QVector3D viewVector_native_constfct(long __this__nativeId);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QCamera(QPrivateConstructor p) { super(p); } 
    
    /**
     * Constructor for internal use only.
     * It is not allowed to call the declarative constructor from inside Java.
     * @hidden
     */
    @NativeAccess
    protected QCamera(QDeclarativeConstructor constructor) {
        super((QPrivateConstructor)null);
        initialize_native(this, constructor);
    } 
    
    @QtUninvokable
    private static native void initialize_native(QCamera instance, QDeclarativeConstructor constructor);
    
    
    /**
     * Overloaded constructor for {@link #QCamera(io.qt.qt3d.core.QNode)}
     *  with parent = null.
     */
    public QCamera() {
        this((io.qt.qt3d.core.QNode)null);
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #aspectRatio()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getAspectRatio() {
        return aspectRatio();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #bottom()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getBottom() {
        return bottom();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #exposure()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getExposure() {
        return exposure();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #farPlane()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getFarPlane() {
        return farPlane();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #fieldOfView()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getFieldOfView() {
        return fieldOfView();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #left()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getLeft() {
        return left();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #lens()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.qt3d.render.@Nullable QCameraLens getLens() {
        return lens();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #nearPlane()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getNearPlane() {
        return nearPlane();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #position()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.gui.@NonNull QVector3D getPosition() {
        return position();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #projectionMatrix()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.gui.@NonNull QMatrix4x4 getProjectionMatrix() {
        return projectionMatrix();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #projectionType()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.qt3d.render.QCameraLens.@NonNull ProjectionType getProjectionType() {
        return projectionType();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #right()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getRight() {
        return right();
    }
    
    /**
     * Overloaded function for {@link #setProjectionMatrix(io.qt.gui.QMatrix4x4)}.
     */
    public final void setProjectionMatrix(io.qt.gui.@NonNull QTransform projectionMatrix) {
        setProjectionMatrix(new io.qt.gui.QMatrix4x4(projectionMatrix));
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #top()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getTop() {
        return top();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #transform()} instead.
     */
    @QtPropertyReader(enabled=false)
    @SuppressWarnings({"exports"})
    @QtUninvokable
    public final io.qt.qt3d.core.@Nullable QTransform getTransform() {
        return transform();
    }
    
    /**
     * Overloaded function for {@link #translate(io.qt.gui.QVector3D, io.qt.qt3d.render.QCamera.CameraTranslationOption)}
     *  with option = io.qt.qt3d.render.QCamera.CameraTranslationOption.TranslateViewCenter.
     */
    public final void translate(io.qt.gui.@NonNull QVector3D vLocal) {
        translate(vLocal, io.qt.qt3d.render.QCamera.CameraTranslationOption.TranslateViewCenter);
    }
    
    /**
     * Overloaded function for {@link #translateWorld(io.qt.gui.QVector3D, io.qt.qt3d.render.QCamera.CameraTranslationOption)}
     *  with option = io.qt.qt3d.render.QCamera.CameraTranslationOption.TranslateViewCenter.
     */
    public final void translateWorld(io.qt.gui.@NonNull QVector3D vWorld) {
        translateWorld(vWorld, io.qt.qt3d.render.QCamera.CameraTranslationOption.TranslateViewCenter);
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #upVector()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.gui.@NonNull QVector3D getUpVector() {
        return upVector();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #viewCenter()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.gui.@NonNull QVector3D getViewCenter() {
        return viewCenter();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #viewMatrix()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.gui.@NonNull QMatrix4x4 getViewMatrix() {
        return viewMatrix();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #viewVector()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.gui.@NonNull QVector3D getViewVector() {
        return viewVector();
    }
}