Pending
package FreeFormCamera
import ClosureKeyPresses
import FramehandleNames
import ClosureFrames
import RegisterEvents
//============================================================================
// CONFIGURATION
//============================================================================
// Press LEFT CTRL to toggle the camera on and off.
//
// CONTROLS WHEN ACTIVE:
// - Right-Click + Drag: Rotate camera view (Yaw & Pitch).
// - SHIFT + Right-Click + Drag: Move camera vertically up/down.
// - Left-Click + Drag: Move forward/backward and strafe left/right.
// - Mouse Wheel Scroll: Zoom in and out.
//============================================================================
@configurable constant TOGGLE_KEY = OSKEY_CONTROL
@configurable constant ROTATION_SENSITIVITY = 90//180.
@configurable constant MOVEMENT_SPEED = 2500.
@configurable constant VERTICAL_SPEED = 1800.
@configurable constant ZOOM_SENSITIVITY = 50.
@configurable constant ZOOM_ACCEL = 6.
@configurable constant DRAG_PIXEL_SCALE = 1.0
@configurable constant MIN_ZOOM_DISTANCE = 100.
@configurable constant MAX_ZOOM_DISTANCE = 4000.
@configurable constant LERP_FACTOR = 0.25
//============================================================================
// GLOBAL VARIABLES
//============================================================================
timer timer_
framehandle mouseWheelFrame
boolean isCameraActive
boolean isLeftMouseDown
boolean isRightMouseDown
boolean isShiftDown
boolean hasCameraChanged
real lastMouseX
real lastMouseY
boolean isDraggingLeft
boolean isDraggingRight
real targetCameraX
real targetCameraY
real targetCameraZ
real targetCameraYaw
real targetCameraPitch
real targetCameraDistance
real currentCameraX
real currentCameraY
real currentCameraZ
real currentCameraYaw
real currentCameraPitch
real currentCameraDistance
//============================================================================
// CAMERA LOGIC
//============================================================================
function normalize360(real r) returns real
if r >= 360.
return r - 360.
if r < 0.
return r + 360.
return r
function updateCamera()
if isCameraActive
// Lerp
currentCameraX += (targetCameraX - currentCameraX) * LERP_FACTOR
currentCameraY += (targetCameraY - currentCameraY) * LERP_FACTOR
currentCameraZ += (targetCameraZ - currentCameraZ) * LERP_FACTOR
currentCameraYaw += (targetCameraYaw - currentCameraYaw) * LERP_FACTOR
currentCameraPitch += (targetCameraPitch - currentCameraPitch) * LERP_FACTOR
currentCameraDistance += (targetCameraDistance - currentCameraDistance) * LERP_FACTOR
// Apply
SetCameraPosition(currentCameraX, currentCameraY)
SetCameraField(CAMERA_FIELD_ZOFFSET, currentCameraZ, 0)
SetCameraField(CAMERA_FIELD_ROTATION, normalize360(currentCameraYaw), 0)
SetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK, normalize360(currentCameraPitch), 0)
SetCameraField(CAMERA_FIELD_TARGET_DISTANCE, currentCameraDistance, 0)
function onMouseMove()
if not isCameraActive
return
let curX = BlzGetTriggerPlayerMouseX()
let curY = BlzGetTriggerPlayerMouseY()
if isLeftMouseDown and not isDraggingLeft
isDraggingLeft = true
lastMouseX = curX
lastMouseY = curY
return
if isRightMouseDown and not isDraggingRight
isDraggingRight = true
lastMouseX = curX
lastMouseY = curY
return
let dx = curX - lastMouseX
let dy = curY - lastMouseY
if isDraggingLeft or isDraggingRight
if isLeftMouseDown
let yawRad = (targetCameraYaw)*DEGTORAD
let fwdX = (yawRad).cos()
let fwdY = (yawRad).sin()
let strafeX = (yawRad).sin()
let strafeY = -(yawRad).cos()
targetCameraX += (strafeX * dx - fwdX * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE
targetCameraY += (strafeY * dx - fwdY * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE
if isRightMouseDown
if isShiftDown
targetCameraZ -= dy * VERTICAL_SPEED
else
targetCameraYaw = normalize360(targetCameraYaw - dx * ROTATION_SENSITIVITY)
targetCameraPitch = normalize360(targetCameraPitch - dy * ROTATION_SENSITIVITY)
lastMouseX = curX
lastMouseY = curY
function onMouseDown()
if isCameraActive
let btn = BlzGetTriggerPlayerMouseButton()
if btn == MOUSE_BUTTON_TYPE_LEFT
isLeftMouseDown = true
if btn == MOUSE_BUTTON_TYPE_RIGHT
isRightMouseDown = true
function onMouseUp()
let btn = BlzGetTriggerPlayerMouseButton()
if btn == MOUSE_BUTTON_TYPE_LEFT
isLeftMouseDown = false
isDraggingLeft = false
if btn == MOUSE_BUTTON_TYPE_RIGHT
isRightMouseDown = false
isDraggingRight = false
function onMouseWheel()
if not isCameraActive
return
let raw = BlzGetTriggerFrameValue()
if raw == 0
return
let steps = ZOOM_SENSITIVITY * ZOOM_ACCEL
if raw > 0
targetCameraDistance -= steps
else
targetCameraDistance += steps
if targetCameraDistance < MIN_ZOOM_DISTANCE
targetCameraDistance = MIN_ZOOM_DISTANCE
if targetCameraDistance > MAX_ZOOM_DISTANCE
targetCameraDistance = MAX_ZOOM_DISTANCE
function syncCameraState()
let camX = GetCameraTargetPositionX()
let camY = GetCameraTargetPositionY()
let camZ = GetCameraField(CAMERA_FIELD_ZOFFSET)
let camYaw = GetCameraField(CAMERA_FIELD_ROTATION)*RADTODEG
let camPitch = GetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK)*RADTODEG
let camDist = GetCameraField(CAMERA_FIELD_TARGET_DISTANCE)
currentCameraX = camX
targetCameraX = camX
currentCameraY = camY
targetCameraY = camY
currentCameraZ = camZ
targetCameraZ = camZ
currentCameraYaw = camYaw
targetCameraYaw = camYaw
currentCameraPitch = camPitch
targetCameraPitch = camPitch
currentCameraDistance = camDist
targetCameraDistance = camDist
function onToggleCamera()
isCameraActive = not isCameraActive
if isCameraActive
syncCameraState()
TimerStart(timer_, 0.03, true, function updateCamera)
EnableSelect(false, false)
BlzFrameSetVisible(mouseWheelFrame, true)
DisplayTimedTextToPlayer(GetTriggerPlayer(), 0, 0, 2.0, "Free Camera Enabled")
else
timer_.pause()
EnableSelect(true, true)
BlzFrameSetVisible(mouseWheelFrame, false)
DisplayTimedTextToPlayer(GetTriggerPlayer(), 0, 0, 2.0, "Free Camera Disabled")
function onKeyEvent()
if BlzGetTriggerPlayerKey() == OSKEY_SHIFT
isShiftDown = BlzGetTriggerPlayerIsKeyDown()
//============================================================================
// INITIALIZATION
//============================================================================
init
CameraSetSmoothingFactor(100)
timer_ = CreateTimer()
mouseWheelFrame = createFrame(FramehandleTypeNames.text, "MouseWheelFrame", WORLD_UI, "", 0)
..setAllPoints(WORLD_UI)
..hide()
..onMouseWheel() ->
onMouseWheel()
registerPlayerEvent(EVENT_PLAYER_MOUSE_MOVE, function onMouseMove)
registerPlayerEvent(EVENT_PLAYER_MOUSE_DOWN, function onMouseDown)
registerPlayerEvent(EVENT_PLAYER_MOUSE_UP, function onMouseUp)
onKeyPress(TOGGLE_KEY) ->
onToggleCamera()
onKeyPress(OSKEY_SHIFT) ->
onKeyEvent()
onKeyRelease(OSKEY_SHIFT) ->
onKeyEvent()-- FreeFormCamera.lua
do
--============================================================================
-- CONFIG
--============================================================================
local TOGGLE_KEY = OSKEY_CONTROL
local ROTATION_SENSITIVITY = 90.0
local MOVEMENT_SPEED = 2500.0
local VERTICAL_SPEED = 1800.0
local ZOOM_SENSITIVITY = 50.0
local ZOOM_ACCEL = 6.0
local DRAG_PIXEL_SCALE = 1.0
local MIN_ZOOM_DISTANCE = 100.0
local MAX_ZOOM_DISTANCE = 4000.0
local LERP_FACTOR = 0.25
--============================================================================
-- STATE
--============================================================================
local timer_ = nil
local mouseWheelFrame = nil
local isCameraActive = false
local isLeftMouseDown = false
local isRightMouseDown = false
local isShiftDown = false
local lastMouseX, lastMouseY = 0.0, 0.0
local isDraggingLeft, isDraggingRight = false, false
local targetCameraX, targetCameraY, targetCameraZ = 0.0, 0.0, 0.0
local targetCameraYaw, targetCameraPitch = 0.0, 0.0
local targetCameraDistance = 1650.0
local currentCameraX, currentCameraY, currentCameraZ = 0.0, 0.0, 0.0
local currentCameraYaw, currentCameraPitch = 0.0, 0.0
local currentCameraDistance = 1650.0
--============================================================================
-- CAMERA LOGIC
--============================================================================
local function Normalize360(r)
r = r % 360.0
if r < 0.0 then r = r + 360.0 end
return r
end
local function UpdateCamera()
if not isCameraActive then return end
-- Lerp towards target
currentCameraX = currentCameraX + (targetCameraX - currentCameraX) * LERP_FACTOR
currentCameraY = currentCameraY + (targetCameraY - currentCameraY) * LERP_FACTOR
currentCameraZ = currentCameraZ + (targetCameraZ - currentCameraZ) * LERP_FACTOR
currentCameraYaw = currentCameraYaw + (targetCameraYaw - currentCameraYaw) * LERP_FACTOR
currentCameraPitch = currentCameraPitch + (targetCameraPitch - currentCameraPitch) * LERP_FACTOR
currentCameraDistance = currentCameraDistance + (targetCameraDistance - currentCameraDistance) * LERP_FACTOR
-- Apply
SetCameraPosition(currentCameraX, currentCameraY)
SetCameraField(CAMERA_FIELD_ZOFFSET, currentCameraZ, 0.00)
SetCameraField(CAMERA_FIELD_ROTATION, Normalize360(currentCameraYaw), 0.00)
SetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK, Normalize360(currentCameraPitch), 0.00)
SetCameraField(CAMERA_FIELD_TARGET_DISTANCE, currentCameraDistance, 0.00)
end
local function OnMouseMove()
if not isCameraActive then return end
local curX = BlzGetTriggerPlayerMouseX()
local curY = BlzGetTriggerPlayerMouseY()
if isLeftMouseDown and not isDraggingLeft then
isDraggingLeft = true
lastMouseX, lastMouseY = curX, curY
return
end
if isRightMouseDown and not isDraggingRight then
isDraggingRight = true
lastMouseX, lastMouseY = curX, curY
return
end
local dx = curX - lastMouseX
local dy = curY - lastMouseY
if isDraggingLeft or isDraggingRight then
if isLeftMouseDown then
local yawRad = math.rad(targetCameraYaw)
local fwdX = math.cos(yawRad)
local fwdY = math.sin(yawRad)
local strafeX = math.sin(yawRad)
local strafeY = -math.cos(yawRad)
targetCameraX = targetCameraX + (strafeX * dx - fwdX * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE
targetCameraY = targetCameraY + (strafeY * dx - fwdY * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE
end
if isRightMouseDown then
if isShiftDown then
targetCameraZ = targetCameraZ - dy * VERTICAL_SPEED
else
targetCameraYaw = Normalize360(targetCameraYaw - dx * ROTATION_SENSITIVITY)
targetCameraPitch = Normalize360(targetCameraPitch - dy * ROTATION_SENSITIVITY)
end
end
lastMouseX, lastMouseY = curX, curY
end
end
local function OnMouseDown()
if not isCameraActive then return end
local btn = BlzGetTriggerPlayerMouseButton()
if btn == MOUSE_BUTTON_TYPE_LEFT then
isLeftMouseDown = true
elseif btn == MOUSE_BUTTON_TYPE_RIGHT then
isRightMouseDown = true
end
end
local function OnMouseUp()
local btn = BlzGetTriggerPlayerMouseButton()
if btn == MOUSE_BUTTON_TYPE_LEFT then
isLeftMouseDown = false
isDraggingLeft = false
elseif btn == MOUSE_BUTTON_TYPE_RIGHT then
isRightMouseDown = false
isDraggingRight = false
end
end
local function OnMouseWheel()
if not isCameraActive then return end
local raw = BlzGetTriggerFrameValue()
if raw == 0 then return end
local steps = ZOOM_SENSITIVITY * ZOOM_ACCEL
if raw > 0 then
targetCameraDistance = targetCameraDistance - steps
else
targetCameraDistance = targetCameraDistance + steps
end
if targetCameraDistance < MIN_ZOOM_DISTANCE then
targetCameraDistance = MIN_ZOOM_DISTANCE
elseif targetCameraDistance > MAX_ZOOM_DISTANCE then
targetCameraDistance = MAX_ZOOM_DISTANCE
end
end
local function SyncCameraState()
local camX = GetCameraTargetPositionX()
local camY = GetCameraTargetPositionY()
local camZ = GetCameraField(CAMERA_FIELD_ZOFFSET)
local camYaw = GetCameraField(CAMERA_FIELD_ROTATION) -- already in degrees
local camPitch= GetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK) -- already in degrees
local camDist = GetCameraField(CAMERA_FIELD_TARGET_DISTANCE)
currentCameraX, targetCameraX = camX, camX
currentCameraY, targetCameraY = camY, camY
currentCameraZ, targetCameraZ = camZ, camZ
currentCameraYaw, targetCameraYaw = camYaw, camYaw
currentCameraPitch, targetCameraPitch = camPitch, camPitch
currentCameraDistance, targetCameraDistance = camDist, camDist
end
local function OnToggleCamera()
isCameraActive = not isCameraActive
local p = GetTriggerPlayer()
if isCameraActive then
SyncCameraState()
TimerStart(timer_, 0.03, true, UpdateCamera)
EnableSelect(false)
EnablePreSelect(false)
BlzFrameSetVisible(mouseWheelFrame, true)
DisplayTimedTextToPlayer(p, 0, 0, 2.0, "Free Camera Enabled")
else
PauseTimer(timer_)
EnableSelect(true)
EnablePreSelect(true)
BlzFrameSetVisible(mouseWheelFrame, false)
DisplayTimedTextToPlayer(p, 0, 0, 2.0, "Free Camera Disabled")
-- Reset drag state
isLeftMouseDown, isRightMouseDown = false, false
isDraggingLeft, isDraggingRight = false, false
end
end
local function OnKeyEvent()
if BlzGetTriggerPlayerKey() == OSKEY_SHIFT then
isShiftDown = BlzGetTriggerPlayerIsKeyDown()
end
end
--============================================================================
-- INIT
--============================================================================
local function Init()
CameraSetSmoothingFactor(100)
timer_ = CreateTimer()
mouseWheelFrame = BlzCreateFrameByType(
"TEXT", "MouseWheelFrame", BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0), "", 0
)
BlzFrameSetAllPoints(mouseWheelFrame, BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0))
BlzFrameSetVisible(mouseWheelFrame, false)
local trig = CreateTrigger()
BlzTriggerRegisterFrameEvent(trig, mouseWheelFrame, FRAMEEVENT_MOUSE_WHEEL)
TriggerAddAction(trig, OnMouseWheel)
for i = 0, bj_MAX_PLAYER_SLOTS - 1 do
local pl = Player(i)
if GetPlayerSlotState(pl) == PLAYER_SLOT_STATE_PLAYING then
trig = CreateTrigger()
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_MOVE)
TriggerAddAction(trig, OnMouseMove)
trig = CreateTrigger()
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_DOWN)
TriggerAddAction(trig, OnMouseDown)
trig = CreateTrigger()
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_UP)
TriggerAddAction(trig, OnMouseUp)
trig = CreateTrigger()
BlzTriggerRegisterPlayerKeyEvent(trig, pl, TOGGLE_KEY, 0, true)
TriggerAddAction(trig, OnToggleCamera)
trig = CreateTrigger()
BlzTriggerRegisterPlayerKeyEvent(trig, pl, OSKEY_SHIFT, 0, true)
TriggerAddAction(trig, OnKeyEvent)
trig = CreateTrigger()
BlzTriggerRegisterPlayerKeyEvent(trig, pl, OSKEY_SHIFT, 0, false)
TriggerAddAction(trig, OnKeyEvent)
end
end
end
-- Run once at map start
do
local t = CreateTrigger()
TriggerRegisterTimerEventSingle(t, 0.00)
TriggerAddAction(t, Init)
end
endlibrary FreeFormCamera initializer Init
//============================================================================
// CONFIGURATION
//============================================================================
// Press LEFT CTRL to toggle the camera on and off.
//
// CONTROLS WHEN ACTIVE:
// - Right-Click + Drag: Rotate camera view (Yaw & Pitch).
// - SHIFT + Right-Click + Drag: Move camera vertically up/down.
// - Left-Click + Drag: Move forward/backward and strafe left/right.
// - Mouse Wheel Scroll: Zoom in and out.
//============================================================================
globals
private constant oskeytype TOGGLE_KEY = OSKEY_CONTROL
private constant real ROTATION_SENSITIVITY = 180.
private constant real MOVEMENT_SPEED = 2500.
private constant real VERTICAL_SPEED = 1800.
private constant real ZOOM_SENSITIVITY = 50.
private constant real ZOOM_ACCEL = 6.
private constant real DRAG_PIXEL_SCALE = 1.0
private constant real MIN_ZOOM_DISTANCE = 100.
private constant real MAX_ZOOM_DISTANCE = 4000.
private constant real LERP_FACTOR = 0.25
//============================================================================
// STATE VARIABLES
//============================================================================
private timer tmr
private framehandle mouseWheelFrame
private boolean isCameraActive = false
private boolean isLeftMouseDown = false
private boolean isRightMouseDown = false
private boolean isShiftDown = false
private real lastMouseX
private real lastMouseY
private boolean isDraggingLeft = false
private boolean isDraggingRight = false
private real targetCameraX
private real targetCameraY
private real targetCameraZ
private real targetCameraYaw
private real targetCameraPitch
private real targetCameraDistance
private real currentCameraX
private real currentCameraY
private real currentCameraZ
private real currentCameraYaw
private real currentCameraPitch
private real currentCameraDistance
endglobals
//============================================================================
// CAMERA LOGIC
//============================================================================
private function Normalize360 takes real r returns real
if r >= 360. then
return r - 360.
endif
if r < 0. then
return r + 360.
endif
return r
endfunction
private function UpdateCamera takes nothing returns nothing
if isCameraActive then
// Lerp
set currentCameraX = currentCameraX + (targetCameraX - currentCameraX) * LERP_FACTOR
set currentCameraY = currentCameraY + (targetCameraY - currentCameraY) * LERP_FACTOR
set currentCameraZ = currentCameraZ + (targetCameraZ - currentCameraZ) * LERP_FACTOR
set currentCameraYaw = currentCameraYaw + (targetCameraYaw - currentCameraYaw) * LERP_FACTOR
set currentCameraPitch = currentCameraPitch + (targetCameraPitch - currentCameraPitch) * LERP_FACTOR
set currentCameraDistance = currentCameraDistance + (targetCameraDistance - currentCameraDistance) * LERP_FACTOR
// Apply
call SetCameraPosition(currentCameraX, currentCameraY)
call SetCameraField(CAMERA_FIELD_ZOFFSET, currentCameraZ, 0.03)
call SetCameraField(CAMERA_FIELD_ROTATION, Normalize360(currentCameraYaw), 0.03)
call SetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK, Normalize360(currentCameraPitch), 0.03)
call SetCameraField(CAMERA_FIELD_TARGET_DISTANCE, currentCameraDistance, 0.03)
endif
endfunction
private function OnMouseMove takes nothing returns nothing
local real curX
local real curY
local real dx
local real dy
local real yawRad
local real fwdX
local real fwdY
local real strafeX
local real strafeY
if not isCameraActive then
return
endif
set curX = BlzGetTriggerPlayerMouseX()
set curY = BlzGetTriggerPlayerMouseY()
if isLeftMouseDown and not isDraggingLeft then
set isDraggingLeft = true
set lastMouseX = curX
set lastMouseY = curY
return
endif
if isRightMouseDown and not isDraggingRight then
set isDraggingRight = true
set lastMouseX = curX
set lastMouseY = curY
return
endif
set dx = curX - lastMouseX
set dy = curY - lastMouseY
if isDraggingLeft or isDraggingRight then
if isLeftMouseDown then
set yawRad = targetCameraYaw*bj_DEGTORAD
set fwdX = Cos(yawRad)
set fwdY = Sin(yawRad)
set strafeX = Sin(yawRad)
set strafeY = -Cos(yawRad)
set targetCameraX = targetCameraX + (strafeX * dx - fwdX * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE
set targetCameraY = targetCameraY + (strafeY * dx - fwdY * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE
endif
if isRightMouseDown then
if isShiftDown then
set targetCameraZ = targetCameraZ - dy * VERTICAL_SPEED
else
set targetCameraYaw = Normalize360(targetCameraYaw - dx * ROTATION_SENSITIVITY)
set targetCameraPitch = Normalize360(targetCameraPitch - dy * ROTATION_SENSITIVITY)
endif
endif
set lastMouseX = curX
set lastMouseY = curY
endif
endfunction
private function OnMouseDown takes nothing returns nothing
local mousebuttontype btn
if isCameraActive then
set btn = BlzGetTriggerPlayerMouseButton()
if btn == MOUSE_BUTTON_TYPE_LEFT then
set isLeftMouseDown = true
endif
if btn == MOUSE_BUTTON_TYPE_RIGHT then
set isRightMouseDown = true
endif
endif
endfunction
private function OnMouseUp takes nothing returns nothing
local mousebuttontype btn = BlzGetTriggerPlayerMouseButton()
if btn == MOUSE_BUTTON_TYPE_LEFT then
set isLeftMouseDown = false
set isDraggingLeft = false
endif
if btn == MOUSE_BUTTON_TYPE_RIGHT then
set isRightMouseDown = false
set isDraggingRight = false
endif
endfunction
private function OnMouseWheel takes nothing returns nothing
local real steps
local real raw
if not isCameraActive then
return
endif
set raw = BlzGetTriggerFrameValue()
if raw == 0 then
return
endif
set steps = ZOOM_SENSITIVITY * ZOOM_ACCEL
if raw > 0 then
set targetCameraDistance = targetCameraDistance - steps
else
set targetCameraDistance = targetCameraDistance + steps
endif
if targetCameraDistance < MIN_ZOOM_DISTANCE then
set targetCameraDistance = MIN_ZOOM_DISTANCE
endif
if targetCameraDistance > MAX_ZOOM_DISTANCE then
set targetCameraDistance = MAX_ZOOM_DISTANCE
endif
endfunction
private function SyncCameraState takes nothing returns nothing
local real camX = GetCameraTargetPositionX()
local real camY = GetCameraTargetPositionY()
local real camZ = GetCameraField(CAMERA_FIELD_ZOFFSET)
local real camYaw = GetCameraField(CAMERA_FIELD_ROTATION)*bj_RADTODEG
local real camPitch = GetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK)*bj_RADTODEG
local real camDist = GetCameraField(CAMERA_FIELD_TARGET_DISTANCE)
set currentCameraX = camX
set targetCameraX = camX
set currentCameraY = camY
set targetCameraY = camY
set currentCameraZ = camZ
set targetCameraZ = camZ
set currentCameraYaw = camYaw
set targetCameraYaw = camYaw
set currentCameraPitch = camPitch
set targetCameraPitch = camPitch
set currentCameraDistance = camDist
set targetCameraDistance = camDist
endfunction
private function OnToggleCamera takes nothing returns nothing
set isCameraActive = not isCameraActive
if isCameraActive then
call SyncCameraState()
call TimerStart(tmr, 0.03, true, function UpdateCamera)
call EnableSelect(false, false)
call BlzFrameSetVisible(mouseWheelFrame, true)
call DisplayTimedTextToPlayer(GetTriggerPlayer(), 0, 0, 2.0, "Free Camera Enabled")
else
call PauseTimer(tmr)
call EnableSelect(true, true)
call BlzFrameSetVisible(mouseWheelFrame, false)
call DisplayTimedTextToPlayer(GetTriggerPlayer(), 0, 0, 2.0, "Free Camera Disabled")
endif
endfunction
private function OnKeyEvent takes nothing returns nothing
if BlzGetTriggerPlayerKey() == OSKEY_SHIFT then
set isShiftDown = BlzGetTriggerPlayerIsKeyDown()
endif
endfunction
//============================================================================
// INITIALIZATION
//============================================================================
private function Init takes nothing returns nothing
local trigger trig
local player pl
local integer i
call CameraSetSmoothingFactor(100)
set tmr = CreateTimer()
set mouseWheelFrame = BlzCreateFrameByType("TEXT", "MouseWheelFrame", BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0), "", 0)
call BlzFrameSetAllPoints(mouseWheelFrame, BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0))
call BlzFrameSetVisible(mouseWheelFrame, false)
set trig = CreateTrigger()
call BlzTriggerRegisterFrameEvent(trig, mouseWheelFrame, FRAMEEVENT_MOUSE_WHEEL)
call TriggerAddAction(trig, function OnMouseWheel)
set i = 0
loop
set pl = Player(i)
if GetPlayerSlotState(pl) == PLAYER_SLOT_STATE_PLAYING then
set trig = CreateTrigger()
call TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_MOVE)
call TriggerAddAction(trig, function OnMouseMove)
set trig = CreateTrigger()
call TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_DOWN)
call TriggerAddAction(trig, function OnMouseDown)
set trig = CreateTrigger()
call TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_UP)
call TriggerAddAction(trig, function OnMouseUp)
set trig = CreateTrigger()
call BlzTriggerRegisterPlayerKeyEvent(trig, pl, TOGGLE_KEY, 0, true)
call TriggerAddAction(trig, function OnToggleCamera)
set trig = CreateTrigger()
call BlzTriggerRegisterPlayerKeyEvent(trig, pl, OSKEY_SHIFT, 0, true)
call TriggerAddAction(trig, function OnKeyEvent)
set trig = CreateTrigger()
call BlzTriggerRegisterPlayerKeyEvent(trig, pl, OSKEY_SHIFT, 0, false)
call TriggerAddAction(trig, function OnKeyEvent)
endif
set i = i + 1
exitwhen i == bj_MAX_PLAYER_SLOTS
endloop
endfunction
endlibrary// ============================================================================
// FreeFormCamera.cs (C# / War3Api)
// Requires: https://github.com/Drake53/CSharp.lua
// ============================================================================
using System;
using static War3Api.Common;
using static War3Api.Blizzard;
public static class FreeFormCamera
{
//============================================================================
// CONFIG
//============================================================================
private const oskeytype TOGGLE_KEY = oskeytype.OSKEY_CONTROL;
private const float ROTATION_SENSITIVITY = 90.0f;
private const float MOVEMENT_SPEED = 2500.0f;
private const float VERTICAL_SPEED = 1800.0f;
private const float ZOOM_SENSITIVITY = 50.0f;
private const float ZOOM_ACCEL = 6.0f;
private const float DRAG_PIXEL_SCALE = 1.0f;
private const float MIN_ZOOM_DISTANCE = 100.0f;
private const float MAX_ZOOM_DISTANCE = 4000.0f;
private const float LERP_FACTOR = 0.25f;
//============================================================================
// STATE
//============================================================================
private static timer s_timer;
private static framehandle s_mouseWheelFrame;
private static bool s_isCameraActive = false;
private static bool s_isLeftMouseDown = false;
private static bool s_isRightMouseDown = false;
private static bool s_isShiftDown = false;
private static float s_lastMouseX = 0.0f, s_lastMouseY = 0.0f;
private static bool s_isDraggingLeft = false, s_isDraggingRight = false;
private static float s_targetX = 0.0f, s_targetY = 0.0f, s_targetZ = 0.0f;
private static float s_targetYaw = 0.0f, s_targetPitch = 0.0f;
private static float s_targetDist = 1650.0f;
private static float s_currX = 0.0f, s_currY = 0.0f, s_currZ = 0.0f;
private static float s_currYaw = 0.0f, s_currPitch = 0.0f;
private static float s_currDist = 1650.0f;
// Public entry: call once during your startup to install the system.
public static void Setup()
{
var boot = CreateTrigger();
TriggerRegisterTimerEventSingle(boot, 0.00f);
TriggerAddAction(boot, Init);
}
//============================================================================
// CAMERA LOGIC
//============================================================================
private static float Normalize360(float r)
{
r = ModuloReal(r, 360.0f);
if (r < 0.0f) r += 360.0f;
return r;
}
private static void UpdateCamera()
{
if (!s_isCameraActive) return;
// Lerp towards target
s_currX += (s_targetX - s_currX) * LERP_FACTOR;
s_currY += (s_targetY - s_currY) * LERP_FACTOR;
s_currZ += (s_targetZ - s_currZ) * LERP_FACTOR;
s_currYaw += (s_targetYaw - s_currYaw) * LERP_FACTOR;
s_currPitch += (s_targetPitch- s_currPitch)* LERP_FACTOR;
s_currDist += (s_targetDist - s_currDist) * LERP_FACTOR;
// Apply
SetCameraPosition(s_currX, s_currY);
SetCameraField(CAMERA_FIELD_ZOFFSET, s_currZ, 0.00f);
SetCameraField(CAMERA_FIELD_ROTATION, Normalize360(s_currYaw), 0.00f);
SetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK, Normalize360(s_currPitch), 0.00f);
SetCameraField(CAMERA_FIELD_TARGET_DISTANCE, s_currDist, 0.00f);
}
private static void OnMouseMove()
{
if (!s_isCameraActive) return;
float curX = BlzGetTriggerPlayerMouseX();
float curY = BlzGetTriggerPlayerMouseY();
if (s_isLeftMouseDown && !s_isDraggingLeft)
{
s_isDraggingLeft = true;
s_lastMouseX = curX; s_lastMouseY = curY;
return;
}
if (s_isRightMouseDown && !s_isDraggingRight)
{
s_isDraggingRight = true;
s_lastMouseX = curX; s_lastMouseY = curY;
return;
}
float dx = curX - s_lastMouseX;
float dy = curY - s_lastMouseY;
if (s_isDraggingLeft || s_isDraggingRight)
{
if (s_isLeftMouseDown)
{
float yawRad = s_targetYaw * bj_DEGTORAD;
float fwdX = Cos(yawRad);
float fwdY = Sin(yawRad);
float strafeX = Sin(yawRad);
float strafeY = -Cos(yawRad);
s_targetX += (strafeX * dx - fwdX * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE;
s_targetY += (strafeY * dx - fwdY * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE;
}
if (s_isRightMouseDown)
{
if (s_isShiftDown)
{
s_targetZ -= dy * VERTICAL_SPEED;
}
else
{
s_targetYaw = Normalize360(s_targetYaw - dx * ROTATION_SENSITIVITY);
s_targetPitch = Normalize360(s_targetPitch - dy * ROTATION_SENSITIVITY);
}
}
s_lastMouseX = curX; s_lastMouseY = curY;
}
}
private static void OnMouseDown()
{
if (!s_isCameraActive) return;
mousebuttontype btn = BlzGetTriggerPlayerMouseButton();
if (btn == MOUSE_BUTTON_TYPE_LEFT)
{
s_isLeftMouseDown = true;
}
else if (btn == MOUSE_BUTTON_TYPE_RIGHT)
{
s_isRightMouseDown = true;
}
}
private static void OnMouseUp()
{
mousebuttontype btn = BlzGetTriggerPlayerMouseButton();
if (btn == MOUSE_BUTTON_TYPE_LEFT)
{
s_isLeftMouseDown = false;
s_isDraggingLeft = false;
}
else if (btn == MOUSE_BUTTON_TYPE_RIGHT)
{
s_isRightMouseDown = false;
s_isDraggingRight = false;
}
}
private static void OnMouseWheel()
{
if (!s_isCameraActive) return;
float raw = BlzGetTriggerFrameValue();
if (raw == 0.0f) return;
float steps = ZOOM_SENSITIVITY * ZOOM_ACCEL;
if (raw > 0.0f) s_targetDist -= steps;
else s_targetDist += steps;
if (s_targetDist < MIN_ZOOM_DISTANCE) s_targetDist = MIN_ZOOM_DISTANCE;
else if (s_targetDist > MAX_ZOOM_DISTANCE) s_targetDist = MAX_ZOOM_DISTANCE;
}
private static void SyncCameraState()
{
float camX = GetCameraTargetPositionX();
float camY = GetCameraTargetPositionY();
float camZ = GetCameraField(CAMERA_FIELD_ZOFFSET);
float camYaw = GetCameraField(CAMERA_FIELD_ROTATION); // degrees
float camPitch = GetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK); // degrees
float camDist = GetCameraField(CAMERA_FIELD_TARGET_DISTANCE);
s_currX = s_targetX = camX;
s_currY = s_targetY = camY;
s_currZ = s_targetZ = camZ;
s_currYaw = s_targetYaw = camYaw;
s_currPitch = s_targetPitch = camPitch;
s_currDist = s_targetDist = camDist;
}
private static void OnToggleCamera()
{
s_isCameraActive = !s_isCameraActive;
player p = GetTriggerPlayer();
if (s_isCameraActive)
{
SyncCameraState();
TimerStart(s_timer, 0.03f, true, UpdateCamera);
EnableSelect(false);
EnablePreSelect(false);
BlzFrameSetVisible(s_mouseWheelFrame, true);
DisplayTimedTextToPlayer(p, 0.0f, 0.0f, 2.0f, "Free Camera Enabled");
}
else
{
PauseTimer(s_timer);
EnableSelect(true);
EnablePreSelect(true);
BlzFrameSetVisible(s_mouseWheelFrame, false);
DisplayTimedTextToPlayer(p, 0.0f, 0.0f, 2.0f, "Free Camera Disabled");
// Reset drag state
s_isLeftMouseDown = false;
s_isRightMouseDown = false;
s_isDraggingLeft = false;
s_isDraggingRight = false;
}
}
private static void OnKeyEvent()
{
if (BlzGetTriggerPlayerKey() == oskeytype.OSKEY_SHIFT)
{
s_isShiftDown = BlzGetTriggerPlayerIsKeyDown();
}
}
//============================================================================
// INIT
//============================================================================
private static void Init()
{
CameraSetSmoothingFactor(100);
s_timer = CreateTimer();
s_mouseWheelFrame = BlzCreateFrameByType(
"TEXT", "MouseWheelFrame", BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0), "", 0);
BlzFrameSetAllPoints(s_mouseWheelFrame, BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0));
BlzFrameSetVisible(s_mouseWheelFrame, false);
// Mouse wheel frame event
var trig = CreateTrigger();
BlzTriggerRegisterFrameEvent(trig, s_mouseWheelFrame, FRAMEEVENT_MOUSE_WHEEL);
TriggerAddAction(trig, OnMouseWheel);
// Per-player mouse + key events
for (int i = 0; i < bj_MAX_PLAYER_SLOTS; i++)
{
player pl = Player(i);
if (GetPlayerSlotState(pl) == PLAYER_SLOT_STATE_PLAYING)
{
trig = CreateTrigger();
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_MOVE);
TriggerAddAction(trig, OnMouseMove);
trig = CreateTrigger();
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_DOWN);
TriggerAddAction(trig, OnMouseDown);
trig = CreateTrigger();
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_UP);
TriggerAddAction(trig, OnMouseUp);
trig = CreateTrigger();
BlzTriggerRegisterPlayerKeyEvent(trig, pl, TOGGLE_KEY, 0, true);
TriggerAddAction(trig, OnToggleCamera);
trig = CreateTrigger();
BlzTriggerRegisterPlayerKeyEvent(trig, pl, oskeytype.OSKEY_SHIFT, 0, true);
TriggerAddAction(trig, OnKeyEvent);
trig = CreateTrigger();
BlzTriggerRegisterPlayerKeyEvent(trig, pl, oskeytype.OSKEY_SHIFT, 0, false);
TriggerAddAction(trig, OnKeyEvent);
}
}
}
}# ============================================================================
# FreeFormCamera.py (PyWC3 / Python -> Lua for Warcraft III)
# Requires: https://github.com/Blimba/PyWC3
# ============================================================================
from std.index import * # AddScriptHook, hook points, std helpers
# These are for IDE completion; PyWC3 treats them as defs-only. Optional but handy:
from df.commonj import * # JASS natives/constants (for code completion)
from df.blizzardj import * # Blizzard UI/Frame natives (for code completion)
# ============================================================================
# CONFIG
# ============================================================================
TOGGLE_KEY = OSKEY_CONTROL
ROTATION_SENSITIVITY = 90.0
MOVEMENT_SPEED = 2500.0
VERTICAL_SPEED = 1800.0
ZOOM_SENSITIVITY = 50.0
ZOOM_ACCEL = 6.0
DRAG_PIXEL_SCALE = 1.0
MIN_ZOOM_DISTANCE = 100.0
MAX_ZOOM_DISTANCE = 4000.0
LERP_FACTOR = 0.25
# ============================================================================
# STATE
# ============================================================================
_timer = None
_mouseWheelFrame = None
_isCameraActive = False
_isLeftMouseDown = False
_isRightMouseDown = False
_isShiftDown = False
_lastMouseX, _lastMouseY = 0.0, 0.0
_isDraggingLeft, _isDraggingRight = False, False
_targetX, _targetY, _targetZ = 0.0, 0.0, 0.0
_targetYaw, _targetPitch = 0.0, 0.0
_targetDist = 1650.0
_currX, _currY, _currZ = 0.0, 0.0, 0.0
_currYaw, _currPitch = 0.0, 0.0
_currDist = 1650.0
# ============================================================================
# CAMERA LOGIC
# ============================================================================
def _normalize360(r: float) -> float:
# Use the JASS native to match in-game semantics exactly.
r = ModuloReal(r, 360.0)
if r < 0.0:
r += 360.0
return r
def _update_camera():
global _currX, _currY, _currZ, _currYaw, _currPitch, _currDist
if not _isCameraActive:
return
# Lerp towards target
_currX += (_targetX - _currX) * LERP_FACTOR
_currY += (_targetY - _currY) * LERP_FACTOR
_currZ += (_targetZ - _currZ) * LERP_FACTOR
_currYaw += (_targetYaw - _currYaw) * LERP_FACTOR
_currPitch += (_targetPitch - _currPitch) * LERP_FACTOR
_currDist += (_targetDist - _currDist) * LERP_FACTOR
# Apply
SetCameraPosition(_currX, _currY)
SetCameraField(CAMERA_FIELD_ZOFFSET, _currZ, 0.00)
SetCameraField(CAMERA_FIELD_ROTATION, _normalize360(_currYaw), 0.00)
SetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK, _normalize360(_currPitch), 0.00)
SetCameraField(CAMERA_FIELD_TARGET_DISTANCE, _currDist, 0.00)
def _on_mouse_move():
global _isDraggingLeft, _isDraggingRight, _lastMouseX, _lastMouseY
global _targetX, _targetY, _targetZ, _targetYaw, _targetPitch
if not _isCameraActive:
return
curX = BlzGetTriggerPlayerMouseX()
curY = BlzGetTriggerPlayerMouseY()
if _isLeftMouseDown and not _isDraggingLeft:
_isDraggingLeft = True
_lastMouseX, _lastMouseY = curX, curY
return
if _isRightMouseDown and not _isDraggingRight:
_isDraggingRight = True
_lastMouseX, _lastMouseY = curX, curY
return
dx = curX - _lastMouseX
dy = curY - _lastMouseY
if _isDraggingLeft or _isDraggingRight:
if _isLeftMouseDown:
yawRad = _targetYaw * bj_DEGTORAD
fwdX = Cos(yawRad)
fwdY = Sin(yawRad)
strafeX = Sin(yawRad)
strafeY = -Cos(yawRad)
_targetX += (strafeX * dx - fwdX * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE
_targetY += (strafeY * dx - fwdY * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE
if _isRightMouseDown:
if _isShiftDown:
_targetZ -= dy * VERTICAL_SPEED
else:
_targetYaw = _normalize360(_targetYaw - dx * ROTATION_SENSITIVITY)
_targetPitch = _normalize360(_targetPitch - dy * ROTATION_SENSITIVITY)
_lastMouseX, _lastMouseY = curX, curY
def _on_mouse_down():
global _isLeftMouseDown, _isRightMouseDown
if not _isCameraActive:
return
btn = BlzGetTriggerPlayerMouseButton()
if btn == MOUSE_BUTTON_TYPE_LEFT:
_isLeftMouseDown = True
elif btn == MOUSE_BUTTON_TYPE_RIGHT:
_isRightMouseDown = True
def _on_mouse_up():
global _isLeftMouseDown, _isRightMouseDown, _isDraggingLeft, _isDraggingRight
btn = BlzGetTriggerPlayerMouseButton()
if btn == MOUSE_BUTTON_TYPE_LEFT:
_isLeftMouseDown = False
_isDraggingLeft = False
elif btn == MOUSE_BUTTON_TYPE_RIGHT:
_isRightMouseDown = False
_isDraggingRight = False
def _on_mouse_wheel():
global _targetDist
if not _isCameraActive:
return
raw = BlzGetTriggerFrameValue()
if raw == 0.0:
return
steps = ZOOM_SENSITIVITY * ZOOM_ACCEL
if raw > 0.0:
_targetDist -= steps
else:
_targetDist += steps
if _targetDist < MIN_ZOOM_DISTANCE:
_targetDist = MIN_ZOOM_DISTANCE
elif _targetDist > MAX_ZOOM_DISTANCE:
_targetDist = MAX_ZOOM_DISTANCE
def _sync_camera_state():
global _currX, _currY, _currZ, _currYaw, _currPitch, _currDist
global _targetX, _targetY, _targetZ, _targetYaw, _targetPitch, _targetDist
camX = GetCameraTargetPositionX()
camY = GetCameraTargetPositionY()
camZ = GetCameraField(CAMERA_FIELD_ZOFFSET)
camYaw = GetCameraField(CAMERA_FIELD_ROTATION) # degrees
camPitch = GetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK) # degrees
camDist = GetCameraField(CAMERA_FIELD_TARGET_DISTANCE)
_currX = _targetX = camX
_currY = _targetY = camY
_currZ = _targetZ = camZ
_currYaw = _targetYaw = camYaw
_currPitch = _targetPitch = camPitch
_currDist = _targetDist = camDist
def _on_toggle_camera():
global _isCameraActive, _timer, _mouseWheelFrame
global _isLeftMouseDown, _isRightMouseDown, _isDraggingLeft, _isDraggingRight
_isCameraActive = not _isCameraActive
p = GetTriggerPlayer()
if _isCameraActive:
_sync_camera_state()
TimerStart(_timer, 0.03, True, _update_camera)
EnableSelect(False)
EnablePreSelect(False)
BlzFrameSetVisible(_mouseWheelFrame, True)
DisplayTimedTextToPlayer(p, 0.0, 0.0, 2.0, "Free Camera Enabled")
else:
PauseTimer(_timer)
EnableSelect(True)
EnablePreSelect(True)
BlzFrameSetVisible(_mouseWheelFrame, False)
DisplayTimedTextToPlayer(p, 0.0, 0.0, 2.0, "Free Camera Disabled")
# Reset drag state
_isLeftMouseDown = False
_isRightMouseDown = False
_isDraggingLeft = False
_isDraggingRight = False
def _on_key_event():
global _isShiftDown
if BlzGetTriggerPlayerKey() == OSKEY_SHIFT:
_isShiftDown = BlzGetTriggerPlayerIsKeyDown()
# ============================================================================
# INIT
# ============================================================================
def _init():
global _timer, _mouseWheelFrame
CameraSetSmoothingFactor(100)
_timer = CreateTimer()
_mouseWheelFrame = BlzCreateFrameByType(
"TEXT", "MouseWheelFrame", BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0), "", 0
)
BlzFrameSetAllPoints(_mouseWheelFrame, BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0))
BlzFrameSetVisible(_mouseWheelFrame, False)
trig = CreateTrigger()
BlzTriggerRegisterFrameEvent(trig, _mouseWheelFrame, FRAMEEVENT_MOUSE_WHEEL)
TriggerAddAction(trig, _on_mouse_wheel)
for i in range(0, bj_MAX_PLAYER_SLOTS):
pl = Player(i)
if GetPlayerSlotState(pl) == PLAYER_SLOT_STATE_PLAYING:
trig = CreateTrigger()
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_MOVE)
TriggerAddAction(trig, _on_mouse_move)
trig = CreateTrigger()
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_DOWN)
TriggerAddAction(trig, _on_mouse_down)
trig = CreateTrigger()
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_UP)
TriggerAddAction(trig, _on_mouse_up)
trig = CreateTrigger()
BlzTriggerRegisterPlayerKeyEvent(trig, pl, TOGGLE_KEY, 0, True)
TriggerAddAction(trig, _on_toggle_camera)
trig = CreateTrigger()
BlzTriggerRegisterPlayerKeyEvent(trig, pl, OSKEY_SHIFT, 0, True)
TriggerAddAction(trig, _on_key_event)
trig = CreateTrigger()
BlzTriggerRegisterPlayerKeyEvent(trig, pl, OSKEY_SHIFT, 0, False)
TriggerAddAction(trig, _on_key_event)
def setup():
"""Call once (e.g., from your map’s main python file)."""
AddScriptHook(_init, MAIN_AFTER)// ============================================================================
// FreeFormCamera.as (AngelScript)
// Requires: https://github.com/UnryzeC/WC3_AngelScript
// ============================================================================
//============================================================================
// CONFIG
//============================================================================
const oskeytype TOGGLE_KEY = OSKEY_CONTROL;
const float ROTATION_SENSITIVITY = 90.0f;
const float MOVEMENT_SPEED = 2500.0f;
const float VERTICAL_SPEED = 1800.0f;
const float ZOOM_SENSITIVITY = 50.0f;
const float ZOOM_ACCEL = 6.0f;
const float DRAG_PIXEL_SCALE = 1.0f;
const float MIN_ZOOM_DISTANCE = 100.0f;
const float MAX_ZOOM_DISTANCE = 4000.0f;
const float LERP_FACTOR = 0.25f;
//============================================================================
// STATE
//============================================================================
timer timer_ = null;
framehandle mouseWheelFrame = null;
bool isCameraActive = false;
bool isLeftMouseDown = false;
bool isRightMouseDown = false;
bool isShiftDown = false;
float lastMouseX = 0.0f, lastMouseY = 0.0f;
bool isDraggingLeft = false, isDraggingRight = false;
float targetCameraX = 0.0f, targetCameraY = 0.0f, targetCameraZ = 0.0f;
float targetCameraYaw = 0.0f, targetCameraPitch = 0.0f;
float targetCameraDistance = 1650.0f;
float currentCameraX = 0.0f, currentCameraY = 0.0f, currentCameraZ = 0.0f;
float currentCameraYaw = 0.0f, currentCameraPitch = 0.0f;
float currentCameraDistance = 1650.0f;
//============================================================================
// CAMERA LOGIC
//============================================================================
float Normalize360(float r)
{
r = ModuloReal(r, 360.0f);
if (r < 0.0f) r += 360.0f;
return r;
}
void UpdateCamera()
{
if (!isCameraActive) return;
// Lerp towards target
currentCameraX += (targetCameraX - currentCameraX) * LERP_FACTOR;
currentCameraY += (targetCameraY - currentCameraY) * LERP_FACTOR;
currentCameraZ += (targetCameraZ - currentCameraZ) * LERP_FACTOR;
currentCameraYaw += (targetCameraYaw - currentCameraYaw) * LERP_FACTOR;
currentCameraPitch += (targetCameraPitch - currentCameraPitch) * LERP_FACTOR;
currentCameraDistance += (targetCameraDistance - currentCameraDistance) * LERP_FACTOR;
// Apply
SetCameraPosition(currentCameraX, currentCameraY);
SetCameraField(CAMERA_FIELD_ZOFFSET, currentCameraZ, 0.00f);
SetCameraField(CAMERA_FIELD_ROTATION, Normalize360(currentCameraYaw), 0.00f);
SetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK, Normalize360(currentCameraPitch), 0.00f);
SetCameraField(CAMERA_FIELD_TARGET_DISTANCE, currentCameraDistance, 0.00f);
}
void OnMouseMove()
{
if (!isCameraActive) return;
float curX = BlzGetTriggerPlayerMouseX();
float curY = BlzGetTriggerPlayerMouseY();
if (isLeftMouseDown && !isDraggingLeft)
{
isDraggingLeft = true;
lastMouseX = curX; lastMouseY = curY;
return;
}
if (isRightMouseDown && !isDraggingRight)
{
isDraggingRight = true;
lastMouseX = curX; lastMouseY = curY;
return;
}
float dx = curX - lastMouseX;
float dy = curY - lastMouseY;
if (isDraggingLeft || isDraggingRight)
{
if (isLeftMouseDown)
{
float yawRad = targetCameraYaw * bj_DEGTORAD;
float fwdX = Cos(yawRad);
float fwdY = Sin(yawRad);
float strafeX = Sin(yawRad);
float strafeY = -Cos(yawRad);
targetCameraX += (strafeX * dx - fwdX * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE;
targetCameraY += (strafeY * dx - fwdY * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE;
}
if (isRightMouseDown)
{
if (isShiftDown)
{
targetCameraZ -= dy * VERTICAL_SPEED;
}
else
{
targetCameraYaw = Normalize360(targetCameraYaw - dx * ROTATION_SENSITIVITY);
targetCameraPitch = Normalize360(targetCameraPitch - dy * ROTATION_SENSITIVITY);
}
}
lastMouseX = curX; lastMouseY = curY;
}
}
void OnMouseDown()
{
if (!isCameraActive) return;
mousebuttontype btn = BlzGetTriggerPlayerMouseButton();
if (btn == MOUSE_BUTTON_TYPE_LEFT)
{
isLeftMouseDown = true;
}
else if (btn == MOUSE_BUTTON_TYPE_RIGHT)
{
isRightMouseDown = true;
}
}
void OnMouseUp()
{
mousebuttontype btn = BlzGetTriggerPlayerMouseButton();
if (btn == MOUSE_BUTTON_TYPE_LEFT)
{
isLeftMouseDown = false;
isDraggingLeft = false;
}
else if (btn == MOUSE_BUTTON_TYPE_RIGHT)
{
isRightMouseDown = false;
isDraggingRight = false;
}
}
void OnMouseWheel()
{
if (!isCameraActive) return;
float raw = BlzGetTriggerFrameValue();
if (raw == 0.0f) return;
float steps = ZOOM_SENSITIVITY * ZOOM_ACCEL;
if (raw > 0.0f)
targetCameraDistance -= steps;
else
targetCameraDistance += steps;
if (targetCameraDistance < MIN_ZOOM_DISTANCE)
targetCameraDistance = MIN_ZOOM_DISTANCE;
else if (targetCameraDistance > MAX_ZOOM_DISTANCE)
targetCameraDistance = MAX_ZOOM_DISTANCE;
}
void SyncCameraState()
{
float camX = GetCameraTargetPositionX();
float camY = GetCameraTargetPositionY();
float camZ = GetCameraField(CAMERA_FIELD_ZOFFSET);
float camYaw = GetCameraField(CAMERA_FIELD_ROTATION); // degrees
float camPitch = GetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK); // degrees
float camDist = GetCameraField(CAMERA_FIELD_TARGET_DISTANCE);
currentCameraX = targetCameraX = camX;
currentCameraY = targetCameraY = camY;
currentCameraZ = targetCameraZ = camZ;
currentCameraYaw = targetCameraYaw = camYaw;
currentCameraPitch = targetCameraPitch = camPitch;
currentCameraDistance = targetCameraDistance = camDist;
}
void OnToggleCamera()
{
isCameraActive = !isCameraActive;
player p = GetTriggerPlayer();
if (isCameraActive)
{
SyncCameraState();
TimerStart(timer_, 0.03f, true, @UpdateCamera);
EnableSelect(false);
EnablePreSelect(false);
BlzFrameSetVisible(mouseWheelFrame, true);
DisplayTimedTextToPlayer(p, 0.0f, 0.0f, 2.0f, "Free Camera Enabled");
}
else
{
PauseTimer(timer_);
EnableSelect(true);
EnablePreSelect(true);
BlzFrameSetVisible(mouseWheelFrame, false);
DisplayTimedTextToPlayer(p, 0.0f, 0.0f, 2.0f, "Free Camera Disabled");
// Reset drag state
isLeftMouseDown = false; isRightMouseDown = false;
isDraggingLeft = false; isDraggingRight = false;
}
}
void OnKeyEvent()
{
if (BlzGetTriggerPlayerKey() == OSKEY_SHIFT)
{
isShiftDown = BlzGetTriggerPlayerIsKeyDown();
}
}
//============================================================================
// INIT
//============================================================================
void Init()
{
CameraSetSmoothingFactor(100);
timer_ = CreateTimer();
mouseWheelFrame = BlzCreateFrameByType(
"TEXT", "MouseWheelFrame", BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0), "", 0
);
BlzFrameSetAllPoints(mouseWheelFrame, BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0));
BlzFrameSetVisible(mouseWheelFrame, false);
trigger trig = CreateTrigger();
BlzTriggerRegisterFrameEvent(trig, mouseWheelFrame, FRAMEEVENT_MOUSE_WHEEL);
TriggerAddAction(trig, @OnMouseWheel);
for (int i = 0; i < bj_MAX_PLAYER_SLOTS; ++i)
{
player pl = Player(i);
if (GetPlayerSlotState(pl) == PLAYER_SLOT_STATE_PLAYING)
{
trig = CreateTrigger();
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_MOVE);
TriggerAddAction(trig, @OnMouseMove);
trig = CreateTrigger();
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_DOWN);
TriggerAddAction(trig, @OnMouseDown);
trig = CreateTrigger();
TriggerRegisterPlayerEvent(trig, pl, EVENT_PLAYER_MOUSE_UP);
TriggerAddAction(trig, @OnMouseUp);
trig = CreateTrigger();
BlzTriggerRegisterPlayerKeyEvent(trig, pl, TOGGLE_KEY, 0, true);
TriggerAddAction(trig, @OnToggleCamera);
trig = CreateTrigger();
BlzTriggerRegisterPlayerKeyEvent(trig, pl, OSKEY_SHIFT, 0, true);
TriggerAddAction(trig, @OnKeyEvent);
trig = CreateTrigger();
BlzTriggerRegisterPlayerKeyEvent(trig, pl, OSKEY_SHIFT, 0, false);
TriggerAddAction(trig, @OnKeyEvent);
}
}
}
// Run once at map start
void onInit()
{
trigger t = CreateTrigger();
TriggerRegisterTimerEventSingle(t, 0.00f);
TriggerAddAction(t, @Init);
}// FreeFormCamera.ts
import { addScriptHook, W3TS_HOOK, Timer, Trigger } from "w3ts/index";
//============================================================================
// CONFIGURATION
//============================================================================
// Press LEFT CTRL to toggle the camera on and off.
//
// CONTROLS WHEN ACTIVE:
// - Right-Click + Drag: Rotate camera view (Yaw & Pitch).
// - SHIFT + Right-Click + Drag: Move camera vertically up/down.
// - Left-Click + Drag: Move forward/backward and strafe left/right.
// - Mouse Wheel Scroll: Zoom in and out.
//============================================================================
// JASS constants / types come from the WC3 API typings via w3ts
const TOGGLE_KEY = OSKEY_CONTROL as oskeytype;
const ROTATION_SENSITIVITY = 90.0; // degrees per (pixel * scale)
const MOVEMENT_SPEED = 2500.0;
const VERTICAL_SPEED = 1800.0;
const ZOOM_SENSITIVITY = 50.0;
const ZOOM_ACCEL = 6.0;
const DRAG_PIXEL_SCALE = 1.0;
const MIN_ZOOM_DISTANCE = 100.0;
const MAX_ZOOM_DISTANCE = 4000.0;
const LERP_FACTOR = 0.25;
//============================================================================
// GLOBAL STATE
//============================================================================
let timer_: Timer;
let mouseWheelFrame: framehandle;
let isCameraActive = false;
let isLeftMouseDown = false;
let isRightMouseDown = false;
let isShiftDown = false;
let lastMouseX = 0.0;
let lastMouseY = 0.0;
let isDraggingLeft = false;
let isDraggingRight = false;
let targetCameraX = 0.0;
let targetCameraY = 0.0;
let targetCameraZ = 0.0;
let targetCameraYaw = 0.0; // degrees
let targetCameraPitch = 0.0; // degrees
let targetCameraDistance = 0.0;
let currentCameraX = 0.0;
let currentCameraY = 0.0;
let currentCameraZ = 0.0;
let currentCameraYaw = 0.0; // degrees
let currentCameraPitch = 0.0; // degrees
let currentCameraDistance = 0.0;
//============================================================================
// CAMERA LOGIC
//============================================================================
function normalize360(r: number): number {
if (r >= 360.0) return r - 360.0;
if (r < 0.0) return r + 360.0;
return r;
}
function updateCamera(): void {
if (!isCameraActive) return;
// Lerp towards targets
currentCameraX += (targetCameraX - currentCameraX) * LERP_FACTOR;
currentCameraY += (targetCameraY - currentCameraY) * LERP_FACTOR;
currentCameraZ += (targetCameraZ - currentCameraZ) * LERP_FACTOR;
currentCameraYaw += (targetCameraYaw - currentCameraYaw) * LERP_FACTOR;
currentCameraPitch += (targetCameraPitch - currentCameraPitch) * LERP_FACTOR;
currentCameraDistance += (targetCameraDistance - currentCameraDistance) * LERP_FACTOR;
// Apply (WC3 camera fields expect degrees for rotation/attack)
SetCameraPosition(currentCameraX, currentCameraY);
SetCameraField(CAMERA_FIELD_ZOFFSET, currentCameraZ, 0);
SetCameraField(CAMERA_FIELD_ROTATION, normalize360(currentCameraYaw), 0);
SetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK, normalize360(currentCameraPitch), 0);
SetCameraField(CAMERA_FIELD_TARGET_DISTANCE, currentCameraDistance, 0);
}
function onMouseMove(): void {
if (!isCameraActive) return;
const curX = BlzGetTriggerPlayerMouseX();
const curY = BlzGetTriggerPlayerMouseY();
if (isLeftMouseDown && !isDraggingLeft) {
isDraggingLeft = true;
lastMouseX = curX;
lastMouseY = curY;
return;
}
if (isRightMouseDown && !isDraggingRight) {
isDraggingRight = true;
lastMouseX = curX;
lastMouseY = curY;
return;
}
const dx = curX - lastMouseX;
const dy = curY - lastMouseY;
if (isDraggingLeft || isDraggingRight) {
if (isLeftMouseDown) {
const yawRad = targetCameraYaw * bj_DEGTORAD;
const fwdX = Math.cos(yawRad);
const fwdY = Math.sin(yawRad);
const strafeX = Math.sin(yawRad);
const strafeY = -Math.cos(yawRad);
targetCameraX += (strafeX * dx - fwdX * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE;
targetCameraY += (strafeY * dx - fwdY * dy) * MOVEMENT_SPEED * DRAG_PIXEL_SCALE;
}
if (isRightMouseDown) {
if (isShiftDown) {
targetCameraZ -= dy * VERTICAL_SPEED;
} else {
targetCameraYaw = normalize360(targetCameraYaw - dx * ROTATION_SENSITIVITY);
targetCameraPitch = normalize360(targetCameraPitch - dy * ROTATION_SENSITIVITY);
}
}
lastMouseX = curX;
lastMouseY = curY;
}
}
function onMouseDown(): void {
if (!isCameraActive) return;
const btn = BlzGetTriggerPlayerMouseButton();
if (btn === MOUSE_BUTTON_TYPE_LEFT) isLeftMouseDown = true;
if (btn === MOUSE_BUTTON_TYPE_RIGHT) isRightMouseDown = true;
}
function onMouseUp(): void {
const btn = BlzGetTriggerPlayerMouseButton();
if (btn === MOUSE_BUTTON_TYPE_LEFT) {
isLeftMouseDown = false;
isDraggingLeft = false;
}
if (btn === MOUSE_BUTTON_TYPE_RIGHT) {
isRightMouseDown = false;
isDraggingRight = false;
}
}
function onMouseWheel(): void {
if (!isCameraActive) return;
const raw = BlzGetTriggerFrameValue();
if (raw === 0) return;
const steps = ZOOM_SENSITIVITY * ZOOM_ACCEL;
if (raw > 0) targetCameraDistance -= steps;
else targetCameraDistance += steps;
if (targetCameraDistance < MIN_ZOOM_DISTANCE) targetCameraDistance = MIN_ZOOM_DISTANCE;
if (targetCameraDistance > MAX_ZOOM_DISTANCE) targetCameraDistance = MAX_ZOOM_DISTANCE;
}
function syncCameraState(): void {
const camX = GetCameraTargetPositionX();
const camY = GetCameraTargetPositionY();
const camZ = GetCameraField(CAMERA_FIELD_ZOFFSET);
const camYaw = GetCameraField(CAMERA_FIELD_ROTATION) * bj_RADTODEG; // store degrees
const camPitch= GetCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK) * bj_RADTODEG; // store degrees
const camDist = GetCameraField(CAMERA_FIELD_TARGET_DISTANCE);
currentCameraX = targetCameraX = camX;
currentCameraY = targetCameraY = camY;
currentCameraZ = targetCameraZ = camZ;
currentCameraYaw = targetCameraYaw = camYaw;
currentCameraPitch = targetCameraPitch = camPitch;
currentCameraDistance = targetCameraDistance = camDist;
}
function onToggleCamera(): void {
isCameraActive = !isCameraActive;
const p = GetTriggerPlayer();
if (isCameraActive) {
syncCameraState();
timer_.start(0.03, true, () => updateCamera());
EnableSelect(false, false);
BlzFrameSetVisible(mouseWheelFrame, true);
DisplayTimedTextToPlayer(p, 0, 0, 2.0, "Free Camera Enabled");
} else {
timer_.pause();
EnableSelect(true, true);
BlzFrameSetVisible(mouseWheelFrame, false);
DisplayTimedTextToPlayer(p, 0, 0, 2.0, "Free Camera Disabled");
}
}
function onKeyEvent(): void {
if (BlzGetTriggerPlayerKey() === OSKEY_SHIFT) {
isShiftDown = BlzGetTriggerPlayerIsKeyDown();
}
}
//============================================================================
// INITIALIZATION
//============================================================================
function init(): void {
// Smooth interpolation between WC3 camera updates
CameraSetSmoothingFactor(100);
// Update timer
timer_ = new Timer();
// Full-screen invisible frame to capture wheel events when active
mouseWheelFrame = BlzCreateFrameByType(
"TEXT",
"MouseWheelFrame",
BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0),
"",
0
);
BlzFrameSetAllPoints(mouseWheelFrame, BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0));
BlzFrameSetVisible(mouseWheelFrame, false);
// Mouse wheel trigger (single, global)
{
const t = new Trigger();
BlzTriggerRegisterFrameEvent(t.handle, mouseWheelFrame, FRAMEEVENT_MOUSE_WHEEL);
t.addAction(() => onMouseWheel());
}
// Per-player input hooks
for (let i = 0; i < bj_MAX_PLAYER_SLOTS; i++) {
const pl = Player(i);
if (GetPlayerSlotState(pl) === PLAYER_SLOT_STATE_PLAYING) {
// Mouse move
{
const t = new Trigger();
t.registerPlayerEvent(pl, EVENT_PLAYER_MOUSE_MOVE);
t.addAction(() => onMouseMove());
}
// Mouse down
{
const t = new Trigger();
t.registerPlayerEvent(pl, EVENT_PLAYER_MOUSE_DOWN);
t.addAction(() => onMouseDown());
}
// Mouse up
{
const t = new Trigger();
t.registerPlayerEvent(pl, EVENT_PLAYER_MOUSE_UP);
t.addAction(() => onMouseUp());
}
// Toggle (Left Ctrl)
{
const t = new Trigger();
BlzTriggerRegisterPlayerKeyEvent(t.handle, pl, TOGGLE_KEY, 0, true);
t.addAction(() => onToggleCamera());
}
// Shift down
{
const t = new Trigger();
BlzTriggerRegisterPlayerKeyEvent(t.handle, pl, OSKEY_SHIFT, 0, true);
t.addAction(() => onKeyEvent());
}
// Shift up
{
const t = new Trigger();
BlzTriggerRegisterPlayerKeyEvent(t.handle, pl, OSKEY_SHIFT, 0, false);
t.addAction(() => onKeyEvent());
}
}
}
}
// Hook into map init (after main)
addScriptHook(W3TS_HOOK.MAIN_AFTER, () => init());
