Open source Star Ruler 2 source code!
This commit is contained in:
Lucas de Vries
@@ -0,0 +1,585 @@
|
||||
//input.as
|
||||
//--------
|
||||
//Various script callbacks for global input handling.
|
||||
//Also handles passing events to the GUI
|
||||
|
||||
#priority init 1
|
||||
import elements.IGuiElement;
|
||||
import targeting.targeting;
|
||||
import navigation.SmartCamera;
|
||||
import util.convar;
|
||||
from navigation.elevation import getElevationIntersect;
|
||||
|
||||
import bool onMouseEvent(const MouseEvent&) from "gui";
|
||||
import bool onKeyboardEvent(const KeyboardEvent&) from "gui";
|
||||
import bool onGuiEvent(const GuiEvent&) from "gui";
|
||||
import void onGuiNavigate(vec2d direction) from "gui";
|
||||
import IGuiElement@ getGuiFocus() from "gui";
|
||||
import bool isGuiHovered() from "gui";
|
||||
import void selectionClick(uint button, bool pressed) from "obj_selection";
|
||||
import void dragSelect(const recti&) from "obj_selection";
|
||||
import Object@ get_hoveredObject() from "obj_selection";
|
||||
import Object@ get_selectedObject() from "obj_selection";
|
||||
import Object@ get_uiObject() from "obj_selection";
|
||||
import void updateHoveredObject() from "obj_selection";
|
||||
import bool objectKeyEvent(int key, bool pressed) from "commands";
|
||||
import void switchToTab(int pos) from "tabs.tabbar";
|
||||
import bool tabEscape() from "tabs.tabbar";
|
||||
import double getAverageElevation() from "navigation.elevation";
|
||||
|
||||
ConVar FollowAI("follow_ai", 0);
|
||||
|
||||
//TODO: Anything directly using the engine camera should go through the camera module
|
||||
|
||||
const double tickZoom = 1.2;
|
||||
const double zoomPerPixel = 0.01;
|
||||
const double camAnglesPerPixel = 0.22 * twopi / 360.0;
|
||||
const double movePerPixel = 0.001;
|
||||
const double zoomPerSecond = 0.45;
|
||||
const double rollBorder = 0.4;
|
||||
const double camMotionPerSecond = 80.0;
|
||||
|
||||
vec2i dragArea, dragFrom;
|
||||
array<double> edgePanDelay = {0.0, 0.0, 0.0, 0.0};
|
||||
array<double> edgePanRampup = {0.3, 0.3, 0.3, 0.3};
|
||||
array<double> edgePanTimers = {0.0, 0.0, 0.0, 0.0};
|
||||
bool doingBoxSelect = false;
|
||||
|
||||
Joystick joystick(1);
|
||||
bool joystickConnected = false;
|
||||
bool joystickActive = false;
|
||||
|
||||
SmartCamera@ ActiveCamera;
|
||||
SmartCamera PreviousCamera;
|
||||
|
||||
SmartCamera@ get_activeCamera() {
|
||||
return ActiveCamera;
|
||||
}
|
||||
|
||||
SmartCamera@ get_lastCamera() {
|
||||
if(ActiveCamera !is null)
|
||||
return ActiveCamera;
|
||||
return PreviousCamera;
|
||||
}
|
||||
|
||||
void set_activeCamera(SmartCamera@ cam) {
|
||||
if(ActiveCamera !is null)
|
||||
PreviousCamera = ActiveCamera;
|
||||
|
||||
@ActiveCamera = cam;
|
||||
}
|
||||
|
||||
void copyPreviousCamera(SmartCamera@ cam) {
|
||||
if(ActiveCamera !is null)
|
||||
cam = ActiveCamera;
|
||||
else
|
||||
cam = PreviousCamera;
|
||||
}
|
||||
|
||||
vec3d mouseToGrid(vec2i mpos) {
|
||||
double plane = getAverageElevation();
|
||||
vec3d dest;
|
||||
line3dd ray = ActiveCamera.screenToRay(mpos);
|
||||
if(!getElevationIntersect(ray, dest))
|
||||
ray.intersectY(dest, plane, false);
|
||||
return dest;
|
||||
}
|
||||
|
||||
vec3d mouseToGrid(vec2i mpos, double plane) {
|
||||
vec3d dest;
|
||||
line3dd ray = ActiveCamera.screenToRay(mpos);
|
||||
if(!getElevationIntersect(ray, dest))
|
||||
ray.intersectY(dest, plane, false);
|
||||
return dest;
|
||||
}
|
||||
|
||||
void take_screenshot(bool pressed) {
|
||||
if(!pressed)
|
||||
takeScreenshot("screenshot");
|
||||
}
|
||||
|
||||
//Called when the platform overlay (e.g. Steam Overlay) is opened or closed
|
||||
double prevGameSpeed = 1.0;
|
||||
void onOverlayChanged(bool overlayOpen) {
|
||||
if(!mpServer && !mpClient) {
|
||||
if(overlayOpen) {
|
||||
prevGameSpeed = gameSpeed;
|
||||
gameSpeed = 0.0;
|
||||
}
|
||||
else {
|
||||
gameSpeed = prevGameSpeed;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Called whenever the mouse wheel is used on the 3D view.
|
||||
// x: Amount scrolled horizontally.
|
||||
// y: Amount scrolled vertically.
|
||||
void onMouseWheel(double x, double y) {
|
||||
if(isGuiHovered() || ActiveCamera is null) {
|
||||
MouseEvent evt;
|
||||
evt.type = MET_Scrolled;
|
||||
evt.x = int(floor(x));
|
||||
evt.y = int(floor(y));
|
||||
onMouseEvent(evt);
|
||||
return;
|
||||
}
|
||||
|
||||
if(targetMouseWheel(x, y))
|
||||
return;
|
||||
|
||||
activeCamera.zoom(y);
|
||||
}
|
||||
|
||||
//Called when the mouse is dragged with one or more buttons
|
||||
//pressed on the 3D view.
|
||||
// buttons: Bitmask of pressed buttons (0x1 << button_num)
|
||||
// x: Mouse x position.
|
||||
// y: Mouse y position.
|
||||
// dx: Movement in the x dimension since last event.
|
||||
// dy: Movement in the y dimension since last event.
|
||||
void onMouseDragged(int buttons, int x, int y, int dx, int dy) {
|
||||
if(activeCamera is null)
|
||||
return;
|
||||
if(targetMouseDragged(buttons, x, y, dx, dy))
|
||||
return;
|
||||
|
||||
Camera@ cam = activeCamera.camera;
|
||||
vec2i screen = screenSize;
|
||||
|
||||
if(buttons == 0x1) {
|
||||
doingBoxSelect = true;
|
||||
dragArea += vec2i(dx,-dy);
|
||||
dragFrom = vec2i(x,y);
|
||||
}
|
||||
else if(buttons == 0x2) {
|
||||
double dist = sqrt(sqr(double(x)/double(screen.x) - 0.5)
|
||||
+ sqr(double(y)/double(screen.y) - 0.5));
|
||||
|
||||
if(settings::bEdgeRoll && rollBorder < dist) {
|
||||
if(x < screen.x / 2)
|
||||
activeCamera.roll(dy);
|
||||
else
|
||||
activeCamera.roll(-dy);
|
||||
}
|
||||
else {
|
||||
activeCamera.rotate(dx, dy);
|
||||
}
|
||||
}
|
||||
else if(buttons == 0x3) {
|
||||
//-- Left and right buttons
|
||||
if(settings::bInvertHorizRot)
|
||||
dx = -dx;
|
||||
|
||||
//Horizontal movement does an absolute yaw
|
||||
if(cam.inverted)
|
||||
cam.abs_yaw(double(-dx) * camAnglesPerPixel);
|
||||
else
|
||||
cam.abs_yaw(double(dx) * camAnglesPerPixel);
|
||||
|
||||
//Vertical movement zooms
|
||||
cam.zoom(1.0 + zoomPerPixel * double(-dy));
|
||||
CAM_ZOOMED = true;
|
||||
}
|
||||
else if(buttons == 0x4) {
|
||||
//-- Only middle button
|
||||
//Pan the world
|
||||
activeCamera.pan(dx, dy);
|
||||
}
|
||||
}
|
||||
|
||||
//Called when a drag event thas ended
|
||||
bool onMouseDragEnd(int button) {
|
||||
if(targetMouseDragEnd(button))
|
||||
return true;
|
||||
if(doingBoxSelect) {
|
||||
if(button != 0) {
|
||||
doingBoxSelect = false;
|
||||
return false;
|
||||
}
|
||||
recti box = recti_area(dragFrom, dragArea);
|
||||
|
||||
//Make sure the rect is oriented top-down, left-right
|
||||
if(box.topLeft.x > box.botRight.x) {
|
||||
int temp = box.topLeft.x;
|
||||
box.topLeft.x = box.botRight.x;
|
||||
box.botRight.x = temp;
|
||||
}
|
||||
if(box.topLeft.y > box.botRight.y) {
|
||||
int temp = box.topLeft.y;
|
||||
box.topLeft.y = box.botRight.y;
|
||||
box.botRight.y = temp;
|
||||
}
|
||||
|
||||
dragSelect(box);
|
||||
|
||||
//Place the cursor to the dragged destination
|
||||
doingBoxSelect = false;
|
||||
mousePos = dragFrom + dragArea;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
//Called when the mouse is moved over the 3d view without
|
||||
//any buttons being held.
|
||||
// x: Mouse x position.
|
||||
// y: Mouse y position.
|
||||
void onMouseMoved(int x, int y) {
|
||||
MouseEvent evt;
|
||||
evt.type = MET_Moved;
|
||||
evt.x = x;
|
||||
evt.y = y;
|
||||
if(onMouseEvent(evt))
|
||||
return;
|
||||
if(targetMouseMoved(x, y))
|
||||
return;
|
||||
}
|
||||
|
||||
//Called when a mouse button is clicked
|
||||
// buttons: Button that was clicked.
|
||||
//void onMouseClicked(int button) {
|
||||
//}
|
||||
|
||||
//Called when a mouse button is double-clicked
|
||||
// buttons: Button that was clicked.
|
||||
//void onMouseDoubleClicked(int button) {
|
||||
//}
|
||||
|
||||
//General handler for when a mouse button event occurs
|
||||
// button: Button that the event pertains to.
|
||||
// pressed: Whether the button was pressed or released.
|
||||
bool onMouseButton(int button, bool pressed) {
|
||||
MouseEvent evt;
|
||||
if(pressed)
|
||||
evt.type = MET_Button_Down;
|
||||
else
|
||||
evt.type = MET_Button_Up;
|
||||
evt.button = button;
|
||||
vec2i mpos = mousePos;
|
||||
evt.x = mpos.x;
|
||||
evt.y = mpos.y;
|
||||
|
||||
bool fromTarget = uiObject !is null;
|
||||
if(fromTarget && targetMouseButton(button, pressed))
|
||||
return false;
|
||||
if(onMouseEvent(evt))
|
||||
return true;
|
||||
if(!fromTarget && targetMouseButton(button, pressed))
|
||||
return false;
|
||||
if(pressed)
|
||||
dragArea = vec2i(0,0);
|
||||
selectionClick(button, pressed);
|
||||
return false;
|
||||
}
|
||||
|
||||
//Called when a unicode char is typed into the main 3D view.
|
||||
// chr: Unicode code point that was typed.
|
||||
bool onCharTyped(int chr) {
|
||||
KeyboardEvent evt;
|
||||
evt.type = KET_Key_Typed;
|
||||
evt.key = chr;
|
||||
return onKeyboardEvent(evt);
|
||||
}
|
||||
|
||||
//Called when a key event occurs when the 3D view has focus.
|
||||
// key: Keyboard key that was pressed.
|
||||
// pressed: Whether the key was pressed or released.
|
||||
bool onKeyEvent(int key, int keyaction) {
|
||||
KeyboardEvent evt;
|
||||
bool pressed = (keyaction & KA_Pressed) != 0;
|
||||
if(pressed)
|
||||
evt.type = KET_Key_Down;
|
||||
else
|
||||
evt.type = KET_Key_Up;
|
||||
evt.key = key;
|
||||
if(onKeyboardEvent(evt))
|
||||
return true;
|
||||
if(objectKeyEvent(key, pressed))
|
||||
return true;
|
||||
if(targetKeyEvent(key, pressed))
|
||||
return true;
|
||||
if(pressed && key == KEY_ESC) {
|
||||
if(tabEscape())
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
uint[] worldMove = {0, 0, 0, 0};
|
||||
void world_forward(bool pressed) {
|
||||
worldMove[3] = pressed ? 1 : 0;
|
||||
}
|
||||
|
||||
void world_left(bool pressed) {
|
||||
worldMove[0] = pressed ? 1 : 0;
|
||||
}
|
||||
|
||||
void world_right(bool pressed) {
|
||||
worldMove[2] = pressed ? 1 : 0;
|
||||
}
|
||||
|
||||
void world_backward(bool pressed) {
|
||||
worldMove[1] = pressed ? 1 : 0;
|
||||
}
|
||||
|
||||
void reset_cam(bool pressed) {
|
||||
if(!pressed && activeCamera !is null) {
|
||||
Camera@ cam = activeCamera.camera;
|
||||
activeCamera.reset();
|
||||
Object@ hw = playerEmpire.Homeworld;
|
||||
if(hw is null)
|
||||
@hw = selectedObject;
|
||||
if(hw !is null)
|
||||
activeCamera.zoomTo(hw);
|
||||
else
|
||||
activeCamera.zoomTo(vec3d());
|
||||
cam.snap();
|
||||
}
|
||||
}
|
||||
|
||||
uint[] zoom = {0, 0};
|
||||
void zoom_in(bool pressed) {
|
||||
zoom[0] = pressed ? 1 : 0;
|
||||
}
|
||||
|
||||
void zoom_out(bool pressed) {
|
||||
zoom[1] = pressed ? 1 : 0;
|
||||
}
|
||||
|
||||
void zoom_object(bool pressed) {
|
||||
if(!pressed && ActiveCamera !is null) {
|
||||
Object@ sel = selectedObject;
|
||||
if(sel !is null && sel.visible)
|
||||
ActiveCamera.zoomLockObject(sel);
|
||||
}
|
||||
}
|
||||
|
||||
double threshold(double x, double thresh) {
|
||||
if(abs(x) < thresh)
|
||||
return 0.0;
|
||||
else
|
||||
return x;
|
||||
}
|
||||
|
||||
bool leftCannon = false;
|
||||
bool movePressed = false;
|
||||
|
||||
void onControllerButton(int i, bool pressed) {
|
||||
joystickActive = true;
|
||||
if(pressed) {
|
||||
if(i == GP_LB)
|
||||
switchToTab(-1);
|
||||
else if(i == GP_RB)
|
||||
switchToTab(+1);
|
||||
}
|
||||
}
|
||||
|
||||
GuiEvent joyGuiEvent;
|
||||
|
||||
vec3d lastAIFocus;
|
||||
|
||||
void tick(double time) {
|
||||
if(game_state != GS_Game)
|
||||
return;
|
||||
|
||||
if(FollowAI.value != 0) {
|
||||
vec3d to = playerEmpire.aiFocus;
|
||||
if(to != lastAIFocus) {
|
||||
activeCamera.zoomTo(to);
|
||||
lastAIFocus = to;
|
||||
}
|
||||
}
|
||||
|
||||
double tickMotion = time * camMotionPerSecond * 60.0;
|
||||
|
||||
//Polling a disconnected joystick on Windows takes ~10ms, so avoid it
|
||||
if(joystickConnected && joystick.poll()) {
|
||||
//Send buttons to gui
|
||||
for(uint i = 0, cnt = joystick.buttonCount; i < cnt; ++i) {
|
||||
uint8 state = joystick.button[i];
|
||||
if(state == JBS_Pressed) {
|
||||
//GUI Event
|
||||
joyGuiEvent.type = GUI_Controller_Down;
|
||||
joyGuiEvent.value = i;
|
||||
@joyGuiEvent.caller = getGuiFocus();
|
||||
if(!onGuiEvent(joyGuiEvent))
|
||||
onControllerButton(i, true);
|
||||
}
|
||||
else if(state == JBS_Released) {
|
||||
//GUI Event
|
||||
joyGuiEvent.type = GUI_Controller_Up;
|
||||
joyGuiEvent.value = i;
|
||||
@joyGuiEvent.caller = getGuiFocus();
|
||||
if(!onGuiEvent(joyGuiEvent))
|
||||
onControllerButton(i, false);
|
||||
}
|
||||
}
|
||||
|
||||
if(activeCamera !is null) {
|
||||
//Panning with left analog
|
||||
vec2d pan = vec2d(-joystick.axis[GP_AXIS_LX], joystick.axis[GP_AXIS_LY]);
|
||||
if(pan.length > 0.05) {
|
||||
pan.normalize(tickMotion * 0.7);
|
||||
activeCamera.pan(pan);
|
||||
mousePos = screenSize * 0.5;
|
||||
joystickActive = true;
|
||||
}
|
||||
|
||||
//Zoom and rotate with right analog
|
||||
double zoom = -joystick.axis[GP_AXIS_RY];
|
||||
if(abs(zoom) > 0)
|
||||
activeCamera.camera.zoom(1.0 + 7.0 * zoomPerSecond * zoom * time * settings::dZoomSpeed);
|
||||
|
||||
double yaw = -joystick.axis[GP_AXIS_RX];
|
||||
if(abs(yaw) > 0)
|
||||
activeCamera.rotate(600.0 * yaw * time, 0);
|
||||
}
|
||||
else {
|
||||
//Navigate gui with left stick
|
||||
vec2d dir = vec2d(joystick.axis[GP_AXIS_LX], -joystick.axis[GP_AXIS_LY]);
|
||||
if(dir.length > 0.25) {
|
||||
if(!movePressed)
|
||||
onGuiNavigate(dir);
|
||||
movePressed = true;
|
||||
}
|
||||
else {
|
||||
movePressed = false;
|
||||
}
|
||||
}
|
||||
|
||||
/*for(uint i = 0; i < joystick.buttonCount; ++i) {
|
||||
uint8 state = joystick.button[i];
|
||||
if(state == JBS_Pressed)
|
||||
print("Joystick 1, key " + i + " pressed");
|
||||
else if(state == JBS_Released)
|
||||
print("Joystick 1, key " + i + " released");
|
||||
}
|
||||
|
||||
for(uint i = 0; i < joystick.axisCount; ++i) {
|
||||
double axis = joystick.axis[i];
|
||||
if(abs(axis) > 0.01)
|
||||
print("Joystick axis " + i + ": " + axis);
|
||||
}*/
|
||||
|
||||
if(joystickActive)
|
||||
updateHoveredObject();
|
||||
}
|
||||
|
||||
if(activeCamera is null)
|
||||
return;
|
||||
|
||||
Camera@ cam = activeCamera.camera;
|
||||
bool inverted = cam.inverted;
|
||||
|
||||
vec2d move;
|
||||
|
||||
//Handle edge panning
|
||||
vec2i mouse = mousePos;
|
||||
if(settings::bEdgePan && windowFocused && mouseOverWindow) {
|
||||
vec2i screen = screenSize;
|
||||
|
||||
if(mouse.x <= 0) {
|
||||
edgePanTimers[0] += time;
|
||||
if(edgePanTimers[0] >= edgePanDelay[0]) {
|
||||
move.x += 1;
|
||||
if(edgePanRampup[0] > 0)
|
||||
tickMotion *= clamp((edgePanTimers[0] - edgePanDelay[0]) / edgePanRampup[0], 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
else {
|
||||
edgePanTimers[0] = 0.0;
|
||||
}
|
||||
|
||||
if(mouse.x >= screen.x - 2) {
|
||||
edgePanTimers[1] += time;
|
||||
if(edgePanTimers[1] >= edgePanDelay[1]) {
|
||||
move.x -= 1;
|
||||
if(edgePanRampup[1] > 0)
|
||||
tickMotion *= clamp((edgePanTimers[1] - edgePanDelay[1]) / edgePanRampup[1], 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
else {
|
||||
edgePanTimers[1] = 0.0;
|
||||
}
|
||||
|
||||
if(mouse.y <= 0) {
|
||||
edgePanTimers[2] += time;
|
||||
if(edgePanTimers[2] >= edgePanDelay[2]) {
|
||||
move.y += 1;
|
||||
if(edgePanRampup[2] > 0)
|
||||
tickMotion *= clamp((edgePanTimers[2] - edgePanDelay[2]) / edgePanRampup[2], 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
else {
|
||||
edgePanTimers[2] = 0.0;
|
||||
}
|
||||
|
||||
if(mouse.y >= screen.y - 2) {
|
||||
edgePanTimers[3] += time;
|
||||
if(edgePanTimers[3] >= edgePanDelay[3]) {
|
||||
move.y -= 1;
|
||||
if(edgePanRampup[0] > 0)
|
||||
tickMotion *= clamp((edgePanTimers[3] - edgePanDelay[3]) / edgePanRampup[3], 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
else {
|
||||
edgePanTimers[3] = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
//Move the world in the direction the keys were pressed
|
||||
if(worldMove[0] ^ worldMove[2] != 0) {
|
||||
if(worldMove[0] != 0)
|
||||
move.x += 1;
|
||||
else
|
||||
move.x += -1;
|
||||
}
|
||||
if(worldMove[1] ^ worldMove[3] != 0) {
|
||||
if(worldMove[1] != 0)
|
||||
move.y += -1;
|
||||
else
|
||||
move.y += 1;
|
||||
}
|
||||
|
||||
if(move.x != 0 || move.y != 0) {
|
||||
move.normalize(tickMotion);
|
||||
activeCamera.pan(move);
|
||||
}
|
||||
|
||||
//Zoom the camera appropriately
|
||||
if(zoom[0] ^ zoom[1] != 0) {
|
||||
if(zoom[0] != 0)
|
||||
cam.zoom(1.0 - zoomPerSecond * time * settings::dZoomSpeed);
|
||||
else
|
||||
cam.zoom(1.0 + zoomPerSecond * time * settings::dZoomSpeed);
|
||||
}
|
||||
}
|
||||
|
||||
void init() {
|
||||
keybinds::Global.addBind(KB_WORLD_FORWARD, "world_forward");
|
||||
keybinds::Global.addBind(KB_WORLD_LEFT, "world_left");
|
||||
keybinds::Global.addBind(KB_WORLD_RIGHT, "world_right");
|
||||
keybinds::Global.addBind(KB_WORLD_BACKWARD, "world_backward");
|
||||
|
||||
keybinds::Global.addBind(KB_ZOOM_IN, "zoom_in");
|
||||
keybinds::Global.addBind(KB_ZOOM_OUT, "zoom_out");
|
||||
|
||||
keybinds::Global.addBind(KB_RESET_CAM, "reset_cam");
|
||||
keybinds::Global.addBind(KB_TAKE_SCREENSHOT, "take_screenshot");
|
||||
|
||||
keybinds::Global.addBind(KB_ZOOM_LOCK_OBJECT, "zoom_object");
|
||||
|
||||
//joystickConnected = joystick.connected();
|
||||
PreviousCamera.reset();
|
||||
|
||||
if(settings::bDelayTopEdge) {
|
||||
edgePanDelay[2] = 0.3;
|
||||
edgePanRampup[2] = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
void draw() {
|
||||
if(doingBoxSelect)
|
||||
drawRectangle(recti_area(dragFrom, dragArea), Color(0x00ff0040));
|
||||
}
|
||||
Reference in New Issue
Block a user