Merge pull request #2999 from rakieldev/newstuff

feat: motif and lifebar elements projection support

Author: K4thos

external/script/main.lua

@@ -1191,6 +1191,10 @@ function main.f_addChar(line, playable, loading, slot)
 					animSetFacing(a, params.facing)
 					animSetXShear(a, params.xshear)
 					animSetAngle(a, params.angle)
+					animSetXAngle(a, params.xangle)
+					animSetYAngle(a, params.yangle)
+					animSetProjection(a, params.projection)
+					animSetfLength(a, params.focallength)
 					animSetWindow(a, params.window[1], params.window[2], params.window[3], params.window[4])
 					animUpdate(a)
 					main.t_selChars[row].cell_data = a

external/script/start.lua

@@ -757,6 +757,10 @@ function start.f_animGet(ref, side, member, paramsSide, params, loop, srcAnim)
 				animSetFacing(a, params.facing)
 				animSetXShear(a, params.xshear)
 				animSetAngle(a, params.angle)
+				animSetXAngle(a, params.xangle)
+				animSetYAngle(a, params.yangle)
+				animSetProjection(a, params.projection)
+				animSetfLength(a, params.focallength)
 				animSetWindow(a, params.window[1], params.window[2], params.window[3], params.window[4])
 				if srcAnim ~= nil then
 					animApplyVel(a, srcAnim)
@@ -1024,22 +1028,66 @@ function start.f_getCursorData(pn)
 	return motif.select_info['p' .. (pn - 1) % 2 + 1]
 end
 
-local function getCellFacing(default, col, row)
-	local cell = motif.select_info.cell[col .. '-' .. row]
-	if cell ~= nil and cell.facing ~= 0 then
-		return cell.facing
+local function getCellOverride(col, row)
+    local cells = motif.select_info.cell
+    local exact = col .. '-' .. row
+	local colWild = col .. '-*'
+	local rowWild = '*-' .. row
+    if cells[exact] then 
+		return cells[exact] 
+	end
+    if cells[colWild] then 
+		return cells[colWild] 
+	end
+    if cells[rowWild] then 
+		return cells[rowWild] 
+	end
+    if cells['*-*'] then 
+		return cells['*-*'] 
+	end
+    return nil
+end
+
+function getCellFacing(default, col, row)
+	local override = getCellOverride(col, row)
+	if override ~= nil and override.facing ~= 0 then
+		return override.facing
 	end
 	return default
 end
 
-local function getCellOffset(col, row)
-	local cell = motif.select_info.cell[col .. '-' .. row]
-	if cell ~= nil and cell.offset ~= nil then
-		return cell.offset
+function getCellOffset(col, row)
+	local override = getCellOverride(col, row)
+	if override ~= nil and override.offset ~= nil then
+		return override.offset
 	end
 	return {0, 0}
 end
 
+function getCellTransform(col, row, paramName, default)
+	local override = getCellOverride(col, row)
+	if override ~= nil then
+		local val = override[paramName]
+		-- Table Validation
+		if type(val) == "table" then
+			if paramName == "scale" then
+				if val[1] ~= 0 or val[2] ~= 0 then return val end
+			else
+				return val
+			end
+		elseif type(val) == "string" then
+			if val ~= "" then 
+				return val 
+			end
+		elseif type(val) == "number" then
+			if val ~= 0 then 
+				return val 
+			end
+		end
+	end
+	return default
+end
+
 --draw cursor
 function start.f_drawCursor(pn, x, y, param, done)
 	-- in non-coop modes only p1 and p2 cursors are used
@@ -1109,8 +1157,21 @@ function start.f_drawCursor(pn, x, y, param, done)
 	if motif.select_info['p' .. pn].cursor[param][key] ~= nil then
 		params = motif.select_info['p' .. pn].cursor[param][key]
 	end
+	local a = params.AnimData
+	if a then -- inherit cell transformation
+		animSetFacing(a, getCellFacing(params.facing, x, y))
+		local scale = getCellTransform(x, y, "scale", params.scale)
+		animSetScale(a, scale[1], scale[2])
+		animSetXShear(a, getCellTransform(x, y, "xshear", params.xshear))
+		animSetAngle(a, getCellTransform(x, y, "angle", params.angle))
+		animSetXAngle(a, getCellTransform(x, y, "xangle", params.xangle))
+		animSetYAngle(a, getCellTransform(x, y, "yangle", params.yangle))
+		animSetProjection(a, getCellTransform(x, y, "projection", params.projection))
+		animSetfLength(a, getCellTransform(x, y, "focallength", params.focallength))
+		animUpdate(a)
+	end
 	main.f_animPosDraw(
-		params.AnimData,
+		a,
 		cd.currentPos[1],
 		cd.currentPos[2],
 		getCellFacing(params.facing, x, y)
@@ -2044,34 +2105,46 @@ function start.updateDrawList()
 		for col = 1, motif.select_info.columns do
 			local cellIndex = (row - 1) * motif.select_info.columns + col
 			local t = start.t_grid[row][col]
+			local c = col - 1
+			local r = row - 1
 
 			if t.skip ~= 1 then
 				local charData = start.f_selGrid(cellIndex)
+				local function getTransforms(defaultFacing)
+					return {
+						facing      = getCellFacing(defaultFacing, c, r),
+						scale       = getCellTransform(c, r, "scale", nil),
+						xshear      = getCellTransform(c, r, "xshear", nil),
+						angle       = getCellTransform(c, r, "angle", nil),
+						xangle      = getCellTransform(c, r, "xangle", nil),
+						yangle      = getCellTransform(c, r, "yangle", nil),
+						projection  = getCellTransform(c, r, "projection", nil),
+						focallength = getCellTransform(c, r, "focallength", nil)
+					}
+				end
+
 				if (charData and charData.char ~= nil and (charData.hidden == 0 or charData.hidden == 3)) or motif.select_info.showemptyboxes then
-					table.insert(drawList, {
-						anim = motif.select_info.cell.bg.AnimData,
-						x = motif.select_info.pos[1] + t.x,
-						y = motif.select_info.pos[2] + t.y,
-						facing = getCellFacing(motif.select_info.cell.bg.facing, col - 1, row - 1)
-					})
+					local item = getTransforms(motif.select_info.cell.bg.facing)
+					item.anim = motif.select_info.cell.bg.AnimData
+					item.x = motif.select_info.pos[1] + t.x
+					item.y = motif.select_info.pos[2] + t.y
+					table.insert(drawList, item)
 				end
 
 				if charData and (charData.char == 'randomselect' or charData.hidden == 3) then
-					table.insert(drawList, {
-						anim = motif.select_info.cell.random.AnimData,
-						x = motif.select_info.pos[1] + t.x + motif.select_info.portrait.offset[1],
-						y = motif.select_info.pos[2] + t.y + motif.select_info.portrait.offset[2],
-						facing = getCellFacing(motif.select_info.cell.random.facing, col - 1, row - 1)
-					})
+					local item = getTransforms(motif.select_info.cell.random.facing)
+					item.anim = motif.select_info.cell.random.AnimData
+					item.x = motif.select_info.pos[1] + t.x + motif.select_info.portrait.offset[1]
+					item.y = motif.select_info.pos[2] + t.y + motif.select_info.portrait.offset[2]
+					table.insert(drawList, item)
 				end
 
 				if charData and charData.char_ref ~= nil and charData.hidden == 0 then
-					table.insert(drawList, {
-						anim = charData.cell_data,
-						x = motif.select_info.pos[1] + t.x + motif.select_info.portrait.offset[1],
-						y = motif.select_info.pos[2] + t.y + motif.select_info.portrait.offset[2],
-						facing = getCellFacing(motif.select_info.portrait.facing, col - 1, row - 1)
-					})
+					local item = getTransforms(motif.select_info.portrait.facing)
+					item.anim = charData.cell_data
+					item.x = motif.select_info.pos[1] + t.x + motif.select_info.portrait.offset[1]
+					item.y = motif.select_info.pos[2] + t.y + motif.select_info.portrait.offset[2]
+					table.insert(drawList, item)
 				end
 			end
 		end

src/anim.go

@@ -186,7 +186,7 @@ type Animation struct {
 	interpolate_offset_y       float32
 	scale_x                    float32
 	scale_y                    float32
-	angle                      float32
+	rot                        Rotation
 	curtrans                   TransType
 	interpolate_blend_srcalpha float32
 	interpolate_blend_dstalpha float32
@@ -565,7 +565,7 @@ func (a *Animation) UpdateSprite() {
 	a.curtrans = a.frames[a.drawidx].TransType
 	a.scale_x = a.frames[a.drawidx].Xscale
 	a.scale_y = a.frames[a.drawidx].Yscale
-	a.angle = a.frames[a.drawidx].Angle
+	a.rot.angle = a.frames[a.drawidx].Angle
 
 	a.interpolate_offset_x = 0
 	a.interpolate_offset_y = 0
@@ -610,7 +610,7 @@ func (a *Animation) UpdateSprite() {
 			drawframe_angle = a.frames[a.drawidx].Angle
 			nextframe_angle = a.frames[nextDrawidx].Angle
 
-			a.angle += (nextframe_angle - drawframe_angle) / float32(a.curFrame().Time) * float32(a.curelemtime)
+			a.rot.angle += (nextframe_angle - drawframe_angle) / float32(a.curFrame().Time) * float32(a.curelemtime)
 			break
 		}
 	}
@@ -739,7 +739,7 @@ func (a *Animation) drawSub1(angle, facing float32) (h, v, agl float32) {
 	agl = angle
 	h *= a.scale_x
 	v *= a.scale_y
-	agl += a.angle * facing
+	agl += a.rot.angle * facing
 	return
 }
 
@@ -1710,7 +1710,9 @@ type Anim struct {
 	x, y, xscl, yscl float32
 	window           [4]int32
 	xshear           float32
-	angle            float32
+	projection       int32
+	fLength          float32
+	rot              Rotation
 	xvel, yvel       float32
 	palfx            *PalFX
 	layerno          int16
@@ -1791,6 +1793,12 @@ func (a *Anim) Copy() *Anim {
 	newAnim.y = a.y
 	newAnim.xscl = a.xscl
 	newAnim.yscl = a.yscl
+	newAnim.xshear = a.xshear
+	newAnim.rot.angle = a.rot.angle
+	newAnim.rot.xangle = a.rot.xangle
+	newAnim.rot.yangle = a.rot.yangle
+	newAnim.projection = a.projection
+	newAnim.fLength = a.fLength
 	newAnim.palfx = a.palfx
 	// Copy current animation state (timing, loop, interpolation, etc.)
 	newAnim.anim.looptime = a.anim.looptime
@@ -1995,7 +2003,7 @@ func (a *Anim) Draw(ln int16) {
 
 	a.anim.Draw(&a.window, a.x+a.vel[0]-xsoffset+float32(sys.gameWidth-320)/2,
 		a.y+a.vel[1]+float32(sys.gameHeight-240), 1, 1, xscl, xscl, a.yscl,
-		xshear, Rotation{a.angle, 0, 0}, 0, a.palfx, a.facing, [2]float32{1, 1}, 0, 0, 0, false)
+		xshear, a.rot, 0, a.palfx, a.facing, [2]float32{1, 1}, a.projection, a.fLength, 0, false)
 }
 
 func (a *Anim) Reset() {

src/bytecode.go

@@ -12347,6 +12347,10 @@ const (
 	text_friction
 	text_accel
 	text_angle
+	text_xangle
+	text_yangle
+	text_projection
+	text_focallength
 	text_scale
 	text_color
 	text_xshear
@@ -12464,7 +12468,15 @@ func (sc text) Run(c *Char, _ []int32) bool {
 				yacc = exp[1].evalF(c)
 			}
 		case text_angle:
-			ts.angle = exp[0].evalF(c)
+			ts.rot.angle = exp[0].evalF(c)
+		case text_xangle:
+			ts.rot.xangle = exp[0].evalF(c)
+		case text_yangle:
+			ts.rot.yangle = exp[0].evalF(c)
+		case text_projection:
+			ts.projection = exp[0].evalI(c)
+		case text_focallength:
+			ts.fLength = exp[0].evalF(c)
 		case text_scale:
 			xscl = exp[0].evalF(c)
 			if len(exp) > 1 {
@@ -12784,7 +12796,25 @@ func (sc modifyText) Run(c *Char, _ []int32) bool {
 			case text_angle:
 				a := exp[0].evalF(c)
 				eachText(func(ts *TextSprite) {
-					ts.angle = a
+					ts.rot.angle = a
+				})
+			case text_xangle:
+				a := exp[0].evalF(c)
+				eachText(func(ts *TextSprite) {
+					ts.rot.xangle = a
+				})
+			case text_yangle:
+				a := exp[0].evalF(c)
+				eachText(func(ts *TextSprite) {
+					ts.rot.yangle = a
+				})
+			case text_projection:
+				eachText(func(ts *TextSprite) {
+					ts.projection = exp[0].evalI(c)
+				})
+			case text_focallength:
+				eachText(func(ts *TextSprite) {
+					ts.fLength = exp[0].evalF(c)
 				})
 			case text_scale:
 				x := exp[0].evalF(c)

src/common.go

@@ -996,18 +996,27 @@ func (is IniSection) getText(name string) (str string, ok bool, err error) {
 }
 
 type Layout struct {
-	offset  [2]float32
-	facing  int8
-	vfacing int8
-	layerno int16
-	scale   [2]float32
-	angle   float32
-	xshear  float32
-	window  [4]int32
+	offset     [2]float32
+	facing     int8
+	vfacing    int8
+	layerno    int16
+	scale      [2]float32
+	rot        Rotation
+	projection Projection
+	fLength    float32
+	xshear     float32
+	window     [4]int32
 }
 
 func newLayout(ln int16) *Layout {
-	return &Layout{facing: 1, vfacing: 1, layerno: ln, scale: [...]float32{1, 1}}
+	return &Layout{
+		facing:     1,
+		vfacing:    1,
+		layerno:    ln,
+		scale:      [2]float32{1, 1},
+		projection: Projection_Orthographic,
+		fLength:    2048,
+	}
 }
 
 func ReadLayout(pre string, is IniSection, ln int16) *Layout {
@@ -1036,8 +1045,21 @@ func (l *Layout) Read(pre string, is IniSection) {
 	is.ReadI32(pre+"layerno", &ln)
 	l.layerno = I32ToI16(Min(2, ln))
 	is.ReadF32(pre+"scale", &l.scale[0], &l.scale[1])
-	is.ReadF32(pre+"angle", &l.angle)
+	is.ReadF32(pre+"angle", &l.rot.angle)
+	is.ReadF32(pre+"xangle", &l.rot.xangle)
+	is.ReadF32(pre+"yangle", &l.rot.yangle)
 	is.ReadF32(pre+"xshear", &l.xshear)
+	is.ReadF32(pre+"focallength", &l.fLength)
+	if str, ok := is[pre+"projection"]; ok {
+		switch strings.ToLower(strings.TrimSpace(str)) {
+		case "orthographic":
+			l.projection = Projection_Orthographic
+		case "perspective":
+			l.projection = Projection_Perspective
+		case "perspective2":
+			l.projection = Projection_Perspective2
+		}
+	}
 	if is.ReadI32(pre+"window", &l.window[0], &l.window[1], &l.window[2], &l.window[3]) {
 		l.window[0] = int32(float32(l.window[0]) * float32(sys.scrrect[2]/sys.lifebar.localcoord[0]))
 		l.window[1] = int32(float32(l.window[1]) * float32(sys.scrrect[3]/sys.lifebar.localcoord[1]))
@@ -1077,7 +1099,7 @@ func (l *Layout) DrawFaceSprite(x, y float32, ln int16, s *Sprite, fx *PalFX, fs
 
 		s.Draw(x+l.offset[0]*sys.lifebar.scale-xsoffset, y+l.offset[1]*sys.lifebar.scale,
 			l.scale[0]*float32(l.facing)*fscale, l.scale[1]*float32(l.vfacing)*fscale,
-			xshear, Rotation{l.angle, 0, 0}, fx, window)
+			xshear, l.rot, int32(l.projection), l.fLength, fx, window)
 	}
 }
 
@@ -1100,8 +1122,8 @@ func (l *Layout) DrawAnim(r *[4]int32, x, y, scl, xscl, yscl float32, ln int16,
 
 		a.Draw(r, x+l.offset[0]-xsoffset, y+l.offset[1]+float32(sys.gameHeight-240),
 			scl, scl, (l.scale[0]*xscl)*float32(l.facing), (l.scale[0]*xscl)*float32(l.facing),
-			(l.scale[1]*yscl)*float32(l.vfacing), xshear, Rotation{l.angle, 0, 0},
-			float32(sys.gameWidth-320)/2, palfx, 1, [2]float32{1, 1}, 0, 0, 0, false)
+			(l.scale[1]*yscl)*float32(l.vfacing), xshear, l.rot,
+			float32(sys.gameWidth-320)/2, palfx, 1, [2]float32{1, 1}, int32(l.projection), l.fLength, 0, false)
 	}
 }
 
@@ -1121,8 +1143,8 @@ func (l *Layout) DrawText(x, y, scl float32, ln int16,
 
 		f.Print(text, (x+l.offset[0]-xsoffset)*scl, (y+l.offset[1])*scl,
 			l.scale[0]*sys.lifebar.fnt_scale*float32(l.facing)*scl,
-			l.scale[1]*sys.lifebar.fnt_scale*float32(l.vfacing)*scl, xshear, Rotation{l.angle, 0, 0},
-			b, a, &l.window, palfx, frgba)
+			l.scale[1]*sys.lifebar.fnt_scale*float32(l.vfacing)*scl, xshear, l.rot,
+			int32(l.projection), l.fLength, b, a, &l.window, palfx, frgba)
 	}
 }