orx-dnk3/org.openrndr.extra.dnk3

Package-level declarations

Types

AmbientLight

class AmbientLight : Light

AmbientOcclusionFacet

class AmbientOcclusionFacet : ColorBufferFacetCombiner

AttenuatedLight

interface AttenuatedLight

BaseColorFacet

class BaseColorFacet : ColorBufferFacetCombiner

Camera

abstract class Camera : Entity

ClipDepthFacet

class ClipDepthFacet : ColorBufferFacetCombiner

ClipPositionFacet

class ClipPositionFacet : ColorBufferFacetCombiner

ColorBufferFacetCombiner

abstract class ColorBufferFacetCombiner(facets: Set<FacetType>, targetOutput: String, val format: ColorFormat, val type: ColorType, val blendMode: BlendMode = BlendMode.BLEND) : FacetCombiner

ContextKey

@JvmRecord

data class ContextKey(val materialContext: MaterialContext, val primitiveContext: PrimitiveContext) : Record

CubemapProbe

abstract class CubemapProbe : Entity

CubemapReflection

data class CubemapReflection(var cubemap: Cubemap? = null)

DiffuseFacet

class DiffuseFacet : ColorBufferFacetCombiner

DiffuseIrradianceFacet

class DiffuseIrradianceFacet : ColorBufferFacetCombiner

DiffuseSpecularAlphaFacet

class DiffuseSpecularAlphaFacet : ColorBufferFacetCombiner

DiffuseSpecularFacet

class DiffuseSpecularFacet : ColorBufferFacetCombiner

DirectionalLight

class DirectionalLight(var direction: Vector3 = -Vector3.UNIT_Z, var shadows: Shadows = Shadows.None) : Light, ShadowLight

DummyMaterial

class DummyMaterial : Material

DummySource

object DummySource : TextureSource

EmissiveAlphaFacet

class EmissiveAlphaFacet : ColorBufferFacetCombiner

EmissiveFacet

class EmissiveFacet : ColorBufferFacetCombiner

Entity

sealed class Entity

FacetCombiner

abstract class FacetCombiner(val facets: Set<FacetType>, val targetOutput: String)

FacetType

enum FacetType : Enum<FacetType>

Feature

interface Feature

FilterPostStep

class FilterPostStep<T : Filter>(val outputScale: Double, val filter: T, val inputs: List<String>, val output: String, val outputFormat: ColorFormat, val outputType: ColorType, val update: T.(PostContext) -> Unit? = null) : PostStep

FilterPostStepBuilder

class FilterPostStepBuilder<T : Filter>(val filter: T)

Fog

data class Fog(var color: ColorRGBa = ColorRGBa.WHITE, var end: Double = 100.0) : Entity

FragmentIDFacet

class FragmentIDFacet : ColorBufferFacetCombiner

FunctionPostStep

class FunctionPostStep(val function: (MutableMap<String, ColorBuffer>) -> Unit) : PostStep

Geometry

class Geometry(val vertexBuffers: List<VertexBuffer>, val indexBuffer: IndexBuffer?, val primitive: DrawPrimitive, val offset: Int, val vertexCount: Int)

HDRColorFacet

class HDRColorFacet : ColorBufferFacetCombiner

HemisphereLight

class HemisphereLight(var direction: Vector3 = Vector3.UNIT_Y, var upColor: ColorRGBa = ColorRGBa.WHITE, var downColor: ColorRGBa = ColorRGBa.BLACK) : Light

InstancedMesh

class InstancedMesh(primitives: List<MeshPrimitive>, var instances: Int, var attributes: List<VertexBuffer>) : MeshBase

IrradianceProbe

class IrradianceProbe : CubemapProbe

LDRColorFacet

class LDRColorFacet : ColorBufferFacetCombiner

Light

abstract class Light : Entity

LightContext

@JvmRecord

data class LightContext(val lights: List<NodeContent<Light>>, val shadowMaps: Map<ShadowLight, RenderTarget>) : Record

Material

interface Material

MaterialContext

data class MaterialContext(val pass: RenderPass, val lights: List<NodeContent<Light>>, val fogs: List<NodeContent<Fog>>, val shadowMaps: Map<ShadowLight, RenderTarget>, val meshCubemaps: Map<Mesh, Cubemap>, val irradianceProbeCount: Int)

MaterialFacet

class MaterialFacet : ColorBufferFacetCombiner

Mesh

class Mesh(primitives: List<MeshPrimitive>) : MeshBase

MeshBase

abstract class MeshBase(var primitives: List<MeshPrimitive>) : Entity

MeshPrimitive

class MeshPrimitive(var geometry: Geometry, var material: Material)

MeshPrimitiveInstance

class MeshPrimitiveInstance(val primitive: MeshPrimitive, val instances: Int, val attributes: List<VertexBuffer>)

ModelCoordinates

class ModelCoordinates(texture: ColorBuffer, var input: String = "va_texCoord0.xy", var tangentInput: String? = null, textureFunction: TextureFunction = TextureFunction.TILING, var pre: String? = null, var post: String? = null) : TextureFromColorBuffer

MomentsFacet

class MomentsFacet : ColorBufferFacetCombiner

NodeContent

class NodeContent<T>(val node: SceneNode, val content: T)

NormalFacet

class NormalFacet : ColorBufferFacetCombiner

OrthographicCamera

class OrthographicCamera(var node: SceneNode) : Camera

PathMesh

class PathMesh(var paths: MutableList<Path3D>, var material: Material, var weight: Double) : Entity

PBRMaterial

class PBRMaterial : Material

PerspectiveCamera

class PerspectiveCamera(var node: SceneNode) : Camera

PointLight

class PointLight(var constantAttenuation: Double = 1.0, var linearAttenuation: Double = 0.0, var quadraticAttenuation: Double = 1.0) : Light

PositionFacet

class PositionFacet : ColorBufferFacetCombiner

PostContext

@JvmRecord

data class PostContext(val lightContext: LightContext, val inverseViewMatrix: Matrix44) : Record

PostStep

interface PostStep

PrimitiveContext

@JvmRecord

data class PrimitiveContext(val hasNormalAttribute: Boolean, val hasSkinning: Boolean) : Record

RenderContext

class RenderContext(val lights: List<NodeContent<Light>>, val meshes: List<NodeContent<Mesh>>, val skinnedMeshes: List<NodeContent<SkinnedMesh>>, val instancedMeshes: List<NodeContent<InstancedMesh>>, val pathMeshes: List<NodeContent<PathMesh>>, val fogs: List<NodeContent<Fog>>)

RenderPass

@JvmRecord

data class RenderPass(val combiners: List<FacetCombiner>, val renderOpaque: Boolean = true, val renderTransparent: Boolean = false, val depthWrite: Boolean = true, val multisample: BufferMultisample = BufferMultisample.Disabled, val skipTarget: Boolean = false) : Record

Scene

class Scene(val root: SceneNode = SceneNode(), val dispatcher: Dispatcher = Dispatcher())

SceneNode

open class SceneNode

SceneRenderer

class SceneRenderer

ShadowLight

interface ShadowLight

Shadows

sealed class Shadows

SkinnedMesh

class SkinnedMesh(primitives: List<MeshPrimitive>, val joints: List<SceneNode>, val skeleton: SceneNode, val inverseBindMatrices: List<Matrix44>) : MeshBase

SpecularFacet

class SpecularFacet : ColorBufferFacetCombiner

SpotLight

class SpotLight(var direction: Vector3 = -Vector3.UNIT_Z, var innerAngle: Double = 45.0, var outerAngle: Double = 90.0) : Light, ShadowLight, AttenuatedLight

SubsurfaceScatter

data class SubsurfaceScatter(var enabled: Boolean)

Texture

class Texture(var source: TextureSource, var target: TextureTarget)

TextureFromCode

class TextureFromCode(val code: String) : TextureSource

TextureFromColorBuffer

abstract class TextureFromColorBuffer(var texture: ColorBuffer, var textureFunction: TextureFunction) : TextureSource

TextureFunction

enum TextureFunction : Enum<TextureFunction>

TextureSource

sealed class TextureSource

TextureTarget

sealed class TextureTarget

Triplanar

class Triplanar(texture: ColorBuffer, var scale: Double = 1.0, var offset: Vector3 = Vector3.ZERO, var sharpness: Double = 2.0, textureFunction: TextureFunction = TextureFunction.TILING, var pre: String? = null, var post: String? = null) : TextureFromColorBuffer

ViewDepthFacet

class ViewDepthFacet : ColorBufferFacetCombiner

ViewNormalFacet

class ViewNormalFacet : ColorBufferFacetCombiner

ViewPositionFacet

class ViewPositionFacet : ColorBufferFacetCombiner

Properties

DefaultOpaquePass

val DefaultOpaquePass: RenderPass

DefaultPass

val DefaultPass: RenderPass

DefaultTransparentPass

val DefaultTransparentPass: RenderPass

DummyGeometry

val DummyGeometry: Geometry

IrradianceProbePass

val IrradianceProbePass: RenderPass

LightPass

val LightPass: RenderPass

shaderGGX

val shaderGGX: String

shaderLinePlaneIntersect

val shaderLinePlaneIntersect: String

shaderNoRepetition

val shaderNoRepetition: String

shaderNoRepetitionVert

val shaderNoRepetitionVert: String

shaderProjectOnPlane

val shaderProjectOnPlane: String

shaderSideOfPlane

val shaderSideOfPlane: String

shaderVSM

val shaderVSM: String

VSMLightPass

val VSMLightPass: RenderPass

worldPosition

val SceneNode.worldPosition: Vector3

Functions

createPassTarget

fun RenderPass.createPassTarget(width: Int, height: Int, depthFormat: DepthFormat = DepthFormat.DEPTH24, multisample: BufferMultisample = this.multisample): RenderTarget

findContent

fun <P : Entity> SceneNode.findContent(selector: Entity.() -> P?): List<NodeContent<P>>

findNodes

fun SceneNode.findNodes(selector: SceneNode.() -> Boolean): List<SceneNode>

fun Shadows.fs(index: Int): String

fun Shadows.PCF.fs(index: Int): String

fun Shadows.Simple.fs(index: Int): String

fun Shadows.VSM.fs(index: Int): String

postStep

fun postStep(function: (MutableMap<String, ColorBuffer>) -> Unit): PostStep

fun <T : Filter> postStep(filter: T, configure: FilterPostStepBuilder<T>.() -> Unit): PostStep

scan

fun <P> SceneNode.scan(initial: P, scanner: SceneNode.(P) -> P)

sceneRenderer

fun sceneRenderer(builder: SceneRenderer.() -> Unit): SceneRenderer

visit

fun SceneNode.visit(visitor: SceneNode.() -> Unit)