ml
313 lines
10 KiB
Go
313 lines
10 KiB
Go
package levels
|
|
|
|
import (
|
|
mgl "github.com/go-gl/mathgl/mgl32"
|
|
|
|
"github.com/inkyblackness/hacked/editor/render"
|
|
"github.com/inkyblackness/hacked/ss1/content/archive/level"
|
|
"github.com/inkyblackness/hacked/ui/opengl"
|
|
)
|
|
|
|
var mapTileGridVertexShaderSource = `
|
|
#version 150
|
|
precision mediump float;
|
|
|
|
in vec4 vertexPosition;
|
|
out float colorAlpha;
|
|
|
|
uniform mat4 alphaMatrix;
|
|
|
|
uniform mat4 modelMatrix;
|
|
uniform mat4 viewMatrix;
|
|
uniform mat4 projectionMatrix;
|
|
|
|
void main(void) {
|
|
gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(vertexPosition.xy, 0.0, 1.0);
|
|
colorAlpha = alphaMatrix[int(vertexPosition.z)][int(vertexPosition.w)];
|
|
}
|
|
`
|
|
|
|
var mapTileGridFragmentShaderSource = `
|
|
#version 150
|
|
precision mediump float;
|
|
|
|
uniform vec4 color;
|
|
in float colorAlpha;
|
|
out vec4 fragColor;
|
|
|
|
void main(void) {
|
|
fragColor = vec4(color.rgb, color.a*colorAlpha);
|
|
}
|
|
`
|
|
|
|
// TileMapper returns basic information to draw a 2D map.
|
|
type TileMapper interface {
|
|
MapGridInfo(pos level.TilePosition) (level.TileType, level.TileSlopeControl, level.WallHeights)
|
|
}
|
|
|
|
// MapGrid renders the grid of the map, based on calculated wall heights.
|
|
type MapGrid struct {
|
|
context *render.Context
|
|
|
|
program uint32
|
|
vao *opengl.VertexArrayObject
|
|
vertexPositionBuffer uint32
|
|
tickVertexPositionBuffer uint32
|
|
vertexPositionAttrib int32
|
|
colorUniform opengl.Vector4Uniform
|
|
|
|
/*
|
|
The alpha matrix is set up to specify the alpha value used for the wall sections.
|
|
There are four cardinal walls with three sections each, plus two diagonal walls (single section), as well
|
|
as the slope-ticks that re-use the shader.
|
|
The matrix is meant to be used like this:
|
|
N N N D1
|
|
E E E D2
|
|
S S S -
|
|
W W W T
|
|
D1 and D2 being the two diagonals, and T specifying the cell for the tick-marks.
|
|
The vertex buffers are an array of v4 entries, with z/w specifying the row and column index to take.
|
|
*/
|
|
alphaMatrixUniform opengl.Matrix4Uniform
|
|
modelMatrixUniform opengl.Matrix4Uniform
|
|
viewMatrixUniform opengl.Matrix4Uniform
|
|
projectionMatrixUniform opengl.Matrix4Uniform
|
|
|
|
slopeTicksByType [][]int
|
|
floorTickStarts []int32
|
|
ceilingTickStarts []int32
|
|
}
|
|
|
|
// NewMapGrid returns a new instance.
|
|
func NewMapGrid(context *render.Context) *MapGrid {
|
|
gl := context.OpenGL
|
|
program, programErr := opengl.LinkNewStandardProgram(gl, mapTileGridVertexShaderSource, mapTileGridFragmentShaderSource)
|
|
if programErr != nil {
|
|
panic(opengl.NamedShaderError{Name: "MapGrid", Nested: programErr})
|
|
}
|
|
grid := &MapGrid{
|
|
context: context,
|
|
program: program,
|
|
vao: opengl.NewVertexArrayObject(gl, program),
|
|
vertexPositionBuffer: gl.GenBuffers(1)[0],
|
|
tickVertexPositionBuffer: gl.GenBuffers(1)[0],
|
|
vertexPositionAttrib: gl.GetAttribLocation(program, "vertexPosition"),
|
|
colorUniform: opengl.Vector4Uniform(gl.GetUniformLocation(program, "color")),
|
|
alphaMatrixUniform: opengl.Matrix4Uniform(gl.GetUniformLocation(program, "alphaMatrix")),
|
|
modelMatrixUniform: opengl.Matrix4Uniform(gl.GetUniformLocation(program, "modelMatrix")),
|
|
viewMatrixUniform: opengl.Matrix4Uniform(gl.GetUniformLocation(program, "viewMatrix")),
|
|
projectionMatrixUniform: opengl.Matrix4Uniform(gl.GetUniformLocation(program, "projectionMatrix")),
|
|
}
|
|
|
|
{
|
|
tickVertices := grid.calculateTickVertices()
|
|
gl.BindBuffer(opengl.ARRAY_BUFFER, grid.tickVertexPositionBuffer)
|
|
gl.BufferData(opengl.ARRAY_BUFFER, len(tickVertices)*4, tickVertices, opengl.STATIC_DRAW)
|
|
gl.BindBuffer(opengl.ARRAY_BUFFER, 0)
|
|
}
|
|
{
|
|
const parts = 3
|
|
left := float32(-0.5)
|
|
right := float32(0.5)
|
|
top := float32(0.5)
|
|
bottom := float32(-0.5)
|
|
finePerPart := float32(1.0 / parts)
|
|
|
|
var wallVertices []float32
|
|
for i := 0; i < parts; i++ {
|
|
wallVertices = append(wallVertices, left+(finePerPart*float32(i)), top, 0.0, float32(i))
|
|
wallVertices = append(wallVertices, left+(finePerPart*float32(i+1)), top, 0.0, float32(i))
|
|
}
|
|
for i := 0; i < parts; i++ {
|
|
wallVertices = append(wallVertices, right, top-(finePerPart*float32(i)), 1.0, float32(i))
|
|
wallVertices = append(wallVertices, right, top-(finePerPart*float32(i+1)), 1.0, float32(i))
|
|
}
|
|
for i := 0; i < parts; i++ {
|
|
wallVertices = append(wallVertices, right-(finePerPart*float32(i)), bottom, 2.0, float32(i))
|
|
wallVertices = append(wallVertices, right-(finePerPart*float32(i+1)), bottom, 2.0, float32(i))
|
|
}
|
|
for i := 0; i < parts; i++ {
|
|
wallVertices = append(wallVertices, left, bottom+(finePerPart*float32(i)), 3.0, float32(i))
|
|
wallVertices = append(wallVertices, left, bottom+(finePerPart*float32(i+1)), 3.0, float32(i))
|
|
}
|
|
wallVertices = append(wallVertices, left, top, 0.0, 3.0)
|
|
wallVertices = append(wallVertices, right, bottom, 0.0, 3.0)
|
|
wallVertices = append(wallVertices, right, top, 1.0, 3.0)
|
|
wallVertices = append(wallVertices, left, bottom, 1.0, 3.0)
|
|
|
|
gl.BindBuffer(opengl.ARRAY_BUFFER, grid.vertexPositionBuffer)
|
|
gl.BufferData(opengl.ARRAY_BUFFER, len(wallVertices)*4, wallVertices, opengl.STATIC_DRAW)
|
|
gl.BindBuffer(opengl.ARRAY_BUFFER, 0)
|
|
}
|
|
{
|
|
grid.slopeTicksByType = [][]int{
|
|
nil,
|
|
nil,
|
|
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
|
|
{0, 1},
|
|
{1, 2},
|
|
{2, 3},
|
|
{3, 0},
|
|
|
|
{3, 0, 1},
|
|
{0, 1, 2},
|
|
{1, 2, 3},
|
|
{2, 3, 0},
|
|
|
|
{2},
|
|
{3},
|
|
{0},
|
|
{1},
|
|
}
|
|
grid.floorTickStarts = []int32{0, 6, 12, 18}
|
|
grid.ceilingTickStarts = []int32{3, 9, 15, 21}
|
|
}
|
|
|
|
return grid
|
|
}
|
|
|
|
// Dispose releases any internal resources.
|
|
func (grid *MapGrid) Dispose() {
|
|
gl := grid.context.OpenGL
|
|
gl.DeleteProgram(grid.program)
|
|
gl.DeleteBuffers([]uint32{grid.vertexPositionBuffer, grid.tickVertexPositionBuffer})
|
|
grid.vao.Dispose()
|
|
}
|
|
|
|
func (grid *MapGrid) calculateTickVertices() []float32 {
|
|
dotHalf := float32(0.05)
|
|
dotBase := float32(0.5) - (dotHalf * 2.0)
|
|
|
|
top := dotBase + dotHalf
|
|
topEnd := dotBase - dotHalf
|
|
left := -dotBase - dotHalf
|
|
leftEnd := -dotBase + dotHalf
|
|
|
|
right := top
|
|
rightEnd := topEnd
|
|
bottom := left
|
|
bottomEnd := leftEnd
|
|
|
|
return []float32{
|
|
left, top, 3.0, 3.0, leftEnd, top, 3.0, 3.0, left, topEnd, 3.0, 3.0,
|
|
leftEnd, top, 3.0, 3.0, leftEnd, topEnd, 3.0, 3.0, left, topEnd, 3.0, 3.0,
|
|
|
|
right, top, 3.0, 3.0, right, topEnd, 3.0, 3.0, rightEnd, top, 3.0, 3.0,
|
|
rightEnd, top, 3.0, 3.0, right, topEnd, 3.0, 3.0, rightEnd, topEnd, 3.0, 3.0,
|
|
|
|
right, bottom, 3.0, 3.0, rightEnd, bottom, 3.0, 3.0, right, bottomEnd, 3.0, 3.0,
|
|
right, bottomEnd, 3.0, 3.0, rightEnd, bottom, 3.0, 3.0, rightEnd, bottomEnd, 3.0, 3.0,
|
|
|
|
left, bottomEnd, 3.0, 3.0, leftEnd, bottom, 3.0, 3.0, left, bottom, 3.0, 3.0,
|
|
left, bottomEnd, 3.0, 3.0, leftEnd, bottomEnd, 3.0, 3.0, leftEnd, bottom, 3.0, 3.0,
|
|
}
|
|
}
|
|
|
|
// Render renders the grid.
|
|
func (grid *MapGrid) Render(columns, rows int, mapper TileMapper) {
|
|
gl := grid.context.OpenGL
|
|
|
|
grid.vao.OnShader(func() {
|
|
modelMatrix := mgl.Ident4()
|
|
lineColor := [4]float32{0.0, 0.8, 0.0, 1.0}
|
|
|
|
grid.viewMatrixUniform.Set(gl, grid.context.ViewMatrix)
|
|
grid.projectionMatrixUniform.Set(gl, &grid.context.ProjectionMatrix)
|
|
|
|
heightFactor := [32*2 + 1]float32{
|
|
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
|
|
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
|
|
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
|
|
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
|
|
0.0,
|
|
0.1, 0.2, 0.3, 0.3, 0.4, 0.4, 0.5, 0.7,
|
|
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
|
|
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
|
|
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
|
|
}
|
|
|
|
for y := 0; y < rows; y++ {
|
|
for x := 0; x < columns; x++ {
|
|
tileType, slopeControl, wallHeights := mapper.MapGridInfo(level.TilePosition{X: byte(x), Y: byte(y)})
|
|
if tileType == level.TileTypeSolid {
|
|
continue
|
|
}
|
|
|
|
modelMatrix = mgl.Ident4().
|
|
Mul4(mgl.Translate3D((float32(x)+0.5)*level.FineCoordinatesPerTileSide, (float32(y)+0.5)*level.FineCoordinatesPerTileSide, 0.0)).
|
|
Mul4(mgl.Scale3D(level.FineCoordinatesPerTileSide, level.FineCoordinatesPerTileSide, 1.0))
|
|
grid.modelMatrixUniform.Set(gl, &modelMatrix)
|
|
var alphaMatrix mgl.Mat4
|
|
alphaMatrix[15] = 1.0 // for tick marks
|
|
|
|
gl.EnableVertexAttribArray(uint32(grid.vertexPositionAttrib))
|
|
gl.BindBuffer(opengl.ARRAY_BUFFER, grid.vertexPositionBuffer)
|
|
gl.VertexAttribOffset(uint32(grid.vertexPositionAttrib), 4, opengl.FLOAT, false, 0, 0)
|
|
|
|
alphaMatrix[0+0] = heightFactor[int(wallHeights.North[0])+32]
|
|
alphaMatrix[0+1] = heightFactor[int(wallHeights.North[1])+32]
|
|
alphaMatrix[0+2] = heightFactor[int(wallHeights.North[2])+32]
|
|
|
|
alphaMatrix[4+0] = heightFactor[int(wallHeights.East[0])+32]
|
|
alphaMatrix[4+1] = heightFactor[int(wallHeights.East[1])+32]
|
|
alphaMatrix[4+2] = heightFactor[int(wallHeights.East[2])+32]
|
|
|
|
alphaMatrix[8+0] = heightFactor[int(wallHeights.South[0])+32]
|
|
alphaMatrix[8+1] = heightFactor[int(wallHeights.South[1])+32]
|
|
alphaMatrix[8+2] = heightFactor[int(wallHeights.South[2])+32]
|
|
|
|
alphaMatrix[12+0] = heightFactor[int(wallHeights.West[0])+32]
|
|
alphaMatrix[12+1] = heightFactor[int(wallHeights.West[1])+32]
|
|
alphaMatrix[12+2] = heightFactor[int(wallHeights.West[2])+32]
|
|
if tileType == level.TileTypeDiagonalOpenNorthEast || tileType == level.TileTypeDiagonalOpenSouthWest {
|
|
alphaMatrix[0+3] = 1.0
|
|
}
|
|
if tileType == level.TileTypeDiagonalOpenNorthWest || tileType == level.TileTypeDiagonalOpenSouthEast {
|
|
alphaMatrix[4+3] = 1.0
|
|
}
|
|
|
|
grid.colorUniform.Set(gl, &lineColor)
|
|
grid.alphaMatrixUniform.Set(gl, &alphaMatrix)
|
|
gl.DrawArrays(opengl.LINES, 0, 28)
|
|
|
|
grid.renderSlopeTicks(gl, tileType, slopeControl)
|
|
}
|
|
}
|
|
gl.BindBuffer(opengl.ARRAY_BUFFER, 0)
|
|
})
|
|
}
|
|
|
|
func (grid *MapGrid) renderSlopeTicks(gl opengl.OpenGL, tileType level.TileType, slopeControl level.TileSlopeControl) {
|
|
var floorTicks []int
|
|
var ceilingTicks []int
|
|
|
|
if slopeControl != level.TileSlopeControlFloorFlat {
|
|
floorTicks = grid.slopeTicksByType[tileType]
|
|
}
|
|
if slopeControl == level.TileSlopeControlCeilingMirrored {
|
|
ceilingTicks = grid.slopeTicksByType[tileType]
|
|
} else if slopeControl != level.TileSlopeControlCeilingFlat {
|
|
ceilingTicks = grid.slopeTicksByType[tileType.Info().SlopeInvertedType]
|
|
}
|
|
|
|
gl.EnableVertexAttribArray(uint32(grid.vertexPositionAttrib))
|
|
gl.BindBuffer(opengl.ARRAY_BUFFER, grid.tickVertexPositionBuffer)
|
|
gl.VertexAttribOffset(uint32(grid.vertexPositionAttrib), 4, opengl.FLOAT, false, 0, 0)
|
|
|
|
floorTickColor := [4]float32{0.0, 0.8, 0.0, 0.9}
|
|
grid.colorUniform.Set(gl, &floorTickColor)
|
|
for _, index := range floorTicks {
|
|
gl.DrawArrays(opengl.TRIANGLES, grid.floorTickStarts[index], 3)
|
|
}
|
|
ceilingTickColor := [4]float32{0.8, 0.0, 0.0, 0.9}
|
|
grid.colorUniform.Set(gl, &ceilingTickColor)
|
|
for _, index := range ceilingTicks {
|
|
gl.DrawArrays(opengl.TRIANGLES, grid.ceilingTickStarts[index], 3)
|
|
}
|
|
}
|