private void RenderAllTilesFromLayer(Coordinate topLeft, Coordinate bottomRight, string currentLayer)
{
int tileData;
int tileSetIndex;
string tileSetSource;
Coordinate drawPosition;
for (int y = (int)topLeft.y; y <= bottomRight.y; y++)
{
for (int x = (int)topLeft.x; x <= bottomRight.x; x++)
{
tileData = FindDataAtPosition(x, y, currentLayer);
if (tileData > 0)
{
tileSetIndex = FindSourceTileSetFor(tileData);
tileData = tileData - mapMetaData.tilesets[tileSetIndex].firstgid + 0;
tileSetSource = mapMetaData.tilesets[tileSetIndex].source;
SetTextureTileSubRect(tileData, tileSetSource);
drawPosition.x = x * mapMetaData.tilewidth;
drawPosition.y = y * mapMetaData.tileheight;
drawPosition = CurrentCamera.ConvertMapToScreenCoordinate(drawPosition);
tileTextures[tileSetSource].RenderAtPosition((int)drawPosition.x, (int)drawPosition.y);
}
}
}
}
public void CloneWater(float viewportX, Vector2 origin)
{
Vector2 p = origin * CurrentCamera.GetXZoom();
int viewportSizeX = Mathf.FloorToInt(viewportX * CurrentCamera.GetXZoom());
Vector2 vecMin = Convertion.Location2World(p) * -1;
Vector2 vecMax = Convertion.Location2World(new Vector2(p.x * -1 + viewportSizeX, p.y));
if (vecMin.x < 0)
{
i = (int)Mathf.Abs(vecMin.x / Chunk.size) + 1;
i *= Chunk.size;
foreach (Tuple <int, int> block in listLiquid)
{
if (block.Item1 > width - i)
{
Liquid.listMap[type].SetCell(block.Item1 - width - 1, height - block.Item2, map[block.Item1, block.Item2]);
}
}
}
if (vecMax.x >= World.size * Chunk.size)
{
i = (int)Mathf.Abs((vecMax.x - Chunk.size * World.size) / Chunk.size) + 1;
i *= Chunk.size;
foreach (Tuple <int, int> block in listLiquid)
{
if (block.Item1 < i)
{
Liquid.listMap[type].SetCell(width + block.Item1 + 1, height - block.Item2, map[block.Item1, block.Item2]);
}
}
}
}
public override void _Process(float delta)
{
int viewportSizeX = Mathf.FloorToInt(GetViewport().Size.x *CurrentCamera.GetXZoom());
Vector2 p = GetViewportTransform().origin *CurrentCamera.GetXZoom();
float xdiff = viewportPos.x - p.x;
float ydiff = viewportPos.y - p.y;
/*Detection de teleportation a un seuil de 95%*/
if (Mathf.Abs(xdiff) >= 0.95f * World.size * Chunk.size * World.BlockTilemap.CellSize.x)
{
foreach (var s in childs)
{
s.Position = new Vector2(s.Position.x + xdiff, s.Position.y + ydiff * speed);
}
}
else
{
foreach (var s in childs)
{
s.Position = new Vector2(s.Position.x + xdiff * speed, s.Position.y + ydiff * speed);
if (s.Position.x + texture.GetSize().x / 2 < -p.x)
{
s.Position = new Vector2(s.Position.x + texture.GetSize().x *2, s.Position.y);
}
if (s.Position.x - texture.GetSize().x / 2 > (-p.x) + viewportSizeX)
{
s.Position = new Vector2(s.Position.x - texture.GetSize().x *2, s.Position.y);
}
}
}
viewportPos = GetViewportTransform().origin *CurrentCamera.GetXZoom();
}
protected override void OnUpdate(GameTime gameTime)
{
MouseState State = Mouse.GetState();
if (State.LeftButton == ButtonState.Pressed && OldState.LeftButton != ButtonState.Pressed)
{
var Entity = SceneManager.ActiveScene.GetEntityAtPosition(new Point(State.X + (int)Player.Camera.Position.X, State.Y + (int)Player.Camera.Position.Y));
if (Entity != null)
{
if (!CurrentCamera.IsDisposed)
{
CurrentCamera.Dispose();
}
CurrentCamera = new ChaseCameraComponent(Player.Camera);
Entity.Components.Add(CurrentCamera);
}
}
if (State.RightButton == ButtonState.Pressed && OldState.RightButton != ButtonState.Pressed)
{
var Entity = SceneManager.ActiveScene.GetEntityAtPosition(new Point(State.X + (int)Player.Camera.Position.X, State.Y + (int)Player.Camera.Position.Y));
if (Entity != null)
{
foreach (var OtherEntity in SceneManager.ActiveScene.Entities.ToArray())
{
if (OtherEntity != Entity && !CorvusGame.Instance.Players.Any(c => c.Character == OtherEntity))
{
OtherEntity.Dispose();
}
}
}
}
}
// Set the currently selected camera
public static void SetCurrentCamera(int id)
{
// Before setting the new camera make sure to deselect the old one
CurrentCamera.Deselect();
CurrentCamera = Cameras[id];
CurrentCamera.Select();
}
public void Render(IRenderer renderer)
{
//AE August 2015: We need to tell the shaders
if (_isDirty)
{
//retrieve a list of lights for each type
var pointLights = _lights.Where(l => l.GetType() == typeof(PointLight));
var directionalLights = _lights.Where(l => l.GetType() == typeof(DirectionalLight));
//reset the indexes
int index = 0;
foreach (var l in pointLights)
{
l.Index = index++;
}
index = 0;
foreach (var l in directionalLights)
{
l.Index = index++;
}
//reset the counters
renderer.SetNumericParameter("activeNumberOfPointLights", pointLights.Count());
renderer.SetNumericParameter("activeNumberOfDirectionalLights", directionalLights.Count());
_isDirty = false;
}
CurrentCamera.Render(renderer);
_lights.ForEach(l => l.Render(renderer));
_shapes.ForEach(s => s.Render(renderer));
}
protected override void OnResize(EventArgs e)
{
GL.Viewport(0, 0, Width, Height);
CurrentCamera.Resize(Width, Height);
base.OnResize(e);
}
/// <summary>
/// Use WASD tp change the position, rotation, fov of camera
/// </summary>
private void UpdateCameraPosition()
{
//if (ChangingCameraPosition)
//{
if (CurrentCamera != null)
{
if (IsChangingFOV) //Control fov
{
CurrentCamera.GetComponent <UnityEngine.Camera>().fieldOfView += Input.InputControl.GetAxis(Input.Controls.Global.GetAxes().cameraLateral);
//Limit fov to range from 0 to 180
float fov = CurrentCamera.GetComponent <UnityEngine.Camera>().fieldOfView;
if (fov > 179)
{
fov = 179; //Not quite 180 because at 180 it has this weird circle thing
}
else if (fov < 0)
{
fov = 0;
}
CurrentCamera.GetComponent <UnityEngine.Camera>().fieldOfView = fov;
}
else if (IsShowingAngle) //Control rotation (only when the angle panel is active)
{
CurrentCamera.transform.Rotate(new Vector3(-Input.InputControl.GetAxis(Input.Controls.Global.GetAxes().cameraLateral) * rotationSpeed, Input.InputControl.GetAxis(Input.Controls.Global.GetAxes().cameraForward) * rotationSpeed, 0) * Time.deltaTime);
}
CurrentCamera.GetComponent <RobotCamera>().UpdateConfiguration();
}
//}
}
// Use this for initialization
void Start()
{
mousehook = this;
overButton = false;
didBack = false;
dragging = false;
keepDetails = false;
//gameCam = GetComponentInParent<Camera>();
heldSpriteRenderer = GetComponent <SpriteRenderer>();
UICaster = GetComponentInParent <GraphicRaycaster>();
UIEventSystem = GetComponentInParent <EventSystem>();
player = transform.parent.GetComponentInChildren <Player>();
//transform.parent = null;
camHandle = gameCam.transform.parent;
gridOverlays = new List <HexHighlighter>();
currentCamera = CurrentCamera.main;
UIMask = 1 << 5;
mouseCheck = new int[3];
zoomLevel = 10;
hexWidth = Mathf.Sqrt(3) * hexSize;
UIHits = new List <RaycastResult>();
UIEvent = new PointerEventData(UIEventSystem);
UIEvent.position = Input.mousePosition;
showingRange = false;
overHeadLight.SetActive(false);
Vector3 camPos = gameCam.transform.localPosition;
camPos.z = Mathf.Clamp(camPos.z, -40, -2.5f);
camPos.y = Mathf.Clamp(camPos.y, 5f, 20);
gameCam.transform.localPosition = camPos;
}
private void resumePreview(bool i)
{
PreviewIsForbidden = false;
if (CurrentCamera != null)
{
CurrentCamera.startUpdatePTZ();
}
}
private void pausePreview(bool i)
{
PreviewIsForbidden = true;
if (CurrentCamera != null)
{
CurrentCamera.stopUpdatePTZ();
}
}
private void cameraPropertyValueAuto_CheckedChanged(Object sender, EventArgs e)
{
if (CameraPropertyControlInitializationComplete)
{
CameraPropertyValue value = new CameraPropertyValue(IsCameraPropertyValueTypePercentage, CameraPropertyValue, IsCameraPropertyAuto);
CurrentCamera.SetCameraProperty(SelectedCameraProperty, value);
}
}
private void UpdateCameraPropertyRange(CameraPropertyCapabilities propertyCapabilities)
{
String text;
if (IsSelectedCameraPropertySupported && propertyCapabilities.IsGetRangeSupported && propertyCapabilities.IsGetSupported)
{
CameraPropertyRange range = CurrentCamera.GetCameraPropertyRange(SelectedCameraProperty);
text = String.Format("[ {0}, {1} ], step: {2}", range.Minimum, range.Maximum, range.Step);
Int32 decimalPlaces;
Decimal minimum, maximum, increment;
if (IsCameraPropertyValueTypeValue)
{
minimum = range.Minimum;
maximum = range.Maximum;
increment = range.Step;
decimalPlaces = 0;
}
else if (IsCameraPropertyValueTypePercentage)
{
minimum = 0;
maximum = 100;
increment = 0.01M;
decimalPlaces = 2;
}
else
{
throw new NotSupportedException(String.Format("Camera property value type '{0}' is not supported.", ( String )cameraPropertyValueTypeSelection.SelectedItem));
}
cameraPropertyValueValue.Minimum = minimum;
cameraPropertyValueValue.Maximum = maximum;
cameraPropertyValueValue.Increment = increment;
cameraPropertyValueValue.DecimalPlaces = decimalPlaces;
if (CurrentCameraPropertyRanges.ContainsKey(SelectedCameraProperty))
{
CurrentCameraPropertyRanges[SelectedCameraProperty] = range;
}
else
{
CurrentCameraPropertyRanges.Add(SelectedCameraProperty, range);
}
CameraPropertyValue value = CurrentCamera.GetCameraProperty(SelectedCameraProperty, IsCameraPropertyValueTypeValue);
SuppressCameraPropertyValueValueChangedEvent = true;
cameraPropertyValueValue.Value = value.Value;
cameraPropertyValueAuto.Checked = value.IsAuto;
SuppressCameraPropertyValueValueChangedEvent = false;
}
else
{
text = "N/A";
}
cameraPropertyRangeValue.Text = text;
}
private void cameraPropertyValueValue_EnabledChanged(Object sender, EventArgs e)
{
if (CameraPropertyControlInitializationComplete && !SuppressCameraPropertyValueValueChangedEvent && cameraPropertyValueValue.Enabled)
{
CameraPropertyValue value = CurrentCamera.GetCameraProperty(SelectedCameraProperty, IsCameraPropertyValueTypeValue);
cameraPropertyValueValue.Value = value.Value;
cameraPropertyValueAuto.Checked = value.IsAuto;
}
}
public override void _Process(float delta)
{
WorldScreenSizeX = GetViewport().Size.x *CurrentCamera.GetXZoom();
if (PlayerState.Is(PlayerState.State.Pause))
{
return;
}
timePlayed += delta;
}
public void SetCameraSetting(Packet.Type packetType, string setting, double value, bool bypassSkipCounter = false)
{
// If nothing has been recieved from QTM then update the settings
// else wait 200 ms before updating qtm again to Xamarin.Forms time to update
// and prevent an infinite feedback loop
if (Urho.Time.SystemTime - lastQTMUpdate > 200 && !ignoreSettingsAfterCameraSelection)
{
CurrentCamera.SetSetting(packetType, setting, value);
}
}
private void SetCameraMode(CameraMode mode)
{
cameraMode = mode;
CurrentCamera.SetMode(mode);
// Switch drawer scheme
if (QTMNetworkConnection.IsMaster)
{
SwitchDrawers(mode);
}
}
private void ChangeCamera(GameObject activeCamera, string cameraType, int cameraIndex)
{
if (CurrentCamera != null)
{
CurrentCamera.GetComponent <Camera>().enabled = false;
}
activeCamera.GetComponent <Camera>().enabled = true;
CurrentCamera = activeCamera;
CurrentCameraType = cameraType;
CurrentCameraIndex = cameraIndex;
}
protected void OnRender(object sender, FrameEventArgs e)
{
// Clear the back buffer
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
CurrentCamera.Render(SceneGraph);
// TODO: implement image effects: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/
// swap backbuffer
SwapBuffers();
}
private void cameraPropertyValue_SelectedIndexChanged(Object sender, EventArgs e)
{
if (CameraPropertyControlInitializationComplete)
{
IsSelectedCameraPropertySupported = CurrentCamera.IsCameraPropertySupported(SelectedCameraProperty);
CameraPropertyCapabilities propertyCapabilities = CurrentCameraPropertyCapabilities[SelectedCameraProperty];
UpdateCameraPropertyRange(propertyCapabilities);
cameraPropertyValueAuto.Enabled = cameraPropertyValueValue.Enabled = cameraPropertyValueTypeSelection.Enabled = IsSelectedCameraPropertySupported && propertyCapabilities.IsFullySupported;
}
}
private void ClearCameraPressed(BindState State)
{
if (State != BindState.Pressed)
{
return;
}
if (!CurrentCamera.IsDisposed)
{
CurrentCamera.Dispose();
}
Player.Character.Components.Add((CurrentCamera = new ChaseCameraComponent(Player.Camera)));
}
public override void _Ready()
{
Vector2 p = GetViewportTransform().origin *CurrentCamera.GetXZoom();
Vector2 vecMin = Convertion.Location2World(p) * -1;
prev_x_viewport = vecMin.x;
GetNode <Sprite>("OUTLINE").Material = (Material)GetNode <Sprite>("OUTLINE").Material.Duplicate();
GetNode <Timer>("TimerEnergy").WaitTime = 1.0f;
timerEnergyWaitTime = GetNode <Timer>("TimerEnergy").WaitTime;
timer = GetNode <Timer>("Timer");
}
public void SetCameraSetting(string setting, double value, bool bypassSkipCounter = false)
{
// If nothing has been recieved from QTM then update the settings
// If one or several events has been recieved skip updating QTM an decrement the counter
if (skipCounter == 0 || bypassSkipCounter)
{
CurrentCamera.SetSetting(setting, value);
}
else
{
skipCounter--;
}
}
public virtual void PointerWheelChanged(Vector2 deltaValue, GameTime gameTime)
{
bool res = UIWindowManager.PointerWheelChanged(deltaValue, gameTime);
if (res == false)
{
// Event was not handled by UI
res = CurrentController?.PointerWheelChanged(deltaValue) ?? false;
if (res == false)
{
CurrentCamera?.PointerWheelChanged(deltaValue);
}
}
}
public virtual bool KeyReleased(Keys key, GameTime gameTime)
{
bool res = UIWindowManager.KeyReleased(key, gameTime);
if (res == false)
{
// Event was not handled by UI
res = CurrentController?.KeyReleased(key) ?? false;
if (res == false)
{
CurrentCamera?.KeyReleased(key);
}
}
return(res);
}
public void DrawTargetLockon(Transform aimtarget, int type)
{
if (CurrentCamera != null)
{
Vector3 dir = (aimtarget.position - CurrentCamera.transform.position).normalized;
float direction = Vector3.Dot(dir, CurrentCamera.transform.forward);
if (direction > 0.5f)
{
Vector3 screenPos = CurrentCamera.WorldToScreenPoint(aimtarget.transform.position);
//float distance = Vector3.Distance (transform.position, aimtarget.transform.position);
GUI.DrawTexture(new Rect(screenPos.x - NavTexture [type].width / 2, Screen.height - screenPos.y - NavTexture [type].height / 2, NavTexture [type].width, NavTexture [type].height), NavTexture [type]);
}
}
}
public override void _Ready()
{
time = GetNode <Timer>("cooldown");
time2 = GetNode <Timer>("afterattack");
Enemy_fly = GetNode <Sprite>("Enemy_Fly");
Enemy_Die = GetNode <Sprite>("Enemy_Die");
proximity = GetNode <Area2D>("Detection");
anim = GetNode <AnimationPlayer>("AnimationEnemy");
anim.Play("Flying");
Enemies.enemiesCount++;
Vector2 p = GetViewportTransform().origin *CurrentCamera.GetXZoom();
Vector2 vecMin = Convertion.Location2World(p) * -1;
prev_x_viewport = vecMin.x;
}
/// <summary>
/// Use this function to resize the scene window, and also to look through
/// the current camera.
/// </summary>
/// <param name="width">Width of the screen.</param>
/// <param name="height">Height of the screen.</param>
public virtual void Resize(int width, int height)
{
if (width != -1 && height != -1 && gl != null)
{
// Resize.
gl.Viewport(0, 0, width, height);
if (CurrentCamera != null)
{
// Set aspect ratio.
CurrentCamera.AspectRatio = width / (float)height;
// Then project.
CurrentCamera.Project(gl);
}
}
}
public void acceptCamera(CameraInfo cam)
{
if (CurrentCamera != null)
{
CurrentCamera.stopUpdatePTZ();
}
CurrentCamera = cam;
if (!previewIsForbidden)
{
CurrentCamera.startUpdatePTZ();
}
Idle = Visibility.Hidden;
Active = Visibility.Visible;
SliderPan = Convert.ToInt32(CurrentCamera.Pan);
SliderTilt = Convert.ToInt32(currentCamera.Tilt);
UndoRedoManager.clear();
SliderZoom = Convert.ToInt32(CurrentCamera.Zoom);
}
protected override void OnUpdateFrame(FrameEventArgs e)
{
base.OnUpdateFrame(e);
CurrentCamera.Update();
var ProjectionMatrix = CurrentCamera.Projection;
var WorldMatrix = CurrentCamera.View;
var ModelViewMatrix = Matrix4.CreateTranslation(0.0f, 0.0f, 0.0f);
Matrix4 ModelViewProjection = ModelViewMatrix * WorldMatrix * ProjectionMatrix;
GL.UseProgram(mBasicShader.Program);
int mvpLocation = GL.GetUniformLocation(mBasicShader.Program, "mvp_matrix");
GL.UniformMatrix4(mvpLocation, false, ref ModelViewProjection);
GL.UseProgram(0);
}
