Render3DPlugin

Create the global 3D renderer, call in gameInit

Additive blending instead of alpha, in the transparent stage

Ambient light color, from above when ambientGroundColor is set

Ambient light from below: set, the ambient blends from this on faces pointing down to ambientColor on faces pointing up, the way a sky and a ground light a scene; setSky sets both from its colors

Anisotropic filtering for textures seen at an angle, 1 to 16, 1 is off; needs mipmaps

A square of size 1 facing +Z with the tile across it, the corners in the order drawBillboard writes them; a ParticleEmitter3D draws its particles as instances of it, each with its own matrix

Blending on, set by the stages

A box of size 1 that drawBox uses, for any object that is a box; set the object's scale3D and color instead of editing the mesh, which would change every box that uses it

The camera

Camera forward axis this frame

Camera right axis this frame

Camera up axis this frame

Skip back faces, set by drawMesh from each mesh: off for strips so they show from both sides

Test against the depth buffer, reset to true before each object and callback; a draw with it off goes over what was drawn before it and under what is drawn after, by render order, which ends the batch of meshes before it, so one per object costs a draw per object

Draw the camera's depth into a texture each frame for post processing: PostProcessPlugin hands it to its shader as iChannel2, read with sceneDepth(uv); off by default and free when off, on it draws the solid objects of the default layer once more, depth only

Write to the depth buffer, owned by the stages: on for opaque, off for transparent

How much a surface lights itself, set per object by its emissive

Emissive map for the next draws, set from each object's emissiveMap

Multiplies the emissive map, set from each object's emissiveMapColor; compared by its rgb, so a Color changed in place is seen when it is set again, and undefined is white

The world around, what reflective surfaces reflect: an object's reflectivity says how much and its shininess how sharp, the same shininess that tightens its highlight: 10000 a mirror, 1000 polished, 10 a wide blur; undefined reflects the sky's colors as setSky gave them; a cube map holds GPU memory until its dispose(), so one made again and again, as for a sky that changes, disposes the one it replaces, or a captured one is captured into again

The cube map the next draws reflect in place of render3D.environment, set from each object's environment

Fog color, uses canvasClearColor when undefined

Measure fog by depth along the view instead of distance from the camera, so fog is even across the screen like a classic depth fog; the fade below is measured the same way

Distance from the camera where fog is total, 0 disables fog

Where see through draws are fully transparent, 0 turns the fade off; distant things melt into a sky or backdrop drawn behind them instead of into the fog color

Where see through draws start to fade to transparent, measured like the fog

Distance from the camera where fog starts

Skip meshes whose bounding sphere is outside the view

Added to the velocity3D of every object with a mass each frame, scaled by its gravityScale; sync2D objects use the 2D gravity

Draw every use of a mesh in the opaque stage as one instanced call, mesh.instanced overrides it per mesh

True while the 3D pass is running, 3D draws are only valid then

Apply lighting, when false draws plain vertex color times texture and casts no shadow; off for billboards, lines, ribbons and soft discs, an object sets emissive instead

Sample textures through mipmaps so they do not shimmer in the distance, false uses each texture's own filtering like 2D

The transform mirrors the draw, so the other winding is the front, set by drawMesh from each transform

Normal map for the next draws, set from each object's normalMap

How strongly the normal map bends the surface, set from each object's normalScale

Draw solid world here, it runs again for shadows so only draw in it

Draw see through things here, like glows, billboards and soft shadows

Keep texture pixels hard edged, no mipmaps and no blending between them, set per object by pixelated

A flat square of size 1 facing +Y, seen from above only, for floors, water and decals; stand it up with the object's rotation3D, and size it with scale3D

The same square seen and lit from both sides, for signs, cards and leaves

This frame's projection matrix

Darken by the shadow map when shadows are on, turn it off for things that should stay lit inside a shadow

How much the surface reflects the sky, 0 to 1, set from each object's reflectivity

Draw the 3D scene on top of the 2D scene instead of under it

Light the next billboards as if they bulge toward the camera like a ball, lit on the side toward each light, in place of the same all over; set from each object's roundLighting, a normal map overrides it

Custom Shader for the next draws, set from each object's shader; undefined draws with the plugin's own

Stops surfaces shadowing themselves, raise for speckles, lower if shadows drift off; a share of the shadow map's depth, twice shadowRange for the sun and a spotlight's radius, so the gap behind a caster grows with the range as the map's texels do, and the speckles they make stay away

Center of the shadowed area, read each frame, undefined follows the camera

A spotlight, a Light3D with a coneAngle, to cast the shadows in place of the sun, a flashlight in the dark: the shadow map looks down its cone, as far as its radius, and the sun still lights the scene but casts none; undefined for the sun, as is a light that is off or has no cone

Size of the shadow map in pixels, bigger is sharper and slower

This frame's light view projection for the shadow map

True while the shadow map is being drawn, draws go to the depth only shader

World size the shadow map covers around shadowCenter, smaller is sharper; it is a square facing the light, so it turns as the light does, and about 1.5 times an area's width covers it from any angle

Cast real shadows from the sun, off by default and free when off

How much to blur the shadow edges

The highlight's exponent, how small and sharp it is: 4 is broad like rubber, 100 sharp like polished metal; set from each object's shininess

Sky dome from buildSky or setSky, drawn around the camera behind everything

A cube map drawn as the sky, behind everything, in place of the sky dome; an orthographic camera looks the same way through every pixel, so it sees one color of it; fog fades to fogColor, not to the sky box, so with fog set fogColor to its horizon's color

Default for every builder's smooth argument: true for smooth vertex normals, false for flat faces

Floor for objects with a softShadow: a height, a HeightMap, or (x, z) => y

Draw see through things far to near so they blend correctly

How far a sound played with playSound is heard when it was made with no range of its own, in world units; further than the 2D soundDefaultRange, a 3D world is bigger

Strength of the highlight where the sun and the Light3D objects reflect, 0 is none and 1 adds a light's full color at its brightest; shininess sets its size

A smooth sphere of diameter 1 that drawSphere uses, shared the same way as boxMesh

Goes up when a draw state field changes, so a batch sees at a glance that none did

Sunlight color

Direction toward the sun, where its light comes from, like a directional Light3D; read at each draw, and any length will do, the shading and the shadows normalize it themselves; the sun is the one light that casts shadows

This frame's view matrix

This frame's combined view projection

Build a mesh once out of draw calls, instead of redrawing the shapes every frame

• Call the same drawStrip, drawQuad and drawBox calls inside, and get a mesh back
• Strips inside a bake ignore their tileInfo, the finished mesh picks the texture when it draws
• drawMesh, drawBox and drawSphere copy their mesh in, moved and tinted, their tileInfo dropped too
• The mesh skips its back faces like any, set doubleSided when what was drawn is open

Draw a flat square that always faces the camera

• Lit with no direction, since it always faces the camera: each light by how near it is, the sun where its light reaches, the ambient and the shadows, the same from any side, so a cloud is brighter by a light in it; with roundLighting it is lit as a ball, bright on the side toward each light, and with a normal map as a card facing the camera; no specular or reflection
• An additive one is light of its own and stays unlit, and emissive 1 keeps its own colors
• Draw it from onRenderTransparent or a transparent object so it can fade

Draw a box, untextured, for blocking out a scene without meshes or objects

Draw a line as a camera facing ribbon, unlit

Draw a mesh with the current draw state, batched with its other uses in the opaque stage when instancing is on

Draw a quad from four corners in loop order, counter clockwise seen from the front, a is the top left of the texture

Draw a ribbon along a path, unlit and visible from both sides; width and color can change along it

• The texture runs along the length, u from the first point to the last
• A path that ends where it starts is a loop, and joins with no seam

Draw render3D.skyBox, or render3D.sky around the camera, unlit, unfogged and behind everything, called automatically by the pass

Draw a disc that fades to transparent at the rim, unlit, for glows, puffs and sky dots

Draw a soft round shadow on the ground under something, much cheaper than a real shadow

• Draw it from onRenderTransparent or from a transparent object

Draw a sphere, untextured and smooth shaded

Draw a triangle strip, batched into the stream with the current draw state

• Strip order: the first three points make a triangle, then each point makes another with the two before it
• List the first three points counter clockwise as seen from the front, or the face points away and may vanish when back faces are culled
• inside a bake the strip goes into the mesh instead, in the transparent stage it is queued for sorting and the arrays are read when the queue replays, so leave them unchanged until the stage ends

Draw a strip with lighting off, for camera facing shapes where the light direction means nothing

Draw a triangle, counter clockwise from outside is the front

Draw the pending stream vertices as one strip with the state they were drawn under, called automatically when needed

Draw the queued transparent draws far to near with the state each was drawn under, called automatically at the end of the transparent stage

Is any part of a sphere on screen this frame, the test that skips meshes the camera cannot see

• While the shadow map is drawing it tests the shadow area instead

Find the nearest object under a screen position or along a ray, for clicking on things

• A mesh is hit on its triangles, the ones that face the ray as they are drawn, both sides of a doubleSided mesh; a sprite is hit as the quad it draws, and a height map, voxel map or mesh collider on its surface
• engineObjectsRaycast3D is the other half of this, every object along a ray instead of the nearest

Play a sound at a 3D position, quieter with distance from the camera and panned by its side, like Sound.play with a 2D position; a sound made with no range of its own is heard to soundDefaultRange, 100, and one given a range keeps it

Play a sound on a loop at a 3D position, the same as playSound with loop on

• Its volume and pan are set when it starts, change or stop it through the SoundInstance returned

Queue a draw for the transparent stage, replayed far to near with the current draw state, or draw it now when sorting is off

• The draw runs later, so it should hold copies of any values the caller may change before then

Draw a layer's objects, solid ones first and see through ones after, called automatically

• The main layer also draws the sky, the render callbacks and the debug shapes

Where a screen position lands on a flat ground plane, for top down games; use HeightMap.raycast for terrain

Get the world ray under a screen position, for clicking on things in 3D

• Uses the camera where it is right now, so it is fine to call from gameUpdate
• It brings the view matrices up to date for that canvas, so worldToScreen stays its exact opposite

Set where fog starts and ends, and its color

Build a sky dome, set it as the sky, and light the scene by it: the fog takes the horizon color, and the ambient light comes from the top color above and the bottom color below, both at the ambient strength

Rebuild the view and projection matrices from the camera, called automatically each frame

Rebuild the light's view projection around the shadow center, called automatically each frame shadows are on

Where a world point lands on screen as -1 to 1 across and up, with z as depth

• Uses this frame's camera, call updateMatrices first if the camera just moved

Project a world point to screen space pixels, same space as mousePosScreen

• The opposite of screenToRay, and it takes the same canvas so the pair agree