| AxisHelper.qml |
|
2299 |
- |
| capsulegeometry.cpp |
!
\qmltype CapsuleGeometry
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\since 6.10
\brief Provides geometry for a capsule.
A geometry for generating a capsule model. The capsule is centered
at \c{(0, 0, 0)} with the height of the capsule extending in the x
direction and the diameter on the yz plane.
|
22518 |
- |
| capsulegeometry_p.h |
|
5389 |
- |
| CMakeLists.txt |
|
2578 |
- |
| conegeometry.cpp |
|
18761 |
- |
| conegeometry_p.h |
|
3841 |
- |
| cuboidgeometry.cpp |
!
\qmltype CuboidGeometry
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\since 6.9
\brief Provides geometry for a cuboid.
CuboidGeometry is a geometry type that represents a cuboid. The cuboid's size is
defined by its xExtent, yExtent, and zExtent properties. The topology of the plane is defined by
the yzMeshResolution, xzMeshResolution, and xyMeshResolution properties.
|
14047 |
- |
| cuboidgeometry_p.h |
|
4552 |
- |
| cylindergeometry.cpp |
|
15463 |
- |
| cylindergeometry_p.h |
|
3452 |
- |
| DebugView.qml |
|
26903 |
- |
| designer |
|
|
- |
| ExtendedSceneEnvironment.qml |
|
5088 |
- |
| extrudedtextgeometry.cpp |
!
\qmltype ExtrudedTextGeometry
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\since 6.9
\brief Provides geometry for extruded text.
ExtrudedTextGeometry provides geometry for extruded text. The text is extruded along the z-axis.
The text and font can be set, and the depth of the extrusion can be controlled.
The size of the generated geometry is controlled by the scale and depth properties. The topology
of the geometry is defined by the font.pointSize.
The origin of the mesh is the rear left end of the text's baseline.
|
15345 |
- |
| extrudedtextgeometry_p.h |
|
3633 |
- |
| gridgeometry.cpp |
!
\qmltype GridGeometry
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\brief A custom geometry provider for rendering grids.
This helper implements grid geometry, which allows showing a grid in a scene.
For example, the following snippet would display a grid with 19 cells in
both directions in a scene that has one light. Without further
transformations, the grid is facing the camera by default.
\image gridgeometry.jpg
{19 by 19 cell grid facing camera with directional lighting}
\badcode
View3D {
anchors.fill: parent
camera: camera
PerspectiveCamera {
id: camera
position: Qt.vector3d(0, 0, 600)
}
DirectionalLight {
position: Qt.vector3d(-500, 500, -100)
color: Qt.rgba(0.4, 0.2, 0.6, 1.0)
ambientColor: Qt.rgba(0.1, 0.1, 0.1, 1.0)
}
Model {
scale: Qt.vector3d(100, 100, 100)
geometry: GridGeometry {
horizontalLines: 20
verticalLines: 20
}
materials: [ DefaultMaterial { } ]
}
}
\endcode
\sa {Qt Quick 3D - Custom Geometry Example}, Model
|
5849 |
- |
| gridgeometry_p.h |
|
1811 |
- |
| heightfieldgeometry.cpp |
!
\qmltype HeightFieldGeometry
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\since 6.4
\brief A height field geometry.
This helper implements a height-field geometry. It defines a surface built from a grayscale image.
The y-coordinate of the surface at a given point in the horizontal plane is determined by the
pixel value at the corresponding point in the image. The image's x-axis and y-axis will go along
the geometry's x-axis and z-axis respectively.
|
7181 |
- |
| heightfieldgeometry_p.h |
|
1705 |
- |
| impl |
|
|
- |
| infinitegrid.cpp |
!
\qmltype InfiniteGrid
\inqmlmodule QtQuick3D.Helpers
\since 6.5
\brief Shows an infinite grid.
This helper implements an infinite grid in the horizontal plane.
The grid fades out as the grid lines converge or at the far clip distance,
whichever comes first.
The grid needs to be a child of the \l{SceneEnvironment}.
\qml
View3D {
environment: SceneEnvironment {
backgroundMode: SceneEnvironment.SkyBox
lightProbe: Texture {
textureData: ProceduralSkyTextureData{}
}
InfiniteGrid {
gridInterval: 100
}
}
//...
}
\endqml
|
3433 |
- |
| infinitegrid_p.h |
|
1785 |
- |
| instancerepeater.cpp |
!
\qmltype InstanceModel
\inherits Object3D
\inqmlmodule QtQuick3D.Helpers
\since 6.4
\brief Defines a data model based on an instance table.
The InstanceModel QML type is a data model that provides access to the elements of an \l Instancing table.
The following roles are available:
\table
\header
\li Role name
\li Description
\row
\li \c modelPosition
\li The position of the instance as a \l vector3d
\row
\li \c modelRotation
\li The rotation of the instance as a \l quaternion
\row
\li \c modelScale
\li The scale of the instance as a \l vector3d
\row
\li \c modelColor
\li The \l color of the instance
\row
\li \c modelData
\li The custom data of the instance as a \l vector4d
\endtable
\sa InstanceRepeater
|
5242 |
- |
| instancerepeater_p.h |
|
2661 |
- |
| LICENSE.GODOT.txt |
|
1146 |
- |
| LodManager.qml |
|
2621 |
- |
| lookatnode.cpp |
!
\qmltype LookAtNode
\inqmlmodule QtQuick3D.Helpers
\inherits Node
\brief A helper node that is automatically kept pointing at another node.
\since 6.4
This helper implements a node that automatically rotates so that it is always
pointed towards a specified node. The rotation only happens over X and Y axes.
For example, the following snippet keeps the cylinder pointed at the cube.
\badcode
View3D {
anchors.fill: parent
camera: camera
PerspectiveCamera {
id: camera
}
DirectionalLight {}
LookAtNode {
target: cube
Model {
id: cylinder
source: "#Cone"
eulerRotation.x: -90
materials: [
PrincipledMaterial {}
]
}
}
Model {
id: cube
position: Qt.vector3d(300, 300, 0);
source: "#Cube"
materials: [ PrincipledMaterial {} ]
}
}
\endcode
|
3110 |
- |
| lookatnode_p.h |
|
1105 |
- |
| meshes |
|
|
- |
| OrbitCameraController.qml |
|
7657 |
- |
| planegeometry.cpp |
!
\qmltype PlaneGeometry
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\since 6.9
\brief Provides geometry for a plane.
PlaneGeometry is a geometry type that represents a plane. The plane's size is
defined by its height and width properties. The topology of the plane is defined by
the meshResolution property. The orientation of the plane is defined by the plane property.
|
13151 |
- |
| planegeometry_p.h |
|
4281 |
- |
| proceduralmesh.cpp |
!
\qmltype ProceduralMesh
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\brief Allows creation of Geometry from QML.
\since 6.6
ProceduralMesh is a helper type that allows creation of Geometry instances
from QML. The Geometry component is Abstract, and is usually created
from C++.
\qml
component TorusMesh : ProceduralMesh {
property real rings: 50
property real segments: 50
property real radius: 100.0
property real tubeRadius: 10.0
property var meshArrays: generateTorus(rings, segments, radius, tubeRadius)
positions: meshArrays.verts
normals: meshArrays.normals
uv0s: meshArrays.uvs
indexes: meshArrays.indices
function generateTorus(rings: real, segments: real, radius: real, tubeRadius: real) {
let verts = []
let normals = []
let uvs = []
let indices = []
for (let i = 0; i <= rings; ++i) {
for (let j = 0; j <= segments; ++j) {
let u = i / rings * Math.PI * 2;
let v = j / segments * Math.PI * 2;
let centerX = radius * Math.cos(u);
let centerZ = radius * Math.sin(u);
let posX = centerX + tubeRadius * Math.cos(v) * Math.cos(u);
let posY = tubeRadius * Math.sin(v);
let posZ = centerZ + tubeRadius * Math.cos(v) * Math.sin(u);
verts.push(Qt.vector3d(posX, posY, posZ));
let normal = Qt.vector3d(posX - centerX, posY, posZ - centerZ).normalized();
normals.push(normal);
uvs.push(Qt.vector2d(i / rings, j / segments));
}
}
for (let i = 0; i < rings; ++i) {
for (let j = 0; j < segments; ++j) {
let a = (segments + 1) * i + j;
let b = (segments + 1) * (i + 1) + j;
let c = (segments + 1) * (i + 1) + j + 1;
let d = (segments + 1) * i + j + 1;
// Generate two triangles for each quad in the mesh
// Adjust order to be counter-clockwise
indices.push(a, d, b);
indices.push(b, d, c);
}
}
return { verts: verts, normals: normals, uvs: uvs, indices: indices }
}
}
\endqml
The above code defines a component TorusMesh that can be used as Geometry for use
with a Model component. When the ring, segments, radius or tubeRadius properties
are modified the geometry will be updated.
The ProceduralMesh component is not as flexible nor as performant as creating
Geometry in C++, but makes up for it in convenience and simplicity. The
properties are fixed attribute lists that when filled will automatically
generate the necessary buffers.
|
21862 |
- |
| proceduralmesh_p.h |
|
5457 |
- |
| proceduralsky.frag |
|
1718 |
- |
| ProceduralSkyMaterial.qml |
|
5547 |
- |
| proceduralskytexturedata.cpp |
Based on "sky.cpp" from the Godot engine v3
Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.
Copyright (c) 2014-2022 Godot Engine contributors.
|
18064 |
- |
| proceduralskytexturedata_p.h |
|
6156 |
- |
| qquick3dquadtextureprovider.cpp |
!
\qmltype QuadTextureProvider
\nativetype QQuick3DQuadTextureProvider
\inqmlmodule QtQuick3D.Helpers
\inherits TextureProviderExtension
\since 6.12
\brief Used to render a quad texture using a custom fragment shader.
This type is used to render quad textures using custom shader code, enabling a convenient way
to get programmable textures. By providing a fragment shader and wanted properties, a pass is created
and a shader pipeline is built based on the provided data, passing the properties in as uniform values
to the fragment shader.
Built-ins provided:
\table
\header
\li Keyword
\li Type
\li Description
\row
\li MAIN
\li
\li void MAIN() is the entry point. This function must always be present in the fragment shader provided.
\row
\li INPUT_UV
\li vec2
\li UV coordinates for current fragment. Top-right: [1, 1] and bottom-left: [0, 0].
\row
\li OUTPUT_SIZE
\li vec2
\li Size of the output texture.
\row
\endtable
Custom properties gets mapped to uniforms. Any time the values change, the updated
value will become visible in the shader. This concept may already be familiar from \l ShaderEffect.
The name of the QML property and the GLSL variable must match. There is no separate
declaration in the shader code for the individual uniforms. Rather, the QML property name
can be used as-is.
The following table lists how the types are mapped:
\table
\header
\li QML Type
\li Shader Type
\li Notes
\row
\li real, int, bool
\li float, int, bool
\li
\row
\li color
\li vec4
\li sRGB to linear conversion is performed implicitly
\row
\li vector2d
\li vec2
\li
\row
\li vector3d
\li vec3
\li
\row
\li vector4d
\li vec4
\li
\row
\li matrix4x4
\li mat4
\li
\row
\li quaternion
\li vec4
\li scalar value is \c w
\row
\li rect
\li vec4
\li
\row
\li point, size
\li vec2
\li
\row
\li TextureInput
\li sampler2D
\li
\endtable
An example of outputting a simple red texture could be done the following way:
\badcode
Texture {
textureProvider: QuadTextureProvider {
width: 128
height: 128
fragmentShaderCode: `
void MAIN() {
FRAGCOLOR = vec4(1.0, 0.0, 0.0, 1.0);
}
`
}
}
\endcode
Another example sampling from a \l Texture property and mixing with UV colors:
\badcode
Texture {
textureProvider: QuadTextureProvider {
fragmentShaderCode: `
void MAIN() {
vec2 uv = INPUT_UV;
vec4 c = texture(checkers, uv);
FRAGCOLOR = mix(c, vec4(uv, 1, 1), 0.5);
}`
property Texture checkers : Texture {
source: "../shared/maps/checkers2.png"
}
}
}
\endcode
The result is the following:
\image quadtextureprovider_checkers.webp
{2x2 grid of gradient-filled cells in teal, white, blue, and
magenta}
\note Providing a vertex shader is not supported, only a fragment shader.
\note If \l Texture properties are provided it will not render until the dependent textures are available.
\note There is currently no support for adding / removing properties at runtime, just modifying the original ones.
\sa ShaderEffect
|
29157 |
- |
| qquick3dquadtextureprovider_p.h |
|
3100 |
- |
| qquick3drenderoutputprovider.cpp |
|
12243 |
- |
| qquick3drenderoutputprovider_p.h |
|
2936 |
- |
| qquick3dsimplequadrenderpass.cpp |
!
\qmltype SimpleQuadRenderer
\nativetype QQuick3DSimpleQuadRenderer
\inqmlmodule QtQuick3D.Helpers
\inherits RenderExtension
\since 6.11
\brief Renders a full-screen textured quad to the main render target.
SimpleQuadRenderer is a \l RenderExtension that blits a \l Texture across
the entire screen. It runs at the \c PostColor stage in the \c Main render
mode, which means it executes after the scene has been drawn but before any
post-processing effects, and it writes directly into the \l View3D's main
render target, overwriting whatever was drawn by the scene.
The most common use case is building a fully custom rendering pipeline:
set \l {View3D::renderFormat}{View3D.renderFormat} to disable Qt Quick 3D's
built-in passes with \c {View3D.DisableInternalPasses}, render the scene
content into one or more \l RenderPass targets, and then use
SimpleQuadRenderer to composite the result back onto the screen.
\note SimpleQuadRenderer is automatically registered as an extension with the
scene — it does not need to be added to \l {View3D::extensions}{View3D.extensions}
manually.
\qml
import QtQuick3D
import QtQuick3D.Helpers
View3D {
// Disable the built-in render passes so we can provide our own output
renderFormat: View3D.DisableInternalPasses
// A custom offscreen pass that renders scene content
RenderPass {
id: mainColorPass
commands: [
RenderablesFilter { renderableTypes: RenderablesFilter.Opaque | RenderablesFilter.Transparent }
]
}
// Blit the result of the custom pass to the screen
SimpleQuadRenderer {
texture: Texture {
textureProvider: RenderOutputProvider {
renderPass: mainColorPass
}
}
}
}
\endqml
\sa RenderOutputProvider, RenderPass, View3D
|
9010 |
- |
| qquick3dsimplequadrenderpass_p.h |
|
1366 |
- |
| qquick3dtexturedatafrontend.cpp |
!
\qmltype ProceduralTextureData
\inqmlmodule QtQuick3D.Helpers
\inherits TextureData
\brief Allows creation and population of TextureData from QML.
\since 6.6
ProceduralTextureData is a helper type that allows creation of TextureData from QML.
The TextureData component is Abstract, and is usually created from C++. With
ProceduralTextureData, it is possible to populate a TextureData from QML.
\qml
ProceduralTextureData {
id: dynamicTextureData
property color color1: "red"
property color color2: "black"
width: 32
height: 32
hasTransparency: false
format: TextureData.RGBA8
textureData: generateTextureData(color1, color2)
function generateTextureData(newColor1: color, newColor2 : color) : ArrayBuffer {
let dataBuffer = new ArrayBuffer(width * height * 4)
let data = new Uint8Array(dataBuffer)
// Create a checkered pattern using newColor1 and newColor2
for (let x = 0; x < width; x++) {
for (let y = 0; y < height; y++) {
let index = (x + y * width) * 4
let color = (x % 2 === y % 2) ? newColor1 : newColor2
data[index + 0] = color.r * 255
data[index + 1] = color.g * 255
data[index + 2] = color.b * 255
data[index + 3] = 255
}
}
return dataBuffer
}
}
\endqml
In the above code snippet, the function generateTextureData is used to generate a
checkerboard pattern using the two colors color1 and color2. By filling an
ArrayBuffer with the generated data, the textureData property of the TextureData
is populated.
|
9640 |
- |
| qquick3dtexturedatafrontend_p.h |
|
2131 |
- |
| qt_attribution.json |
|
636 |
- |
| qtquick3dhelpersglobal_p.h |
|
709 |
- |
| randominstancing.cpp |
!
\qmltype InstanceRange
\inherits Object3D
\inqmlmodule QtQuick3D.Helpers
\since 6.2
\brief Specifies a range for RandomInstancing.
The InstanceRange QML type is used to specify the range of variation for
RandomInstancing attributes.
|
19515 |
- |
| randominstancing_p.h |
|
5110 |
- |
| REUSE.toml |
|
126 |
- |
| spheregeometry.cpp |
!
\qmltype SphereGeometry
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\since 6.9
\brief Provides geometry for a sphere.
SphereGeometry is a geometry type that represents a sphere. The sphere's size is
defined by its radius. The topology of the sphere is defined by the number of
rings and segments.
|
9742 |
- |
| spheregeometry_p.h |
|
3118 |
- |
| torusgeometry.cpp |
!
\qmltype TorusGeometry
\inqmlmodule QtQuick3D.Helpers
\inherits Geometry
\since 6.9
\brief Provides geometry for a torus.
TorusGeometry is a geometry type that represents a torus. The torus is defined by the number of
rings and segments, and the radius of the torus.
|
10915 |
- |
| torusgeometry_p.h |
|
3479 |
- |
| WasdController.qml |
|
8449 |
- |