Functions
init-cloud-vert-array() => symbolsource
init-haze-vert-array() => symbolsource
sky-make-moon-data(arg0: sky-work, arg1: float) => nonesource
Initialize `upload-data` with sky-moon-data in *sky-work*
sky-make-sun-data(arg0: sky-work, arg1: int, arg2: float) => nonesource
Initialize `upload-data` with sky-sun-data in *sky-work*
Variables
*cloud-poly*: inline-arraysource
*haze-poly*: inline-arraysource
sky-base-polygons: inline-arraysource
const sky-roof-polygons: inline-arraysource
Types
cloud-lights: structuresource
cloud-vert-array: structuresource
Fields
data: cloud-vertex
cloud-vertex: structuresource
haze-lights: structuresource
haze-vert-array: structuresource
Fields
data: haze-vertex
sky-color-day: structuresource
Fields
hour: sky-color-hour
sky-color-hour: structuresource
sky-orbit: structuresource
sky-sun-data: structuresource
sky-upload-data: structuresource
sky-work: structuresource
Fields
adgif-tmpl: dma-gif-packet
draw-tmpl: dma-gif-packet
draw-tmpl2: dma-gif-packet
fog-tmpl: dma-gif-packet
blend-tmpl: dma-gif-packet
sprite-tmpl: dma-gif-packet
sprite-tmpl2: dma-gif-packet
sun-coords: vector
green-coords: vector
moon0-coords: vector
moon1-coords: vector
moon2-coords: vector
star-coords: vector
sun-colors: vector4w
green-colors: vector4w
moon-colors: vector4w
star-colors: vector4w
st-coords: vector
random: vector4w
giftag-base: dma-gif
giftag-haze: dma-gif
giftag-roof: dma-gif
giftag-ocean: dma-gif
fog: vector
sky: float
time: float
off-s: uint16
off-t: uint16
orbit: sky-orbit
upload-data: sky-upload-data
ambi-color: vector4w
ambi-color-lower: vector4w
sun0-color: vector4w
sun1-color: vector4w
moon-color: vector4w
sun0-color-lower: vector4w
cam-mat: matrix
star-mat: matrix
vec0: vector4w
vec1: vector4w
cloud-lights: cloud-lights
haze-lights: haze-lights
buf: dma-buffer
draw-vortex: basic
stars: vector
Methods
init-sun-data!(obj: sky-work, arg0: int, arg1: float, arg2: float, arg3: float) => nonesource
Sets the sun related upload data - the sun, halo and aurora
init-orbit-settings!(obj: sky-work, arg0: int, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float) => nonesource
update-colors-for-time(obj: sky-work, arg0: float) => nonesource
Update sky colors for the given time.
update-time-and-speed(obj: sky-work, arg0: float, arg1: float) => nonesource
Update based on the given time. Time is used to place suns/moon at the right spot, speed is used to scroll clouds.
update-matrix(obj: sky-work, arg0: matrix) => nonesource
Update the projection matrix for sky drawing.
The input matrix should not include perepctive.
This function will apply the current math camera's perspective.
The input matrix should not include perepctive.
This function will apply the current math camera's perspective.
update-template-colors(obj: sky-work) => nonesource
Update skybox colors from level/mood.
init-regs-for-large-polygon-draw: unknown
init-regs-for-sky-asm: unknown
cloud-vtx-light-update(obj: sky-work, arg0: vector, arg1: vector, arg2: cloud-lights, arg3: vector, arg4: vector) => nonesource
Update lighting for cloud mesh vertex.
cloud-vtx-tex-update(obj: sky-work, arg0: vector, arg1: vector, arg2: vector, arg3: cloud-lights) => nonesource
Update texture stq for cloud mesh vertex.
adjust-cloud-lighting(obj: sky-work) => nonesource
Apply lighting to cloud vertices
cloud-vtx1-to-sky(obj: sky-work, arg0: sky-vertex, arg1: cloud-vertex) => nonesource
Convert a cloud vertex to a sky vertex, using the 'normal' stq/col
cloud-vtx2-to-sky(obj: sky-work, arg0: sky-vertex, arg1: cloud-vertex) => nonesource
Convert a cloud vertex to a sky vertex, using the '2' stq/col
draw-clouds(obj: sky-work, arg0: dma-buffer) => nonesource
Draw the cloud layer using large polygon renderer
Assumes that init-regs-for-large-polygon-draw was already called.
Assumes that init-regs-for-large-polygon-draw was already called.
apply-haze-light(obj: sky-work, arg0: vector, arg1: vector, arg2: haze-lights) => nonesource
Apply haze lights to a vertex.
adjust-haze-lighting(obj: sky-work) => nonesource
Adjust lighting for haze.
haze-vtx-to-sky(obj: sky-work, arg0: sky-vertex, arg1: sky-vertex, arg2: haze-vertex) => nonesource
Convert haze vertex to sky format.
draw-haze(obj: sky-work, arg0: dma-buffer) => nonesource
Draw haze using large polygon renderer.
Calls init-regs-for-large-polygon-draw.
Calls init-regs-for-large-polygon-draw.
sun-dma: unknown
green-sun-dma: unknown
moon-dma: unknown
setup-stars(obj: sky-work, arg0: matrix, arg1: sky-upload-data) => nonesource
Prepare for star drawing.
stars-transform-asm: unknown
stars-dma: unknown
draw-roof(obj: sky-work, arg0: dma-buffer) => nonesource
Draw the roof of the sky box. Uses large-polygon renderer.
draw-base(obj: sky-work, arg0: dma-buffer) => nonesource
Draw the base of the sky box. Uses large-polygon renderer.
draw-fog(obj: sky-work, arg0: dma-buffer) => nonesource
Expand description
Sky renderer.
this render is much more complicated than the jak 1 version.
there's a lot of weird tricks to store values in the VF registers, and a lot of asm,
so a lot of this is in C++.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Large Polygon Renderer
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
there's a special "large polygon renderer" that handles clipping
and ps2-specific texture perspective stuff.
the way it subdivides is extremely strange, and not well understood, but it works well with the
Direct renderer in C++.
this renderer is also used for drawing debug regions and some parts of the ocean near the horizon.
there's a lot of state stored in vf registers, so we have to be very careful with this.
VF registers for large polygon
vf13: fog
vf14: hmge
vf23: 0?
vf24: texture offset (stored in xy, zw are 0),
vf25: hvdf-offset
vf26: inv-hmge
vf27: giftag
vf28: cam 3 (premultiplied by hmge)
vf29: cam 2 (premultiplied by hmge)
vf30: cam 1 (premultiplied by hmge)
vf31: cam 0 (premultiplied by hmge)
this render is much more complicated than the jak 1 version.
there's a lot of weird tricks to store values in the VF registers, and a lot of asm,
so a lot of this is in C++.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Large Polygon Renderer
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
there's a special "large polygon renderer" that handles clipping
and ps2-specific texture perspective stuff.
the way it subdivides is extremely strange, and not well understood, but it works well with the
Direct renderer in C++.
this renderer is also used for drawing debug regions and some parts of the ocean near the horizon.
there's a lot of state stored in vf registers, so we have to be very careful with this.
VF registers for large polygon
vf13: fog
vf14: hmge
vf23: 0?
vf24: texture offset (stored in xy, zw are 0),
vf25: hvdf-offset
vf26: inv-hmge
vf27: giftag
vf28: cam 3 (premultiplied by hmge)
vf29: cam 2 (premultiplied by hmge)
vf30: cam 1 (premultiplied by hmge)
vf31: cam 0 (premultiplied by hmge)
close-sky-buffer(arg0: dma-buffer) => nonesource
Terminate dma from large polygon renderer. This should be called after the last
call to render-sky-tri/quad.
call to render-sky-tri/quad.