Nevar pievienot vairāk kā 25 tēmas
Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
1897 rindas
61 KiB
1897 rindas
61 KiB
require "bit"
|
|
|
|
MainCamera = MainCamera or BaseClass(BaseModel)
|
|
local MainCamera = MainCamera
|
|
local Scene = Scene
|
|
local GlobalEventSystem = GlobalEventSystem
|
|
local SceneEventType = SceneEventType
|
|
local IsTableEmpty = IsTableEmpty
|
|
local GameMath = GameMath
|
|
local Time = Time
|
|
local math_abs = math.abs
|
|
local math_sin = math.sin
|
|
local table_remove = table.remove
|
|
local table_insert = table.insert
|
|
local GameMath_Lerp = GameMath.Lerp
|
|
local ReleaseTemporary = UnityEngine.RenderTexture.ReleaseTemporary
|
|
local Clamp = Mathf.Clamp
|
|
|
|
--摄像机和主角的平面距离
|
|
CameraDistanceWithMainRole = 10.7
|
|
--摄像机可视范围
|
|
CameraDefaultFieldofView = 37
|
|
--摄像机和地面夹角
|
|
SceneCameraRotate = 40.0
|
|
--摄像机离地面高度
|
|
SceneCameraHeigth = 10.0
|
|
|
|
|
|
MainCamera.PixelsToUnits = 100 --像素坐标比例
|
|
MainCamera.SmoothMode = true --摄像机开启平滑
|
|
MainCamera.SmoothTime = 0.1 --摄像机平滑时间
|
|
MainCamera.ScreenCenterOffset = 0 --摄像机偏移主角位置像素值
|
|
MainCamera.ScreenScale = 1.1 --摄像机视窗缩放
|
|
MainCamera.SizeSmoothSpeed = 1 --摄像机缩放的时候的默认速度
|
|
MainCamera.SmoothState = { --摄像机缓动类型，对应着不同参数
|
|
Normal = 0,
|
|
Jump = 1,
|
|
Skill = 2,
|
|
Jump_Point = 3,
|
|
Horse = 4,
|
|
Speed_Buff = 5,
|
|
Quiz = 6,
|
|
NewBieTask = 7,
|
|
TaskJump = 8,
|
|
Flash = 9,
|
|
None = 10,
|
|
SpecialDun = 11,
|
|
JUMP_ONE = 12,
|
|
}
|
|
|
|
--摄像机旋转相关参数
|
|
MainCamera.role_last_angle = 0
|
|
MainCamera.role_cur_angle = 0
|
|
MainCamera.role_angle_off = 0
|
|
MainCamera.role_from_camera_angle = 0
|
|
MainCamera.role_last_rotate_area = false
|
|
MainCamera.camera_cur_angle = 0
|
|
MainCamera.camera_target_angle = 0
|
|
MainCamera.camera_enable_rotate = false
|
|
|
|
-------------------------------------高斯模糊相关-------------------------------------
|
|
-- 屏幕后处理预设
|
|
-- MainCamera.RenderEffectPreset = {
|
|
-- Grayed = {brightness = 1, saturation = 0, contrast = 1}, -- 灰化预设
|
|
-- }
|
|
-- 激活了后处理效果
|
|
-- MainCamera.Activiting_Render_Effect = false
|
|
-- 特效相机类型 默认情况下，黑白化只需要MainCamera，一般大界面（全屏显示）的高斯模糊只需要模糊UI摄像机
|
|
MainCamera.EffectCameraType = {
|
|
MainCamera = 0, -- 主场景摄像机
|
|
UICamera = 1, -- ui摄像机(由于渲染顺序的问题，只要处理了UI摄像机，主摄像机的画面效果也会被影响,后续处理中注意避免两个特效同时开启)
|
|
}
|
|
-- 激活了模糊效果
|
|
MainCamera.Activiting_Blur_Effect = false
|
|
MainCamera.FreeCameraViewOpened = false -- 是否打开了自由摄像机调试界面
|
|
function MainCamera:__init()
|
|
if MainCamera.Instance ~= nil then
|
|
LogError("MainCamera is a singleton class")
|
|
end
|
|
|
|
MainCamera.Instance = self
|
|
self.smoothTarget = nil
|
|
self.firstMove = true
|
|
self.rendering_blur_screenShot = false
|
|
self.round_robin_cache_list = {}
|
|
self.gameObject = GameObject.Find("root/MainCameraRoot") --3D中摄像机分成两个层级控制，ROOT中控制旋转和位置，Camera控制俯视角度以及摄像机与玩家的距离
|
|
if self.gameObject then
|
|
self.transform = self.gameObject.transform
|
|
self.camera_gameObject = GameObject.Find("root/MainCameraRoot/MainCamera")
|
|
self.camera = self.camera_gameObject:GetComponent("Camera") --这里用GetComponentInChildren总是报错不知道为啥
|
|
SetGlobalPosition(self.camera.transform, 0, 0, -CameraDistanceWithMainRole)
|
|
self.camera.backgroundColor = Color(0,0,0,0)
|
|
self.camera.farClipPlane = 1900
|
|
|
|
self.camera_base_size_original = ScreenHeight / MainCamera.PixelsToUnits * 0.5
|
|
self.camera_base_size = CameraDefaultFieldofView
|
|
self:SetCameraSize(60)
|
|
self.camera_curr_size = self.camera_base_size
|
|
self.uiCamera_gameObject=GameObject.Find("root/UICamera")
|
|
self.uiCamera=self.uiCamera_gameObject:GetComponent("Camera")
|
|
self.camera.fieldOfView = CameraDefaultFieldofView
|
|
|
|
--剧情动画摄像机
|
|
self.story_cam_obj = GameObject.Find("root/StoryCamera")
|
|
if self.story_cam_obj then
|
|
self.story_cam_obj:SetActive(false)
|
|
end
|
|
-- 剧情摄像机添加径向模糊
|
|
self.story_radiusBlur = self.story_cam_obj:AddComponent(typeof(RadiusBlur))
|
|
self.story_radiusBlur.enabled = false
|
|
self.story_radiusBlur.radius_material = ShaderTools.GetRadiusMaterial()
|
|
-- 添加径向模糊默认值
|
|
self:SetStoryCameraRadiusData(0.5, 0.5, 0.01)
|
|
self:SetStoryCameraRadiusIteration(10)
|
|
|
|
-- 高斯模糊摄像机
|
|
-- self.blurCamera_gameObject = GameObject.Find("root/BlurCamera")
|
|
-- self.blurCamera = self.blurCamera_gameObject:GetComponent("Camera")
|
|
-- 获取到摄像机后就隐藏起来
|
|
-- self.blurCamera.enabled = false
|
|
|
|
------------////////////////////////////
|
|
-- 整合屏幕后处理效果PostEffect
|
|
-- 目标的纹理降低采样率比率和迭代次数设置
|
|
self.main_blur_downSample_value = 4
|
|
self.ui_blur_downSample_value = 5
|
|
-- 主摄像机后处理
|
|
self:ApplyMainPostEffect()
|
|
|
|
-- UI摄像机后处理
|
|
-- if not self.ui_postEffect then
|
|
-- self.ui_postEffect = self.uiCamera_gameObject:GetComponent(typeof(PostEffect))
|
|
-- end
|
|
-- if not IsNull(self.ui_postEffect) then
|
|
-- -- if not self:IsSupportPostEffect() then
|
|
-- -- self.ui_postEffect.enabled = false
|
|
-- -- else
|
|
-- -- self.ui_postEffect.enabled = true
|
|
-- -- 设置FXAA参数
|
|
-- self.ui_postEffect.EnableFXAA = false
|
|
-- -- 设置泛光模糊参数
|
|
-- self.ui_postEffect.EnableBloom = false
|
|
-- -- 设置模糊参数
|
|
-- self.ui_postEffect.EnableBlur = true
|
|
-- self.ui_postEffect.recurveMaxNum = 4
|
|
-- self.ui_postEffect.blurSpread = 2
|
|
-- self.ui_postEffect.use_dual_blur = true
|
|
-- -- 应用数据到材质球
|
|
-- self.ui_postEffect:ApplyBloomMaterialProperties()
|
|
-- self.ui_postEffect:ApplyFXAAMaterialProperties()
|
|
-- -- end
|
|
-- end
|
|
-- 检测设备是否支持后处理
|
|
self:SetRenderSupport()
|
|
if not self.is_screen_effect_supported then
|
|
if not IsNull(self.main_postEffect) then
|
|
self.main_postEffect.enabled = false
|
|
end
|
|
-- if not IsNull(self.ui_postEffect) then
|
|
-- self.ui_postEffect.enabled = false
|
|
-- end
|
|
end
|
|
------------////////////////////////////
|
|
end
|
|
|
|
self.screen_obj_count = 0 --屏幕摄像机对象数量
|
|
self.is_update_camera = true
|
|
self.is_lock_camera = false --是否锁定摄像机
|
|
self.lock_camera_pos = false --锁定的位置
|
|
self.lock_move_speed = 0 --锁定的时候的移动速度
|
|
self.is_change_size = false --摄像机是否在改变大小
|
|
self.camera_move_speed = co.Vector2(0,0)
|
|
self.real_now_pos = co.Vector2(0,0)
|
|
self.orthographic_state = false --默认正交摄像机
|
|
self.rotate_around = 0
|
|
self.maxDistance = 2 --摄像机跟随的最大距离限制，超过这个距离就会达到最大速度也就是刚好跟着主角移动
|
|
self.maxSpeed = 0.2 --摄像机跟随移动的最大速度，需要大于等于人物的移动速度
|
|
self.isSmooth = MainCamera.SmoothMode
|
|
self.targetSmoothSpeed = self.maxSpeed
|
|
self.smoothState = MainCamera.SmoothState.Normal --相机平滑移动的状态，不同状态速度不同
|
|
self.can_scale_camera = true
|
|
|
|
self.shake_elements_list = {}
|
|
|
|
self.temp_pos = {x = 0,y = 0,z = 0}
|
|
self.temp_shake_pos = {x = 0,y = 0}
|
|
|
|
self.camera.transform.localRotation = Quaternion.Euler(SceneCameraRotate,0,0)
|
|
|
|
self.size_smooth_list ={}
|
|
self.is_showing_sky_res = false --是否正常显示全屏天空盒
|
|
self.cur_terrain_alpha = false
|
|
|
|
local function sceneChanged() ---在切换场景的时候，取消缓动效果
|
|
self.isSmoothing = false
|
|
if not SceneManager.Instance:IsPkRankFightScene() and self.smoothTarget and self.is_update_camera then
|
|
self.transform.position = self.smoothTarget --处理重复进入同一个场景的时候，比如切换角色但是选择的还是当前角色
|
|
self.size_smooth_list = {}
|
|
GlobalEventSystem:Fire(SceneEventType.CAMERA_MOVE)
|
|
end
|
|
local dun_id = SceneManager.Instance:GetCurrDunId()
|
|
local camera_config = Config.ConfigSceneCamera.LockDungeon[dun_id]
|
|
if camera_config then
|
|
local function on_set_camera_mode( )
|
|
local cur_dun_id = SceneManager.Instance:GetCurrDunId()
|
|
if cur_dun_id ~= dun_id then
|
|
return
|
|
end
|
|
self.use_special_camera = true
|
|
self:SetSpecialDunMode(camera_config)
|
|
MainCamera.camera_enable_rotate = false
|
|
end
|
|
if camera_config.is_delay then
|
|
setTimeout(on_set_camera_mode, 1)
|
|
else
|
|
on_set_camera_mode()
|
|
end
|
|
elseif self.use_special_camera then
|
|
self.use_special_camera = false
|
|
self:QuitSpecialDunMode()
|
|
end
|
|
self.block_smooth = false
|
|
print("MainCamera Load Complete")
|
|
self:HideBlackSky(self.black_sky_res)
|
|
end
|
|
local function ReEnter()
|
|
if SceneManager:getInstance():IsGemDungeon() or SceneManager:getInstance():IsGodHoodDungeon() then --这两个副本，在第一次进去的时候，不要无缝切换，第二次开始才无缝切换
|
|
self.size_smooth_list = {}
|
|
self.isSmoothing = false
|
|
self.block_smooth = true
|
|
GlobalEventSystem:Fire(SceneEventType.CAMERA_MOVE)
|
|
end
|
|
self:HideBlackSky(self.black_sky_res)
|
|
end
|
|
GlobalEventSystem:Bind(EventName.SCENE_LOAD_VIEW_COMPLETE,sceneChanged)
|
|
GlobalEventSystem:Bind(SceneEventType.SCENE_REENTER, ReEnter)
|
|
|
|
local load_call_back = function(objs)
|
|
if objs and objs[0] then
|
|
self.intoscene_effect = newObject(objs[0])
|
|
self.intoscene_effect.transform:SetParent(self.camera.transform)
|
|
|
|
self.intoscene_effect.transform.localEulerAngles = Vector3(0, 0, 0)
|
|
SetLocalPosition(self.intoscene_effect.transform,0)
|
|
|
|
self.intoscene_effect:SetActive(false)
|
|
end
|
|
end
|
|
|
|
local change_scene_particle = "camfx_scenetransform"
|
|
lua_resM:loadPrefab(self, change_scene_particle, change_scene_particle, load_call_back, nil, ASSETS_LEVEL.LOW)
|
|
|
|
local main_canvas_change = function( state )
|
|
if state then
|
|
self.isSmooth = MainCamera.SmoothMode
|
|
else
|
|
self.isSmooth = false
|
|
end
|
|
end
|
|
LuaViewManager.Instance:Bind(LuaViewManager.BOCAST_MAIN_CANVAS_LAST_STATE,main_canvas_change)
|
|
end
|
|
|
|
function MainCamera:getInstance()
|
|
if MainCamera.Instance == nil then
|
|
MainCamera.New()
|
|
end
|
|
return MainCamera.Instance
|
|
end
|
|
|
|
function MainCamera:ApplyMainPostEffect( )
|
|
self.is_login_post_effect_state = false
|
|
if not self.main_postEffect then
|
|
self.main_postEffect = self.camera_gameObject:GetComponent(typeof(PostEffect))
|
|
end
|
|
if not IsNull(self.main_postEffect) then
|
|
-- 主摄像机，高端设备上开泛光
|
|
if not self:IsSupportPostEffect() then
|
|
self.main_postEffect.enabled = false
|
|
else
|
|
self.main_postEffect.enabled = true
|
|
-- 设置泛光模糊参数
|
|
self.main_postEffect.EnableBloom = true
|
|
self.main_postEffect.threshold = 0.65
|
|
self.main_postEffect.intensity = 1.2
|
|
self.main_postEffect.blurSize = 1
|
|
self.main_postEffect.blurIterations = 1
|
|
self.main_postEffect.use_dual_bloom = true
|
|
-- 设置FXAA参数
|
|
self.main_postEffect.EnableFXAA = false
|
|
-- 设置模糊参数
|
|
self.main_postEffect.EnableBlur = false
|
|
-- 应用数据到材质球
|
|
self.main_postEffect:ApplyBloomMaterialProperties()
|
|
end
|
|
end
|
|
end
|
|
|
|
--登录镜头特殊处理
|
|
function MainCamera:ApplyLoginPostEffect( )
|
|
self.is_login_post_effect_state = true
|
|
local function on_login_effect( )
|
|
if not self.main_postEffect then
|
|
self.main_postEffect = self.camera_gameObject:GetComponent(typeof(PostEffect))
|
|
end
|
|
if not IsNull(self.main_postEffect) then
|
|
-- 主摄像机，中高端设备上开泛光
|
|
if SystemMemoryLevel.Cur == SystemMemoryLevel.Low then
|
|
self.main_postEffect.enabled = false
|
|
else
|
|
self.main_postEffect.enabled = true
|
|
-- 设置泛光模糊参数
|
|
self.main_postEffect.EnableBloom = true
|
|
self.main_postEffect.threshold = 0.8
|
|
self.main_postEffect.intensity = 2.64
|
|
self.main_postEffect.blurSize = 2.5
|
|
self.main_postEffect.blurIterations = 3
|
|
self.main_postEffect.use_dual_bloom = true
|
|
-- 设置FXAA参数
|
|
self.main_postEffect.EnableFXAA = false
|
|
-- 设置模糊参数
|
|
self.main_postEffect.EnableBlur = false
|
|
-- 应用数据到材质球
|
|
self.main_postEffect:ApplyBloomMaterialProperties()
|
|
end
|
|
end
|
|
end
|
|
on_login_effect()
|
|
setTimeout(on_login_effect, 0.1)
|
|
end
|
|
|
|
function MainCamera:ShowEnterSceneEffect()
|
|
-- 新手2002副本出来要衔接剧情，不用特效
|
|
local last_dun_id = SceneManager:getInstance():GetLastDunId()
|
|
if last_dun_id and last_dun_id == 2002 then
|
|
return
|
|
end
|
|
|
|
local hide_func = function()
|
|
if self.intoscene_effect then
|
|
self.intoscene_effect:SetActive(false)
|
|
self.effect_id = nil
|
|
end
|
|
end
|
|
if self.effect_id then
|
|
GlobalTimerQuest:CancelQuest(self.effect_id)
|
|
self.effect_id = nil
|
|
if self.intoscene_effect then
|
|
self.intoscene_effect:SetActive(false)
|
|
end
|
|
end
|
|
if self.intoscene_effect then
|
|
self.intoscene_effect:SetActive(true)
|
|
end
|
|
if not self.effect_id then
|
|
self.effect_id = GlobalTimerQuest:AddDelayQuest(hide_func,3)
|
|
end
|
|
end
|
|
|
|
function MainCamera:GetScreenEffectCamere()
|
|
if self.screen_effect_camera == nil then
|
|
self.screen_effect_camera = UiFactory.createChild(self.transform, UIType.Camera3D, "Camera3D")
|
|
self.screen_effect_camera.transform.localRotation = Quaternion.Euler(30,-90,0)
|
|
self.screen_effect_camera:SetActive(not lua_settingM:GetBlockProperty("scenePtc"))
|
|
end
|
|
return self.screen_effect_camera
|
|
end
|
|
|
|
function MainCamera:DestoryScreenEffectCamere()
|
|
if self.screen_effect_camera then
|
|
destroy(self.screen_effect_camera)
|
|
self.screen_effect_camera = nil
|
|
end
|
|
end
|
|
|
|
function MainCamera:SetScreenEffectCamereState( state )
|
|
if self.screen_effect_camera then
|
|
self.screen_effect_camera:SetActive(state)
|
|
end
|
|
end
|
|
|
|
--[[设置摄像机的视野范围 注意：修改的参数是 fieldOfView 而不是transform的scale或者位置
|
|
size 需要的目标大小
|
|
isSmooth 是否平滑过渡，如果否，将会取消当前的平滑列表（如果正在平滑过程中）
|
|
]]
|
|
function MainCamera:SetCameraSize(size, isSmooth)
|
|
|
|
|
|
if self.camera.fieldOfView == size then
|
|
return
|
|
end
|
|
|
|
if isSmooth then
|
|
if not self.size_smooth_list then
|
|
self.size_smooth_list = {}
|
|
end
|
|
table_insert(self.size_smooth_list,size)
|
|
else
|
|
self.size_smooth_list = nil
|
|
self.size_smooth_list = {}
|
|
self.camera_curr_size = size
|
|
self.camera.fieldOfView = size
|
|
|
|
if self.screencamera then
|
|
self.screencamera.fieldOfView = size
|
|
end
|
|
end
|
|
-- if Scene.Instance and not specialScene then
|
|
-- local now_pos = self.real_now_pos
|
|
-- local cam_scale = MainCamera.ScreenScale * size / self.camera_base_size
|
|
|
|
-- local half_target_width = SrcScreenWidth * cam_scale / 2
|
|
-- local half_target_height = ScreenHeight * cam_scale / 2
|
|
-- local scene_size = Scene.Instance:GetSceneSize()
|
|
-- local scene_width = scene_size.x - half_target_width
|
|
-- local scene_height = scene_size.y - half_target_height
|
|
|
|
-- if half_target_width < scene_width then
|
|
-- if now_pos.x < half_target_width then
|
|
-- return
|
|
-- elseif now_pos.x > scene_width then
|
|
-- return
|
|
-- end
|
|
-- else
|
|
-- return
|
|
-- end
|
|
-- if half_target_height < scene_height then
|
|
-- if now_pos.y < half_target_height then
|
|
-- return
|
|
-- elseif now_pos.y > scene_height then
|
|
-- return
|
|
-- end
|
|
-- else
|
|
-- return
|
|
-- end
|
|
-- end
|
|
GlobalEventSystem:Fire(SceneEventType.CAMERA_CHANGE_SIZE, self.camera_curr_size / self.camera_base_size)
|
|
-- if Scene.Instance and Scene.Instance.main_role then --3D项目就不用改变玩家模型大小了
|
|
-- local curr_scale = math.pow(self.camera_curr_size / self.camera_base_size, Config.otherFightInfo.mainrole_jump_scale)
|
|
-- if Scene.Instance.main_role.name_board then
|
|
-- Scene.Instance.main_role.name_board:SetScale(curr_scale)
|
|
-- end
|
|
-- Scene.Instance.main_role:SetScale(curr_scale)
|
|
-- end
|
|
end
|
|
|
|
function MainCamera:SetBaseCameraSize(size)
|
|
if not self.can_scale_camera then
|
|
return
|
|
end
|
|
|
|
self.camera_curr_size = size
|
|
self:SetCameraSize(size)
|
|
end
|
|
|
|
function MainCamera:GetCameraRatio()
|
|
-- return self.camera_curr_size / self.camera_base_size_original
|
|
return self.camera_curr_size / self.camera_base_size
|
|
end
|
|
|
|
function MainCamera:ScaleCamera( scale )
|
|
self:SetCameraSize(self.camera_base_size * scale)
|
|
end
|
|
|
|
function MainCamera:GetCameraPos()
|
|
return self.real_now_pos
|
|
end
|
|
|
|
function MainCamera:ScreenToWorldPoint( x, y )
|
|
return self.camera:ScreenToWorldPoint(Vector3(x,y,0))
|
|
end
|
|
|
|
function MainCamera:WorldToViewportPoint( x,y,z )
|
|
return Vector3(x - self.real_now_pos.x,y - self.real_now_pos.y,z) / MainCamera.ScreenScale
|
|
end
|
|
|
|
function MainCamera:WorldToScreenPoint( vect )
|
|
return self.camera:WorldToScreenPoint(vect)
|
|
end
|
|
|
|
function MainCamera:CameraBoundHandle(to_set_pos)
|
|
local now_pos = to_set_pos
|
|
local cam_scale = MainCamera.ScreenScale * self.camera_curr_size / self.camera_base_size
|
|
|
|
local half_target_width = SrcScreenWidth * cam_scale / 2
|
|
local half_target_height = ScreenHeight * cam_scale / 2
|
|
local scene_size = Scene.Instance:GetSceneSize()
|
|
local scene_width = scene_size.x - half_target_width
|
|
local scene_height = scene_size.y - half_target_height
|
|
|
|
if half_target_width < scene_width then
|
|
if now_pos.x < half_target_width then
|
|
now_pos.x = half_target_width
|
|
elseif now_pos.x > scene_width then
|
|
now_pos.x = scene_width
|
|
end
|
|
else
|
|
now_pos.x = scene_size.x/ 2
|
|
end
|
|
|
|
if half_target_height < scene_height then
|
|
if now_pos.y < half_target_height then
|
|
now_pos.y = half_target_height
|
|
elseif now_pos.y > scene_height then
|
|
now_pos.y = scene_height
|
|
end
|
|
else
|
|
now_pos.y = scene_size.y / 2
|
|
end
|
|
return now_pos
|
|
end
|
|
|
|
function MainCamera:JoyStickState( state )
|
|
self.is_joystick_state = state
|
|
end
|
|
|
|
function MainCamera:IsJoyStickState( )
|
|
return self.is_joystick_state
|
|
end
|
|
|
|
function MainCamera:UpdateCameraPosDirect(posx,posy,height)
|
|
|
|
if self.update_direct_pos == nil then
|
|
self.update_direct_pos = co.TableXY(posx,posy + MainCamera.ScreenCenterOffset)
|
|
else
|
|
self.update_direct_pos.x = posx
|
|
self.update_direct_pos.y = posy + MainCamera.ScreenCenterOffset
|
|
end
|
|
--self.update_direct_pos = self:CameraBoundHandle(self.update_direct_pos)
|
|
--target_pos.x = bit.toint(target_pos.x)
|
|
--target_pos.y = bit.toint(target_pos.y)
|
|
|
|
-- local x = math.abs(target_pos.x - self.real_now_pos.x)
|
|
-- local y = math.abs(target_pos.y - self.real_now_pos.y)
|
|
-- if self.is_joystick_state and ( x > 10 or y > 10) then
|
|
-- end
|
|
self:SetPos(self.update_direct_pos.x, self.update_direct_pos.y,height)
|
|
self.camera_move_speed.x = 0
|
|
self.camera_move_speed.y = 0
|
|
end
|
|
|
|
function MainCamera:Update(now_time, elapse_time)
|
|
|
|
-- if self.is_update_camera then
|
|
-- --self:UpdateCamera(target_pos, is_in_move, main_move_dir, elapse_time)
|
|
-- end
|
|
|
|
if not self.is_update_camera then
|
|
return
|
|
end
|
|
|
|
if MainCamera.FreeCameraViewOpened then -- 打开了自由摄像机界面后，该值为true
|
|
return
|
|
end
|
|
|
|
self:UpdateShakeScreen(now_time, elapse_time)
|
|
-- self:UpdateLockCamera(now_time,elapse_time)
|
|
self:UpdateCameraSize(now_time,elapse_time)
|
|
--self:UpdateCamerView()
|
|
self:SmoothPosToTarget()
|
|
end
|
|
|
|
--震屏处理
|
|
function MainCamera:UpdateShakeScreen(now_time, elapse_time)
|
|
if not Scene.Instance.main_role then
|
|
return
|
|
end
|
|
|
|
if IsTableEmpty(self.shake_elements_list) then
|
|
self.is_shaking = false
|
|
else
|
|
self.is_shaking = true
|
|
local curr_shake_range_x = 0
|
|
local curr_shake_range_y = 0
|
|
local curr_shake_range_s = 0
|
|
local curr_shake_range = 0
|
|
local ratio = 0
|
|
local radian_off = 0
|
|
local past_time = 0
|
|
|
|
for i, vo in ipairs(self.shake_elements_list) do
|
|
|
|
past_time = Status.NowTime - vo.add_list_time
|
|
|
|
if past_time >= vo.shake_start_time then
|
|
ratio = (past_time - vo.shake_start_time) / vo.shake_lase_time
|
|
ratio = ratio > 1 and 1 or ratio
|
|
curr_shake_range = vo.shake_max_range * math_sin((ratio * vo.shake_angle + vo.start_angle) * math.pi / 180)
|
|
if vo.shake_type == 1 then --上下
|
|
|
|
if math_abs(curr_shake_range) > math_abs(curr_shake_range_y) then
|
|
curr_shake_range_y = curr_shake_range
|
|
end
|
|
elseif vo.shake_type == 2 then --左右
|
|
if math_abs(curr_shake_range) > math_abs(curr_shake_range_x) then
|
|
curr_shake_range_x = curr_shake_range
|
|
end
|
|
elseif vo.shake_type == 3 then --拉伸
|
|
if math_abs(curr_shake_range) > math_abs(curr_shake_range_s) then
|
|
curr_shake_range_s = curr_shake_range
|
|
end
|
|
end
|
|
if ratio >= 1 then
|
|
table_remove(self.shake_elements_list, i)
|
|
end
|
|
end
|
|
end
|
|
if curr_shake_range_x ~= 0 or curr_shake_range_y ~= 0 then
|
|
local role_real_pos = Scene.Instance.main_role.real_pos
|
|
if math_abs(self.real_now_pos.x - role_real_pos.x - curr_shake_range_x) > 100 or math_abs(self.real_now_pos.y - role_real_pos.y - MainCamera.ScreenCenterOffset - curr_shake_range_y) > 100 then
|
|
self.temp_shake_pos.x = role_real_pos.x + curr_shake_range_x
|
|
self.temp_shake_pos.y = role_real_pos.y + curr_shake_range_y
|
|
self:UpdateCamera(self.temp_shake_pos, nil, nil, true)
|
|
else
|
|
self:UpdateCameraPosDirect(role_real_pos.x + curr_shake_range_x, role_real_pos.y + curr_shake_range_y)
|
|
end
|
|
end
|
|
if curr_shake_range_s ~= 0 then
|
|
self:SetCameraSize(CameraDefaultFieldofView + curr_shake_range_s / MainCamera.PixelsToUnits)
|
|
end
|
|
if IsTableEmpty(self.shake_elements_list) then
|
|
self.is_shaking = false
|
|
self:SetCameraSize(CameraDefaultFieldofView) -- 2D用 self.camera_base_size
|
|
if Scene.Instance.main_role then
|
|
self:UpdateCamera(Scene.Instance.main_role.real_pos)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--添加震屏项
|
|
function MainCamera:AddShakeElement(shake_start_time, shake_type, shake_lase_time, shake_max_range, shake_angle, start_angle)
|
|
if shake_lase_time == 0 or shake_max_range == 0 or shake_angle == 0 or lua_settingM:ExistBlockSet("shakeScreen") then
|
|
return
|
|
end
|
|
|
|
if (not lua_viewM.main_cancas_last_visible) or lua_viewM.is_lock_screen then
|
|
return
|
|
end
|
|
|
|
local shake_info = {
|
|
shake_type = shake_type,
|
|
shake_lase_time = shake_lase_time,
|
|
shake_max_range = shake_max_range or 15,
|
|
--start_shake_pos = co.TableXY(RoleManager.Instance.mainRoleInfo.pos_x, RoleManager.Instance.mainRoleInfo.pos_y),
|
|
shake_angle = shake_angle or 180,
|
|
start_angle = start_angle,
|
|
-- start_camera_size = self.camera_curr_size,
|
|
shake_start_time = shake_start_time,
|
|
add_list_time = Status.NowTime,
|
|
}
|
|
|
|
table_insert(self.shake_elements_list, shake_info)
|
|
self.is_shaking = true
|
|
end
|
|
|
|
function MainCamera:ClearShakeElement()
|
|
self.shake_elements_list = {}
|
|
end
|
|
|
|
function MainCamera:SetUpdateCameraEnabled(flag)
|
|
self.is_update_camera = flag
|
|
|
|
local game_vector2 = self.transform.position
|
|
self.real_now_pos.x = game_vector2.x * MainCamera.PixelsToUnits
|
|
self.real_now_pos.y = game_vector2.z * MainCamera.PixelsToUnits
|
|
self.camera_move_speed.x = 0
|
|
self.camera_move_speed.y = 0
|
|
self.last_t_pos = nil
|
|
|
|
if flag then
|
|
self.camera.transform.localRotation = Quaternion.Euler(SceneCameraRotate,0,0)
|
|
self.transform.rotation = Quaternion.Euler(0,0,0)
|
|
SetLocalPosition(self.camera.transform, 0, 0, -CameraDistanceWithMainRole)
|
|
end
|
|
end
|
|
|
|
function MainCamera:UpdateCameraPos(dest_pos,time,elapse_time)
|
|
|
|
if self.move_start_time < time then
|
|
self.move_start_time = self.move_start_time + Time.deltaTime
|
|
if self.move_constant then
|
|
local now_pos = GameMath_Lerp(self.move_start_pos,dest_pos,self.move_start_time/time)
|
|
self:SetPos(now_pos.x,now_pos.y)
|
|
else
|
|
local x = GameMath.EaseInOutQuad(self.move_start_pos.x,dest_pos.x,self.move_start_time/time)
|
|
local y = GameMath.EaseInOutQuad(self.move_start_pos.y,dest_pos.y,self.move_start_time/time)
|
|
self:SetPos(x,y)
|
|
end
|
|
else
|
|
self.lock_camera_pos = false
|
|
end
|
|
end
|
|
|
|
function MainCamera:UpdateCameraSizeBySize(elapse_time)
|
|
if self.change_start_time < self.change_size_time then
|
|
self.change_start_time = self.change_start_time + Time.deltaTime
|
|
local scale = GameMath_Lerp(self.change_start_scale,self.dest_camera_scale,self.change_start_time/self.change_size_time)
|
|
self:ScaleCamera(scale)
|
|
else
|
|
self.is_change_size = false
|
|
end
|
|
end
|
|
|
|
function MainCamera:RandFunc(x)
|
|
local ret_val = math.floor(x)
|
|
local val = x - ret_val
|
|
if val >= 0.5 then
|
|
ret_val = ret_val + 1
|
|
end
|
|
return ret_val
|
|
end
|
|
|
|
function MainCamera:UpdateCamera(t_pos, is_in_move, elapse_time, force_update)
|
|
if self.is_shaking and not force_update then
|
|
return
|
|
end
|
|
|
|
if self.last_t_pos and self.last_t_pos.x == t_pos.x and self.last_t_pos.y == t_pos.y then
|
|
return
|
|
end
|
|
|
|
elapse_time = 1.0/LuaFPS.FPS
|
|
if self.target_pos == nil then
|
|
self.target_pos = co.Vector2(t_pos.x,t_pos.y + MainCamera.ScreenCenterOffset)
|
|
else
|
|
self.target_pos.x = t_pos.x
|
|
self.target_pos.y = t_pos.y + MainCamera.ScreenCenterOffset
|
|
end
|
|
--暂时直接将主角当为摄像机目标
|
|
if self.inteval_pos == nil then
|
|
self.inteval_pos = self.target_pos - self.real_now_pos
|
|
else
|
|
self.inteval_pos.x = self.target_pos.x - self.real_now_pos.x
|
|
self.inteval_pos.y = self.target_pos.y - self.real_now_pos.y
|
|
end
|
|
if self.inteval_pos.x < -1000 or self.inteval_pos.x > 1000 or self.inteval_pos.y < -1000 or self.inteval_pos.y > 1000 then
|
|
self.target_pos = self:CameraBoundHandle(self.target_pos)
|
|
--self.target_pos.x = bit.toint(self.target_pos.x)
|
|
--self.target_pos.y = bit.toint(self.target_pos.y)
|
|
self.camera_move_speed.x = 0
|
|
self.camera_move_speed.y = 0
|
|
--self.real_now_pos.x = self.target_pos.x
|
|
--self.real_now_pos.y = self.target_pos.y
|
|
self:SetPos(self.target_pos.x, self.target_pos.y, nil , force_update)
|
|
return
|
|
end
|
|
local smooth_time = MainCamera.SmoothTime
|
|
local tem_pos = self.target_pos
|
|
-- tem_pos, self.camera_move_speed =
|
|
-- GameMath.Smooth(self.real_now_pos, self.target_pos,
|
|
-- self.camera_move_speed,
|
|
-- smooth_time,
|
|
-- elapse_time)
|
|
if self.last_t_pos == nil then
|
|
self.last_t_pos = co.TableXY(tem_pos.x, tem_pos.y - MainCamera.ScreenCenterOffset)
|
|
else
|
|
self.last_t_pos.x, self.last_t_pos.y = tem_pos.x, tem_pos.y - MainCamera.ScreenCenterOffset
|
|
end
|
|
tem_pos = self:CameraBoundHandle(tem_pos)
|
|
tem_pos.x = self:RandFunc(tem_pos.x)
|
|
tem_pos.y = self:RandFunc(tem_pos.y)
|
|
self:SetPos(tem_pos.x, tem_pos.y, nil, force_update)
|
|
end
|
|
|
|
--摄像机跟随
|
|
function MainCamera:Follow(pos,now_time,elapse_time,dontCheckBound)
|
|
if pos then
|
|
local tem_pos = {}
|
|
tem_pos.x = GameMath_Lerp(self.real_now_pos.x,pos.x,elapse_time * 2)
|
|
tem_pos.y = GameMath_Lerp(self.real_now_pos.y,pos.y,elapse_time * 2)
|
|
|
|
if dontCheckBound then
|
|
self:SetPos(tem_pos.x,tem_pos.y)
|
|
else
|
|
local real_now_pos = self:CameraBoundHandle(tem_pos)
|
|
self:SetPos(real_now_pos.x,real_now_pos.y)
|
|
end
|
|
end
|
|
end
|
|
|
|
function MainCamera:SetPos( posx, posy,height,force_update)
|
|
if SceneManager:getInstance():IsStarFightScene() then
|
|
return
|
|
end
|
|
|
|
if self.real_now_pos and self.real_now_pos.x == posx and self.real_now_pos.y == posy and not height and not force_update then
|
|
return
|
|
end
|
|
self.real_now_pos.x, self.real_now_pos.y = posx, posy
|
|
local mainrole_height = 0
|
|
local mainrole = Scene.Instance:GetMainRole()
|
|
if mainrole then
|
|
mainrole_height = mainrole.obj_pos_height
|
|
if mainrole_height == 0 and self.last_role_height then
|
|
mainrole_height = self.last_role_height
|
|
end
|
|
if mainrole_height > 0 then
|
|
self.last_role_height = mainrole_height
|
|
end
|
|
end
|
|
height = height or 0
|
|
self.temp_pos.x = posx / MainCamera.PixelsToUnits; --transform.x
|
|
self.temp_pos.y = posy / MainCamera.PixelsToUnits --transform.z
|
|
self.temp_pos.z = SceneCameraHeigth + mainrole_height + height / MainCamera.PixelsToUnits--transform.y
|
|
--摄像机的y轴给一个插值过渡
|
|
-- if(math.abs(self.transform.position.y - realz) < 3) then
|
|
-- realz = GameMath_Lerp(realz,self.transform.position.y,0.01)
|
|
-- end
|
|
if self.isSmoothing then
|
|
self.smoothTarget = Vector3(self.temp_pos.x,self.temp_pos.z,self.temp_pos.y)
|
|
--self:SmoothPosToTarget()
|
|
else
|
|
self.smoothTarget = nil
|
|
SetGlobalPosition3D(self.transform, self.temp_pos.x, self.temp_pos.y, self.temp_pos.z)
|
|
GlobalEventSystem:Fire(SceneEventType.CAMERA_MOVE)
|
|
end
|
|
end
|
|
|
|
function MainCamera:SetSmoothingState(bool)
|
|
self.isSmoothing = bool
|
|
end
|
|
|
|
function MainCamera:GetCameraRealHeight()
|
|
local mainrole_height = 0
|
|
local mainrole = Scene.Instance:GetMainRole()
|
|
if mainrole then
|
|
mainrole_height = mainrole.obj_pos_height
|
|
end
|
|
local realz = SceneCameraHeigth + mainrole_height
|
|
return realz
|
|
end
|
|
|
|
|
|
--@pos:摄像机的目标坐标
|
|
--@immediately:是立即跳至目标点还是缓动移过去
|
|
--@constant:是否匀速移动
|
|
function MainCamera:SetLockCameraPos(x,y,time,immediately,constant)
|
|
self.is_lock_camera = true
|
|
self.lock_camera_pos = co.TableXY(x,y + MainCamera.ScreenCenterOffset)
|
|
self.move_immediately = immediately
|
|
self.move_constant = constant
|
|
self.move_camera_time = time
|
|
self.move_start_time = 0
|
|
self.move_start_pos = co.Vector2(self.real_now_pos.x,self.real_now_pos.y)
|
|
end
|
|
|
|
|
|
function MainCamera:SetCameraChangeSize(scale,time,immediately)
|
|
self.is_change_size = true
|
|
self.dest_camera_scale = scale
|
|
self.change_start_time = 0
|
|
self.change_start_scale = self.camera_curr_size / self.camera_base_size
|
|
self.change_size_time = time
|
|
self.change_immediately = immediately
|
|
end
|
|
|
|
function MainCamera:UpdateCameraPosByMainRole(force_update)
|
|
|
|
if Scene.Instance.main_role == nil then
|
|
return
|
|
end
|
|
|
|
self.is_lock_camera = false
|
|
self.lock_camera_pos = false
|
|
|
|
if Scene.Instance.main_role then
|
|
self:UpdateCamera(Scene.Instance.main_role.real_pos,nil,nil,force_update)
|
|
end
|
|
end
|
|
|
|
--摄像机是否锁定不跟随主角
|
|
function MainCamera:IsLockCamera()
|
|
return self.is_lock_camera
|
|
end
|
|
|
|
--摄像机是否在改变大小
|
|
function MainCamera:IsChangeSize()
|
|
return self.is_change_size
|
|
end
|
|
|
|
--摄像机是否在改变大小
|
|
function MainCamera:IsMoveCamera()
|
|
return self.lock_camera_pos
|
|
end
|
|
|
|
--摄像机是否震屏
|
|
function MainCamera:IsShakeCamera()
|
|
return self.is_shaking
|
|
end
|
|
|
|
--摄像机是否锁定不跟随主角
|
|
function MainCamera:UpdateLockCamera(now_time, elapse_time)
|
|
--如果外部指定的摄像机坐标就指定坐标
|
|
if self.is_lock_camera and self.lock_camera_pos then
|
|
if not self.move_immediately then
|
|
self:UpdateCameraPos(self.lock_camera_pos,self.move_camera_time,elapse_time)
|
|
else
|
|
self:SetPos(self.lock_camera_pos.x, self.lock_camera_pos.y)
|
|
self.lock_camera_pos = false
|
|
end
|
|
end
|
|
end
|
|
|
|
--摄像机是否锁定不跟随主角
|
|
function MainCamera:UpdateCameraSize(now_time, elapse_time)
|
|
--如果外部指定的摄像机坐标就指定坐标
|
|
if self.is_change_size and self.dest_camera_scale ~= nil then
|
|
if not self.change_immediately then
|
|
self:UpdateCameraSizeBySize(elapse_time)
|
|
else
|
|
self:ScaleCamera(self.dest_camera_scale)
|
|
self.is_change_size = false
|
|
end
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
--更新摄像机视野范围的平滑动画
|
|
function MainCamera:UpdateCamerView( )
|
|
if not(IsTableEmpty(self.size_smooth_list))then
|
|
local target = self:GetNextSmoothTarget()
|
|
if not(target == -1 ) then
|
|
if not (target) then
|
|
return
|
|
end
|
|
|
|
local temp = target - self.camera.fieldOfView
|
|
local sign = 1
|
|
if(temp < 0) then
|
|
sign = -1
|
|
end
|
|
|
|
self.camera.fieldOfView = (self.camera.fieldOfView + MainCamera.SizeSmoothSpeed * sign)
|
|
if self.screencamera then
|
|
self.screencamera.fieldOfView = (self.camera.fieldOfView + MainCamera.SizeSmoothSpeed * sign)
|
|
end
|
|
if(math_abs(self.camera.fieldOfView - target) < MainCamera.SizeSmoothSpeed*2) then
|
|
self.camera_curr_size = target
|
|
self.camera.fieldOfView = target
|
|
|
|
if self.screencamera then
|
|
self.screencamera.fieldOfView = target
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
function MainCamera:GetNextSmoothTarget()
|
|
if not(self.size_smooth_list) then
|
|
return -1
|
|
end
|
|
|
|
if not(IsTableEmpty(self.size_smooth_list)) then
|
|
if(self.camera.fieldOfView == self.size_smooth_list[1]) then
|
|
table_remove(self.size_smooth_list,1)
|
|
self:GetNextSmoothTarget()
|
|
else
|
|
return self.size_smooth_list[1]
|
|
|
|
end
|
|
else
|
|
return -1
|
|
end
|
|
|
|
end
|
|
|
|
--恢复摄像机初始设置
|
|
function MainCamera:InitCameraSetting()
|
|
self.is_lock_camera = false
|
|
self.lock_camera_pos = false
|
|
self.isSmoothing = false
|
|
self.real_now_pos.x, self.real_now_pos.y = 0, 0
|
|
self.last_t_pos = nil
|
|
self.shake_elements_list = {}
|
|
|
|
|
|
-- if SceneManager.Instance:IsPkRankFightScene() then
|
|
-- local mainrole = Scene.Instance:GetMainRole()
|
|
-- if mainrole then
|
|
-- local newHeight = Scene.Instance:GetZoneHeight(4880/SceneObj.LogicRealRatio.x,4300/SceneObj.LogicRealRatio.y)
|
|
-- mainrole.obj_pos_height = newHeight
|
|
-- end
|
|
|
|
-- self:SetCameraSize(55)
|
|
-- self:SetPos(4880, 4300)
|
|
-- end
|
|
end
|
|
|
|
function MainCamera:RotateAround( position, dir, value )
|
|
self.rotate_around = self.rotate_around + value
|
|
if math_abs(self.rotate_around) > 360 then
|
|
if self.rotate_around > 0 then
|
|
self.rotate_around = self.rotate_around - 360
|
|
else
|
|
self.rotate_around = self.rotate_around + 360
|
|
end
|
|
end
|
|
|
|
self.transform:RotateAround( position, dir, value)
|
|
end
|
|
|
|
--改变相机的移动是否平滑过渡 isActive = true or false
|
|
function MainCamera:ChangeSmoothActive(isActive)
|
|
self.isSmooth = isActive
|
|
end
|
|
|
|
function MainCamera:ChangeSmoothState(state)
|
|
self.smoothState = state
|
|
if state == MainCamera.SmoothState.Normal then
|
|
-- self.maxDistance = 2
|
|
-- self.maxSpeed = 0.15
|
|
-- self.targetSmoothSpeed = 0.15
|
|
self.maxDistance = 2
|
|
self.maxSpeed = 0.22
|
|
self.targetSmoothSpeed = 2
|
|
self.isSmooth = true
|
|
elseif state == MainCamera.SmoothState.Jump then
|
|
self.maxDistance = 2
|
|
-- self.maxSpeed = 0.35
|
|
self.targetSmoothSpeed = 0.5
|
|
elseif state == MainCamera.SmoothState.Skill then
|
|
self.maxDistance = 2
|
|
self.maxSpeed = 0.22
|
|
self.targetSmoothSpeed = 2
|
|
elseif state == MainCamera.SmoothState.Jump_Point then
|
|
self.maxDistance = 3.5
|
|
self.maxSpeed = 0.4
|
|
self.targetSmoothSpeed = 2
|
|
elseif state == MainCamera.SmoothState.JUMP_ONE then
|
|
self.maxDistance = 3.5
|
|
self.maxSpeed = 0.4
|
|
self.targetSmoothSpeed = 2
|
|
elseif state == MainCamera.SmoothState.Horse then
|
|
self.maxDistance = 3
|
|
self.maxSpeed = 0.5
|
|
self.targetSmoothSpeed = 1
|
|
elseif state == MainCamera.SmoothState.Speed_Buff then
|
|
self.maxDistance = 2
|
|
self.maxSpeed = 3
|
|
self.targetSmoothSpeed = 3
|
|
elseif state == MainCamera.SmoothState.Quiz then
|
|
self.maxDistance = 3
|
|
self.maxSpeed = 0.22
|
|
self.targetSmoothSpeed = 1
|
|
elseif state == MainCamera.SmoothState.NewBieTask then
|
|
self.maxDistance = 2
|
|
self.maxSpeed = 0.6
|
|
self.targetSmoothSpeed = 0.25
|
|
elseif state == MainCamera.SmoothState.TaskJump then
|
|
self.maxDistance = 4
|
|
self.maxSpeed = 0.3
|
|
self.targetSmoothSpeed = 0.3
|
|
elseif state == MainCamera.SmoothState.Flash then
|
|
self.maxDistance = 6
|
|
self.maxSpeed = 0.4
|
|
self.targetSmoothSpeed = 0.4
|
|
elseif state == MainCamera.SmoothState.SpecialDun then
|
|
self.maxDistance = 3
|
|
self.maxSpeed = 0.3
|
|
self.targetSmoothSpeed = 0.25
|
|
self.isSmoothing = true
|
|
elseif state == MainCamera.SmoothState.None then
|
|
self.maxDistance = 6
|
|
self.maxSpeed = 0.4
|
|
self.targetSmoothSpeed = 0
|
|
self.isSmoothing = false
|
|
self.isSmooth = false
|
|
|
|
end
|
|
|
|
-- print("改变了摄像机参数 ",state,self.maxSpeed)
|
|
end
|
|
|
|
function MainCamera:ChangePosFllowMainrole(pos_x,pos_y,jump_height)
|
|
if SceneManager:getInstance():IsStarFightScene() then
|
|
|
|
return
|
|
end
|
|
|
|
-- 以下是2D相机的逻辑
|
|
|
|
-- local radian = math.abs(self.rotate_around) % 180 / 180 * math.pi
|
|
-- local asin = math.sin(radian)
|
|
-- local acos = math.cos(radian)
|
|
-- local x = math.abs(asin * CameraDistanceWithMainRole)
|
|
-- local y = math.abs(acos * CameraDistanceWithMainRole)
|
|
|
|
-- if self.rotate_around > 0 then
|
|
-- if self.rotate_around < -270 then
|
|
-- elseif self.rotate_around > 180 then
|
|
-- y = -y
|
|
-- elseif self.rotate_around > 90 then
|
|
-- x = -x
|
|
-- y = -y
|
|
-- else
|
|
-- x = -x
|
|
-- end
|
|
-- else
|
|
-- if self.rotate_around < -270 then
|
|
-- x = -x
|
|
-- elseif self.rotate_around < -180 then
|
|
-- x = -x
|
|
-- y = -y
|
|
-- elseif self.rotate_around < -90 then
|
|
-- y = -y
|
|
-- end
|
|
-- end
|
|
|
|
-- 以上
|
|
-- if self.firstMove then
|
|
-- self:UpdateCameraPosDirect(pos_x, pos_y,jump_height )
|
|
-- self.firstMove = false
|
|
-- return
|
|
-- end
|
|
-- local mainrole_height = 0
|
|
-- local mainrole = Scene.Instance:GetMainRole()
|
|
-- if mainrole then
|
|
-- mainrole_height = mainrole.obj_pos_height
|
|
-- end
|
|
|
|
-- -- self.smoothTarget.x = pos_x / MainCamera.PixelsToUnits; --transform.x
|
|
-- -- self.smoothTarget.y = pos_y / MainCamera.PixelsToUnits --transform.z
|
|
-- -- local off_height = jump_height / MainCamera.PixelsToUnits
|
|
-- -- self.smoothTarget.z = SceneCameraHeigth + mainrole_height + off_height--transform.y
|
|
|
|
-- local x = pos_x / MainCamera.PixelsToUnits; --transform.x
|
|
-- local y = pos_y / MainCamera.PixelsToUnits --transform.z
|
|
-- local off_height = jump_height / MainCamera.PixelsToUnits
|
|
-- local z = SceneCameraHeigth + mainrole_height + off_height--transform.y
|
|
|
|
-- self.smoothTarget = Vector3(x,y,z)
|
|
if self.isSmooth and not self.block_smooth then
|
|
self.isSmoothing = true
|
|
else
|
|
self.isSmoothing = false
|
|
end
|
|
|
|
|
|
self:UpdateCameraPosDirect(pos_x, pos_y,jump_height )
|
|
--MainCamera.Instance:SetCameraSize(MainCamera.Instance.camera_base_size * (1 + jump_height * 0.0011))
|
|
end
|
|
|
|
function MainCamera:SmoothPosToTarget()
|
|
if not self.smoothTarget then
|
|
return
|
|
end
|
|
if not self.isSmoothing then
|
|
return
|
|
end
|
|
-- if SceneManager:getInstance():IsStarFightScene() then
|
|
-- return
|
|
-- end
|
|
|
|
local abs = math_abs(self.targetSmoothSpeed - self.maxSpeed)
|
|
if abs > 0.01 then
|
|
if self.targetSmoothSpeed >= self.maxSpeed then
|
|
self.maxSpeed = self.maxSpeed + 0.01
|
|
else
|
|
self.maxSpeed = self.maxSpeed - 0.01
|
|
end
|
|
end
|
|
|
|
local distance = Vector3.Distance(self.transform.position,self.smoothTarget)
|
|
if distance < 0.01 then
|
|
self.isSmoothing = false
|
|
return
|
|
end
|
|
if distance > self.maxDistance * 2 then --超过最大距离的两倍，就不缓动了
|
|
self.transform.position = self.smoothTarget
|
|
GlobalEventSystem:Fire(SceneEventType.CAMERA_MOVE)
|
|
return
|
|
end
|
|
|
|
|
|
local temp_fps = 60
|
|
if LuaFPS.FPS and LuaFPS.FPS ~= 0 then
|
|
temp_fps = LuaFPS.FPS
|
|
end
|
|
local real_max_speed = 60/temp_fps * self.maxSpeed
|
|
local speed = distance/self.maxDistance * real_max_speed
|
|
speed = self:GetClamp(speed,-real_max_speed,real_max_speed)
|
|
|
|
local nextStep = Vector3.MoveTowards(self.transform.position,self.smoothTarget,speed)
|
|
SetGlobalPosition3D(self.transform, nextStep.x, nextStep.z,nextStep.y)
|
|
GlobalEventSystem:Fire(SceneEventType.CAMERA_MOVE)
|
|
end
|
|
|
|
function MainCamera:GetClamp(value,min,max)
|
|
if value < min then
|
|
return min
|
|
end
|
|
if value > max then
|
|
return max
|
|
end
|
|
return value
|
|
end
|
|
|
|
|
|
function MainCamera:Distance(value1,value2)
|
|
return math.sqrt(math.pow(2,(value1.x - value2.x)) + math.pow(2,(value1.y - value2.y)) + math.pow(2,(value1.z - value2.z)))
|
|
end
|
|
|
|
|
|
function MainCamera:GetNameBoardPoint( x,y,z )
|
|
local pos = self.camera:WorldToScreenPoint(Vector3(x,y,z))
|
|
pos = self.uiCamera:ScreenToWorldPoint(pos)
|
|
return pos
|
|
end
|
|
|
|
function MainCamera:CreateScreenCamera()
|
|
local screencameraobj = GameObject.New("ScreenCamera")
|
|
screencameraobj:AddComponent(typeof(UnityEngine.Camera))
|
|
screencameraobj.layer = LayerMask.NameToLayer("Screen")
|
|
|
|
self.screencamera = screencameraobj:GetComponent("Camera")
|
|
|
|
self.screencamera.depth = 0
|
|
self.screencamera.cullingMask = 2048
|
|
self.screencamera.clearFlags = UnityEngine.CameraClearFlags.Depth
|
|
self.screencamera.orthographic = false
|
|
self.screencamera.transform:SetParent(self.transform)
|
|
|
|
self.screencamera.fieldOfView = self.camera_curr_size
|
|
self.screencamera.transform.localRotation = Quaternion.Euler(SceneCameraRotate,0,0)
|
|
|
|
SetLocalPosition(self.screencamera.transform,0,0,-CameraDistanceWithMainRole)
|
|
end
|
|
|
|
function MainCamera:AddScreenObj( transform )
|
|
do return end
|
|
if tonumber(AppConst.EnglineVer) <= 72 then
|
|
return
|
|
end
|
|
|
|
if not self.screencamera then
|
|
self:CreateScreenCamera()
|
|
end
|
|
|
|
if self.screen_obj_count == 0 then
|
|
self.screencamera.gameObject:SetActive(true)
|
|
end
|
|
|
|
self.screen_obj_count = self.screen_obj_count + 1
|
|
local layer = LayerMask.NameToLayer("Screen")
|
|
self:SetCustomLayer(transform,layer)
|
|
end
|
|
|
|
function MainCamera:RemoveScreenObj( transform )
|
|
do return end
|
|
if not self.screencamera then
|
|
return
|
|
end
|
|
|
|
self.screen_obj_count = self.screen_obj_count - 1
|
|
local layer = LayerMask.NameToLayer("Default")
|
|
self:SetCustomLayer(transform,layer)
|
|
|
|
if self.screen_obj_count <= 0 then
|
|
self.screencamera.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
|
|
function MainCamera:HideScreenCamera()
|
|
self.screen_obj_count = 0
|
|
if self.screencamera and self.screencamera.gameObject.activeSelf then
|
|
self.screencamera.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
|
|
function MainCamera:SetCustomLayer( obj, layer )
|
|
if IsNull(obj) then
|
|
return
|
|
end
|
|
for i = 0,obj.childCount - 1 do
|
|
obj:GetChild(i).gameObject.layer = layer
|
|
self:SetCustomLayer(obj:GetChild(i),layer)
|
|
end
|
|
end
|
|
|
|
function MainCamera:AddSelectRoleMode()
|
|
self.can_scale_camera = false
|
|
SetGlobalPosition(self.transform, 0, 0, 0)
|
|
SetGlobalPosition(self.camera.transform, -0.14, 0.965, -4.83)
|
|
self.camera.transform.localRotation = Quaternion.Euler(-1.50,-3.47,0)
|
|
self.camera.fieldOfView = 30
|
|
end
|
|
|
|
function MainCamera:AddCreateRoleMode( )
|
|
self.can_scale_camera = false
|
|
SetGlobalPosition(self.transform, 0, 0, 0)
|
|
SetGlobalPosition(self.camera.transform, -0.14, 0.965, -4.83)
|
|
self.camera.transform.localRotation = Quaternion.Euler(-1.50,-3.47,0)
|
|
self.camera.fieldOfView = 30
|
|
end
|
|
|
|
function MainCamera:ResetNormalMode()
|
|
self:RecoverCameraParm()
|
|
self.can_scale_camera = true
|
|
SetLocalPosition(self.camera.transform, 0, 0, -CameraDistanceWithMainRole)
|
|
self.camera.transform.localRotation = Quaternion.Euler(SceneCameraRotate,0,0)
|
|
self.camera.fieldOfView = self.camera_curr_size
|
|
end
|
|
|
|
function MainCamera:BackupCameraParm( )
|
|
if self.has_backup then
|
|
return
|
|
end
|
|
self.backup_distance = CameraDistanceWithMainRole
|
|
self.backup_rotate_x = SceneCameraRotate
|
|
self.backup_field = self.camera_curr_size
|
|
self.backup_height = SceneCameraHeigth
|
|
self.has_backup = true
|
|
end
|
|
|
|
function MainCamera:RecoverCameraParm( )
|
|
if not self.backup_distance then
|
|
return
|
|
end
|
|
CameraDistanceWithMainRole = self.backup_distance
|
|
SceneCameraRotate = self.backup_rotate_x
|
|
self.camera_curr_size = self.backup_field
|
|
SceneCameraHeigth = self.backup_height
|
|
self.has_backup = false
|
|
end
|
|
|
|
function MainCamera:SetSpecialDunMode( cfg )
|
|
-- self:SetUpdateCameraEnabled(false)
|
|
self:BackupCameraParm()
|
|
CameraDistanceWithMainRole = cfg.distance
|
|
SceneCameraRotate = cfg.rotate
|
|
self.camera_curr_size = cfg.field
|
|
SceneCameraHeigth = cfg.height
|
|
self:ChangeSmoothState(MainCamera.SmoothState.SpecialDun)
|
|
self:SetUpdateCameraEnabled(true)
|
|
self.transform.localRotation = Quaternion.Euler(0,cfg.angle,0)
|
|
self:UpdateCameraPosByMainRole()
|
|
end
|
|
|
|
function MainCamera:QuitSpecialDunMode( )
|
|
self:SetUpdateCameraEnabled(true)
|
|
self:ResetNormalMode()
|
|
self:UpdateCameraPosByMainRole()
|
|
end
|
|
|
|
function MainCamera:SetFishingCameraPos( angle)
|
|
--self:SetRoleDirection()
|
|
self:SetUpdateCameraEnabled(false)
|
|
local x, y, z = 0, 0, 0
|
|
x, z = Scene.Instance.main_role:GetRealPos()
|
|
x = x / MainCamera.PixelsToUnits
|
|
z = z / MainCamera.PixelsToUnits
|
|
y = self.transform.position.y - Config.ConfigFishSceneCamera.height
|
|
SetGlobalPosition(self.transform, x, y, z)
|
|
self.camera.transform.localRotation = Quaternion.Euler(Config.ConfigFishSceneCamera.rotate,0,0)
|
|
self.transform.localRotation = Quaternion.Euler(0,angle,0)
|
|
end
|
|
|
|
function MainCamera:SetMateCamera(pos_x,pos_y,type_id )
|
|
self:SetUpdateCameraEnabled(false)
|
|
-- if type_id == "x" then
|
|
if true then
|
|
self:SetPos( pos_x, pos_y + 700,-800)
|
|
self.camera.transform.localRotation = Quaternion.Euler(13,0,0)
|
|
elseif type_id == "y" then
|
|
self.camera.transform.localRotation = Quaternion.Euler(13,-90,0)
|
|
self:SetPos( pos_x+600, pos_y + 1300,-800)
|
|
end
|
|
end
|
|
|
|
function MainCamera:QuitMateCamera( )
|
|
self:SetUpdateCameraEnabled(true)
|
|
self:ResetNormalMode()
|
|
self:UpdateCameraPosByMainRole()
|
|
end
|
|
|
|
function MainCamera:SetCameraMoveToZ( cfg )
|
|
if not cfg then
|
|
return
|
|
end
|
|
if self.time_id then
|
|
GlobalTimerQuest:CancelQuest(self.time_id)
|
|
self.time_id = nil
|
|
end
|
|
|
|
local z = cfg.distance
|
|
local animation_time = cfg.time or 1
|
|
local time, step = 0, 0.02
|
|
local function Move( )
|
|
time = time + step
|
|
if time >= animation_time then
|
|
if self.time_id then
|
|
GlobalTimerQuest:CancelQuest(self.time_id)
|
|
self.time_id = nil
|
|
end
|
|
else
|
|
|
|
local now_pos = GameMath_Lerp(self.camera.transform.localPosition.z, z, time/animation_time)
|
|
SetLocalPosition(self.camera.transform, 0, 0, now_pos)
|
|
GlobalEventSystem:Fire(SceneEventType.CAMERA_MOVE)
|
|
end
|
|
end
|
|
self.time_id = GlobalTimerQuest:AddPeriodQuest(Move,0.02,-1)
|
|
end
|
|
|
|
function MainCamera:ResetExitFishCameraPos()
|
|
local cfg = Config.ConfigFishSceneCamera
|
|
if not cfg then return end
|
|
if self.time_id then
|
|
GlobalTimerQuest:CancelQuest(self.time_id)
|
|
self.time_id = nil
|
|
end
|
|
self:SetUpdateCameraEnabled(true)
|
|
self.camera.transform.localRotation = Quaternion.Euler(SceneCameraRotate,0,0)
|
|
self.transform.localRotation = Quaternion.Euler(0,0,0)
|
|
if Scene.Instance.main_role then
|
|
local x, y, z = 0, 0, 0
|
|
x, z = Scene.Instance.main_role:GetRealPos()
|
|
x = x / MainCamera.PixelsToUnits
|
|
z = z / MainCamera.PixelsToUnits
|
|
y = self.transform.position.y + cfg.height
|
|
SetGlobalPosition(self.transform, x, y, z)
|
|
SetLocalPosition(self.camera.transform, 0, 0, -CameraDistanceWithMainRole)
|
|
end
|
|
|
|
end
|
|
|
|
--更改渲染层级
|
|
function MainCamera:SetMainCameraCullingMask( layer, flag )
|
|
if not self.camera then
|
|
return
|
|
end
|
|
if flag then
|
|
self.camera.cullingMask = bit.bor(self.camera.cullingMask, bit.lshift(1,layer))
|
|
else
|
|
self.camera.cullingMask = bit.band(self.camera.cullingMask, bit.bnot(bit.lshift(1,layer)))
|
|
end
|
|
end
|
|
|
|
--切换泛光效果开关
|
|
function MainCamera:SetPostEffectEnable( flag )
|
|
if self.is_login_post_effect_state then
|
|
return
|
|
end
|
|
if not IsNull(self.main_postEffect) and self:IsSupportPostEffect() then
|
|
self.main_postEffect.enabled = flag
|
|
end
|
|
end
|
|
|
|
function MainCamera:IsSupportPostEffect( )
|
|
-- if G_DEBUG_MODE then
|
|
-- return false
|
|
-- end
|
|
if self.is_support_post_effect ~= nil then
|
|
return self.is_support_post_effect
|
|
end
|
|
self.is_support_post_effect = SystemMemoryLevel.Cur == SystemMemoryLevel.Top
|
|
return self.is_support_post_effect
|
|
end
|
|
|
|
function MainCamera:IsSupportFAXX( )
|
|
if G_DEBUG_MODE then
|
|
return false
|
|
end
|
|
if self.is_support_faxx ~= nil then
|
|
return self.is_support_faxx
|
|
end
|
|
self.is_support_faxx = SystemMemoryLevel.Cur == SystemMemoryLevel.Hight
|
|
return self.is_support_faxx
|
|
end
|
|
|
|
--------------------------------------------屏幕后处理相关start--------------------------------------------
|
|
-- 获取当前设备是否支持使用屏幕后处理特效
|
|
function MainCamera:SetRenderSupport( )
|
|
self.is_screen_effect_supported = self.main_postEffect and self.main_postEffect:GetSupported() or false
|
|
-- and self.ui_postEffect and self.ui_postEffect:GetSupported()
|
|
end
|
|
function MainCamera:GetRenderSupport( )
|
|
return self.is_screen_effect_supported
|
|
end
|
|
--------------------------------------------高斯模糊相关start--------------------------------------------
|
|
-- 启用主摄像机和UI摄像机的渲染截图 camera_type:特效相机类型,默认模糊UI摄像机 anim_time:模糊动画时间
|
|
-- function MainCamera:EnableBlurEffect(camera_type, anim_time)
|
|
-- local top_canvas_node = panelMgr:GetParent("Top"):GetComponent("Canvas")
|
|
-- if not top_canvas_node then return end
|
|
-- -- 已经存在了进行模糊的摄像机时，直接跳过
|
|
-- if MainCamera.Activiting_Blur_Effect then return end
|
|
|
|
-- camera_type = camera_type or MainCamera.EffectCameraType.UICamera
|
|
-- -- 将TopUI层的渲染摄像机改为不参与模糊的摄像机
|
|
-- top_canvas_node.worldCamera = self.blurCamera
|
|
-- self.blurCamera.enabled = true
|
|
-- self.blurCamera_gameObject.transform.localRotation = Quaternion.Euler(0,0,0)
|
|
-- if camera_type == MainCamera.EffectCameraType.MainCamera then
|
|
-- -- self.main_screen_effect.enabled = true
|
|
-- -- self.main_screen_effect.render_blur_effect = true
|
|
-- self.main_postEffect.render_blur_effect = true
|
|
-- MainCamera.Activiting_Blur_Effect = true
|
|
-- elseif camera_type == MainCamera.EffectCameraType.UICamera then
|
|
-- -- self.ui_screen_effect.enabled = true
|
|
-- -- self.ui_screen_effect.render_blur_effect = true
|
|
-- self.ui_postEffect.render_blur_effect = true
|
|
-- MainCamera.Activiting_Blur_Effect = true
|
|
-- end
|
|
-- -- 启用渐变动画效果
|
|
-- self:StartBlurAmountBlend(true, anim_time)
|
|
-- end
|
|
|
|
-- -- 关闭模糊效果
|
|
-- function MainCamera:DisableBlurEffect(anim_time)
|
|
-- if not MainCamera.Activiting_Blur_Effect then return end
|
|
-- self:StartBlurAmountBlend(false, anim_time)
|
|
-- MainCamera.Activiting_Blur_Effect = false
|
|
-- end
|
|
-- -- 关闭模糊脚本运作
|
|
-- function MainCamera:ShutDownBlurEffect( )
|
|
-- if self.main_postEffect then
|
|
-- self.main_postEffect.render_blur_effect = false
|
|
-- end
|
|
-- if self.ui_postEffect then
|
|
-- self.ui_postEffect.render_blur_effect = false
|
|
-- end
|
|
-- -- 将Top层的UI渲染摄像机还原为UIcamera
|
|
-- local top_canvas_node = panelMgr:GetParent("Top"):GetComponent("Canvas")
|
|
-- if top_canvas_node then
|
|
-- top_canvas_node.worldCamera = self.uiCamera
|
|
-- self.blurCamera.enabled = false
|
|
-- end
|
|
-- end
|
|
-- -- 模糊效果缓动 show 显示模糊或者关闭模糊 anim_time 缓动时间
|
|
-- function MainCamera:StartBlurAmountBlend(show, anim_time)
|
|
-- -- 获取当前激活渲染效果的摄像机
|
|
-- local anim_camera = self.main_postEffect.render_blur_effect and self.main_postEffect or nil
|
|
-- anim_camera = anim_camera or (self.ui_postEffect.render_blur_effect and self.ui_postEffect)
|
|
-- if not anim_camera then return end
|
|
-- self:ClearBlurAnimId()
|
|
-- -- 目标模糊混合值
|
|
-- local target_amount = show and 1 or 0
|
|
-- local start_amount = show and 0 or 1
|
|
-- -- 目标降低采样率值
|
|
-- local max_downSample = anim_camera == self.main_postEffect and
|
|
-- self.main_blur_downSample_value or self.ui_blur_downSample_value
|
|
-- local target_downSample = show and max_downSample or 1
|
|
-- local start_downSample = show and 1 or max_downSample
|
|
-- local anim_time = anim_time or 0.3
|
|
-- local downSample_time = anim_time * (target_downSample-1)/target_downSample
|
|
-- -- 如果是要显示出来，则先从原始图片渐变到模糊图片
|
|
-- local callback = nil
|
|
-- if show and anim_time ~= 0 then
|
|
-- anim_camera.blur_amount = 0
|
|
-- anim_camera.downSample = 1
|
|
-- end
|
|
-- -- 添加动画(2019年11月16日修改：修改动画参数，增强模糊动画效果,代码参考tweenlite)
|
|
-- if anim_time ~= 0 then
|
|
-- local start_time = Status.NowTime
|
|
-- local function blur_anim_func()
|
|
-- local use_time = Status.NowTime - start_time
|
|
-- local progress = use_time / anim_time
|
|
-- anim_camera.blur_amount = use_time >= anim_time and target_amount or GameMath_Lerp(start_amount, target_amount, progress)
|
|
-- anim_camera.downSample = use_time >= downSample_time and target_downSample or GameMath_Lerp(start_downSample, target_downSample, progress)
|
|
-- if use_time >= anim_time then
|
|
-- self:ClearBlurAnimId()
|
|
-- if not show then
|
|
-- self:ShutDownBlurEffect()
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- self.blur_anim_func_id = GlobalTimerQuest:AddPeriodQuest(blur_anim_func, 0.03, -1)
|
|
-- blur_anim_func()
|
|
-- else
|
|
-- anim_camera.blur_amount = target_amount
|
|
-- anim_camera.downSample = max_downSample
|
|
-- if not show then
|
|
-- self:ShutDownBlurEffect()
|
|
-- end
|
|
-- end
|
|
-- end
|
|
|
|
-- function MainCamera:ClearBlurAnimId( )
|
|
-- if self.blur_anim_func_id then
|
|
-- GlobalTimerQuest:CancelQuest(self.blur_anim_func_id)
|
|
-- self.blur_anim_func_id = nil
|
|
-- end
|
|
-- end
|
|
|
|
-- 直接获取当前目标摄像机的模糊效果(目前模糊样式固定，且直接获取模糊后的图)
|
|
-- callback:必传，第一个参数一定是接收RenderTexture
|
|
-- camera_type:模糊摄像机格式，默认是UI摄像机
|
|
-- function MainCamera:GetCameraBlurScreenShot(callback, camera_type)
|
|
-- if not callback then -- 没有回调，则读取缓存，并跳出本轮模糊
|
|
-- self:CheckCacheBlurList()
|
|
-- return
|
|
-- end
|
|
-- -- 当前正在等待处理的话，则缓存列表
|
|
-- if self.rendering_blur_screenShot then
|
|
-- self.round_robin_cache_list[#self.round_robin_cache_list+1] = {
|
|
-- callback = callback,
|
|
-- camera_type = camera_type,
|
|
-- }
|
|
-- return
|
|
-- end
|
|
-- camera_type = camera_type or MainCamera.EffectCameraType.UICamera
|
|
-- local target_effect, max_downSample
|
|
-- if camera_type == MainCamera.EffectCameraType.MainCamera then
|
|
-- target_effect = self.main_postEffect
|
|
-- max_downSample = self.main_blur_downSample_value
|
|
-- elseif camera_type == MainCamera.EffectCameraType.UICamera then
|
|
-- target_effect = self.ui_postEffect
|
|
-- max_downSample = self.ui_blur_downSample_value
|
|
-- end
|
|
-- local function screenshot_callback(args)
|
|
-- -- 首个参数既是RenderTexture
|
|
-- callback(args and args[0])
|
|
-- -- 状态置false，检查缓存队列中是否有其他模糊请求
|
|
-- self.rendering_blur_screenShot = false
|
|
-- self:CheckCacheBlurList()
|
|
-- end
|
|
-- target_effect:RenderBlurScreenShot(1, max_downSample, screenshot_callback)
|
|
-- self.rendering_blur_screenShot = true
|
|
-- end
|
|
-- -- 缓存模糊需求列表
|
|
-- function MainCamera:CheckCacheBlurList( )
|
|
-- if TableSize(self.round_robin_cache_list) == 0 then return end
|
|
-- if self.check_blur_delay_id then
|
|
-- GlobalTimerQuest:CancelQuest(self.check_blur_delay_id)
|
|
-- self.check_blur_delay_id = nil
|
|
-- end
|
|
-- local function delay_method( )
|
|
-- local data = table.remove(self.round_robin_cache_list, 1)
|
|
-- if data then
|
|
-- self:GetCameraBlurScreenShot(data.callback, data.camera_type)
|
|
-- end
|
|
-- end
|
|
-- -- 下一帧再读取缓存
|
|
-- self.check_blur_delay_id = setTimeout(delay_method, 0.01)
|
|
-- end
|
|
|
|
-- -- 释放RT缓存
|
|
-- function MainCamera:ClearScreenShotCache(rt)
|
|
-- if not IsNull(rt) then
|
|
-- ReleaseTemporary(rt)
|
|
-- end
|
|
-- end
|
|
-- -- （测试用）切换模糊截屏渲染模式
|
|
-- function MainCamera:SwitchToDualBlur(camera_type, use_dual_blur)
|
|
-- camera_type = camera_type or MainCamera.EffectCameraType.UICamera
|
|
-- local target_effect, max_downSample, recurveMaxNum, blurSpread
|
|
-- -- 根据不同的采样shader选取不一样的默认参数
|
|
-- max_downSample = use_dual_blur and 5 or 4
|
|
-- recurveMaxNum = use_dual_blur and 3 or 4
|
|
-- blurSpread = use_dual_blur and 5 or 1
|
|
-- if camera_type == MainCamera.EffectCameraType.MainCamera then
|
|
-- target_effect = self.main_postEffect
|
|
-- self.main_blur_downSample_value = max_downSample
|
|
-- elseif camera_type == MainCamera.EffectCameraType.UICamera then
|
|
-- target_effect = self.ui_postEffect
|
|
-- self.ui_blur_downSample_value = max_downSample
|
|
-- end
|
|
-- target_effect.use_dual_blur = use_dual_blur
|
|
-- target_effect.downSample = max_downSample
|
|
-- target_effect.blurSpread = blurSpread
|
|
-- target_effect.recurveMaxNum = recurveMaxNum
|
|
-- end
|
|
--------------------------------------------高斯模糊相关end--------------------------------------------
|
|
--------------------------------------------屏幕后处理相关end--------------------------------------------
|
|
|
|
function MainCamera:ShowBlackSky( sky_res, target_alpha, step_alpha)
|
|
if self.is_showing_sky_res then
|
|
return
|
|
end
|
|
self.is_showing_sky_res = true
|
|
|
|
local target_alpha = target_alpha
|
|
local step_alpha = step_alpha
|
|
local is_need_alpha = false
|
|
if target_alpha and step_alpha then
|
|
is_need_alpha = true
|
|
end
|
|
|
|
self.black_sky_res = sky_res or "mrsd_skills_skybox01"
|
|
local function load_call_back( objs, is_gameObject )
|
|
if not objs or not objs[0] then
|
|
return
|
|
end
|
|
if self.black_sky_obj then
|
|
destroy(self.black_sky_obj)
|
|
end
|
|
self.black_sky_obj = is_gameObject and objs[0] or newObject(objs[0])
|
|
self.black_sky_transform = self.black_sky_obj.transform
|
|
self.black_sky_transform:SetParent(self.transform)
|
|
self.black_sky_transform.localScale = Vector3.one
|
|
self.black_sky_transform.localPosition = Vector3.zero
|
|
self.black_sky_renders = self.black_sky_obj:GetComponentsInChildren(typeof(UnityEngine.MeshRenderer))
|
|
|
|
if is_need_alpha then
|
|
self.cur_terrain_alpha = self.cur_terrain_alpha or 1
|
|
local function on_alpha_callback( )
|
|
self:SetMainCameraCullingMask(UIPartical.RenderingOther_List.Ground, false)
|
|
self:SetMainCameraCullingMask(UIPartical.RenderingOther_List.Reflection, false)
|
|
end
|
|
self:StartTerrainAlphaTimer(self.cur_terrain_alpha, target_alpha, step_alpha, on_alpha_callback)
|
|
else
|
|
self:SetMainCameraCullingMask(UIPartical.RenderingOther_List.Ground, false)
|
|
self:SetMainCameraCullingMask(UIPartical.RenderingOther_List.Reflection, false)
|
|
end
|
|
end
|
|
LuaResManager:getInstance():loadPrefab(self, self.black_sky_res, self.black_sky_res, load_call_back, false)
|
|
end
|
|
|
|
function MainCamera:HideBlackSky( sky_res, target_alpha, step_alpha)
|
|
if self.terrain_alpha_timer then
|
|
GlobalTimerQuest:CancelQuest(self.terrain_alpha_timer)
|
|
self.terrain_alpha_timer = nil
|
|
end
|
|
if not self.black_sky_obj then
|
|
return
|
|
end
|
|
local target_alpha = target_alpha
|
|
local step_alpha = step_alpha
|
|
local is_need_alpha = false
|
|
if target_alpha and step_alpha then
|
|
is_need_alpha = true
|
|
end
|
|
local function on_hide_callback( )
|
|
if self.black_sky_obj then
|
|
if self.black_sky_res and sky_res == self.black_sky_res then
|
|
lua_resM:AddObjToPool(self, self.black_sky_res, self.black_sky_res, self.black_sky_obj)
|
|
else
|
|
destroy(self.black_sky_obj)
|
|
end
|
|
self.black_sky_obj = nil
|
|
self.black_sky_transform = nil
|
|
end
|
|
self.is_showing_sky_res = false
|
|
end
|
|
|
|
if is_need_alpha then
|
|
self:SetMainCameraCullingMask(UIPartical.RenderingOther_List.Ground, true)
|
|
self:SetMainCameraCullingMask(UIPartical.RenderingOther_List.Reflection, true)
|
|
self.cur_terrain_alpha = self.cur_terrain_alpha or 0
|
|
self:StartTerrainAlphaTimer(self.cur_terrain_alpha, target_alpha, step_alpha, on_hide_callback)
|
|
else
|
|
on_hide_callback()
|
|
self:SetMainCameraCullingMask(UIPartical.RenderingOther_List.Ground, true)
|
|
self:SetMainCameraCullingMask(UIPartical.RenderingOther_List.Reflection, true)
|
|
end
|
|
end
|
|
|
|
function MainCamera:StartTerrainAlphaTimer(cur_value, target_value, step_alpha, call_back)
|
|
if self.terrain_alpha_timer then
|
|
GlobalTimerQuest:CancelQuest(self.terrain_alpha_timer)
|
|
self.terrain_alpha_timer = nil
|
|
end
|
|
local cur_alpha = cur_value or 0
|
|
step_alpha = step_alpha or 0.02
|
|
local target_value = target_value or 1
|
|
local is_add = cur_alpha < target_value
|
|
local function on_step( )
|
|
cur_alpha = is_add and cur_alpha + step_alpha or cur_alpha - step_alpha
|
|
self.cur_terrain_alpha = cur_alpha
|
|
local is_finish = false
|
|
if is_add then
|
|
is_finish = cur_alpha >= target_value
|
|
else
|
|
is_finish = cur_alpha <= target_value
|
|
end
|
|
if is_finish then
|
|
if self.terrain_alpha_timer then
|
|
GlobalTimerQuest:CancelQuest(self.terrain_alpha_timer)
|
|
self.terrain_alpha_timer = nil
|
|
end
|
|
|
|
self:SetTerrainAlpha(target_value)
|
|
if call_back then
|
|
call_back()
|
|
end
|
|
else
|
|
self:SetTerrainAlpha(cur_alpha)
|
|
end
|
|
end
|
|
self.terrain_alpha_timer = GlobalTimerQuest:AddPeriodQuest(on_step, 0.02, -1)
|
|
on_step()
|
|
end
|
|
|
|
function MainCamera:SetTerrainAlpha( value )
|
|
self.cur_terrain_alpha = value
|
|
Shader.SetGlobalFloat("_GlobalSceneAlpha", value)
|
|
end
|
|
|
|
function MainCamera:GetMovieCamera( )
|
|
if not self.story_camera then
|
|
self.story_camera = self.story_cam_obj:GetComponent("Camera")
|
|
end
|
|
self.story_camera.fieldOfView = self.camera_curr_size
|
|
self.story_camera.transform.localRotation = Quaternion.Euler(SceneCameraRotate,0,0)
|
|
SetLocalPosition(self.story_camera.transform,0,0,-CameraDistanceWithMainRole)
|
|
return self.story_cam_obj, self.story_camera
|
|
end
|
|
|
|
function MainCamera:AddCameraAction( ab_name, res_name, action_name, call_back )
|
|
local function load_finish_func(objs, is_gameObject)
|
|
if not objs or not objs[0] then
|
|
return
|
|
end
|
|
local main_role = Scene.Instance:GetMainRole()
|
|
if main_role and not main_role:IsInState(PoseState.STORY) then
|
|
return
|
|
end
|
|
local temp_controller = objs[0]
|
|
if not self.story_camera then
|
|
self.story_camera = self.story_cam_obj:GetComponent("Camera")
|
|
self.story_camera.enabled = true
|
|
end
|
|
self.story_camera.fieldOfView = 22
|
|
self.story_camera.depth = 6
|
|
self.story_cam_obj.transform.localRotation = Quaternion.Euler(0,0,0)
|
|
SetLocalPosition(self.story_cam_obj.transform,0,0,0)
|
|
self.story_cam_obj:SetActive(true)
|
|
if not self.camera_animator then
|
|
self.camera_animator = self.story_cam_obj:AddComponent(typeof(UnityEngine.Animator))
|
|
end
|
|
self.camera_animator.runtimeAnimatorController = temp_controller
|
|
self.camera_animator:CrossFade(action_name, 0)
|
|
if call_back then
|
|
call_back()
|
|
end
|
|
end
|
|
lua_resM:loadObject(self, ab_name, res_name, load_finish_func)
|
|
end
|
|
|
|
function MainCamera:RemoveCameraAction( )
|
|
if self.camera_animator then
|
|
destroy(self.camera_animator)
|
|
self.camera_animator = false
|
|
end
|
|
if self.story_cam_obj then
|
|
SetLocalPosition(self.story_cam_obj.transform, 0, 0, 0)
|
|
self.story_cam_obj.transform.localRotation = Quaternion.Euler(0,0,0)
|
|
end
|
|
if self.story_cam_obj then
|
|
self.story_cam_obj:SetActive(false)
|
|
end
|
|
end
|
|
|
|
--------------------- 剧情摄像机径向模糊相关 start ---------------------
|
|
-- 启动径向模糊
|
|
function MainCamera:EnableStoryCameraRadiusBlur(show)
|
|
if self.story_radiusBlur then
|
|
self.story_radiusBlur.enabled = show
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
-- 设置径向模糊的中心点和模糊半径 中心点坐标范围0~1 模糊半径范围 0~0.03
|
|
function MainCamera:SetStoryCameraRadiusData(centerX, centerY, radius_offset)
|
|
if self.story_radiusBlur then
|
|
-- 获取默认值
|
|
local cur_blurData = self.story_radiusBlur.radius_data
|
|
centerX = centerX or cur_blurData.x
|
|
Clamp(centerX, 0, 1)
|
|
centerY = centerY or cur_blurData.y
|
|
Clamp(centerY, 0, 1)
|
|
radius_offset = radius_offset or cur_blurData.z
|
|
Clamp(radius_offset, 0, 0.03)
|
|
|
|
self.story_radiusBlur.radius_data = Vector3(centerX, centerY, radius_offset)
|
|
end
|
|
end
|
|
-- 设置径向模糊的迭代次数
|
|
function MainCamera:SetStoryCameraRadiusIteration(iteration)
|
|
if self.story_radiusBlur then
|
|
-- 获取默认值
|
|
local cur_iteration = self.story_radiusBlur.iteration
|
|
iteration = iteration or cur_iteration
|
|
Clamp(iteration, 1, 30)
|
|
|
|
self.story_radiusBlur.iteration = iteration
|
|
end
|
|
end
|
|
--------------------- 剧情摄像机径向模糊相关 end ---------------------
|
|
|
|
function MainCamera:ResetAutoRotateInfo( )
|
|
MainCamera.role_last_angle = 0
|
|
MainCamera.role_cur_angle = 0
|
|
MainCamera.role_angle_off = 0
|
|
MainCamera.role_from_camera_angle = 0
|
|
MainCamera.role_last_rotate_area = false
|
|
MainCamera.camera_cur_angle = 0
|
|
MainCamera.camera_target_angle = 0
|
|
MainCamera.camera_enable_rotate = false
|
|
if not IsNull(self.transform) then
|
|
SetLocalRotation(self.transform)
|
|
end
|
|
end
|