[FE] VR PC (OPEN SOUrSe)

 RS = :()
 RunService = :()
 UIS = :()
 CAS = :()
 TweenService = :()
 Players = :()

 plr = Players.LocalPlayer
 cam = .CurrentCamera

 .NexusVRPC_Cleanup 
	(.NexusVRPC_Cleanup)


 remote
(()
	 m = RS:(, )
	remote = m:(, )
	 ready = m:()
	 ready 
		ready:()
	
)

 CFG = {
	sendRate =  / ,
	smooth = ,
	reach = ,
	reachLong = ,
	depth = ,
	depthMin = ,
	depthMax = ,
	gripWidth = ,
	rollSpeed = ,
	maxRecord = ,
}

 S = {
	enabled = ,
	autoReturn = ,
	headLook = ,
	longReach = ,
	noclip = ,
	hud = ,
	help = ,
	recording = ,
	playing = ,
}

 sin, cos, exp, clamp, abs = .sin, .cos, .exp, .clamp, .abs
 V3 = .new
 DOWN = (, -, )

 conns = {}
  (signal, fn)
	conns[#conns + ] = signal:(fn)


  (sign)
	 rest = (sign * , -, -)
	 {
		sign = sign,
		shoulder = (sign * , , ),
		rest = rest,
		pos = rest,
		vel = (, , ),
		target = rest,
		roll = ,
		rollTarget = ,
		depth = CFG.depth,
		pinned = ,
		cf = .(rest),
		dir = DOWN,
	}


 hands = {L = (-), R = ()}
 currentMode = 
 headSmooth = 
 state = {valid = , rootCF = .(), headCF = .(), dirL = DOWN, dirR = DOWN}
 slots = {}
 rec = {frames = {}, t = }
 play = {t = , i = }

  (class, props, parent)
	 o = .(class)
	 k, v  (props) 
		o[k] = v
	
	o.Parent = parent
	 o


  ()
	 gethui 
		 ok, g = (gethui)
		 ok  g 
			 g
		
	
	 ok, core = (()
		 :()
	)
	 ok  core 
		 tested = (()
			 t = .()
			t.Parent = core
			t:()
		)
		 tested 
			 core
		
	
	 plr:()


 parentGui = ()
 parentGui:() 
	parentGui.NexusVR_PC:()


 gui = (, {
	Name = ,
	ResetOnSpawn = ,
	DisplayOrder = ,
	IgnoreGuiInset = ,
}, parentGui)

 panel = (, {
	Size = .(, ),
	Position = .(, ),
	BackgroundColor3 = .(, , ),
	BackgroundTransparency = ,
	BorderSizePixel = ,
}, gui)
(, {CornerRadius = .(, )}, panel)
(, {Color = .(, , ), Transparency = , Thickness = }, panel)

 statusLabel = (, {
	Size = .(, -, , -),
	Position = .(, ),
	BackgroundTransparency = ,
	TextXAlignment = .TextXAlignment.Left,
	TextYAlignment = .TextYAlignment.Top,
	RichText = ,
	Font = .Font.Code,
	TextSize = ,
	TextColor3 = .(, , ),
	Text = ,
}, panel)

 helpPanel = (, {
	Size = .(, ),
	Position = .(, ),
	BackgroundColor3 = .(, , ),
	BackgroundTransparency = ,
	BorderSizePixel = ,
	Visible = ,
}, gui)
(, {CornerRadius = .(, )}, helpPanel)
(, {Color = .(, , ), Transparency = , Thickness = }, helpPanel)

 helpLines = {
	,
	,
	,
	,
	,
	,
	,
	,
	,
	,
	,
	,
	,
	,
	,
}

(, {
	Size = .(, -, , -),
	Position = .(, ),
	BackgroundTransparency = ,
	TextXAlignment = .TextXAlignment.Left,
	TextYAlignment = .TextYAlignment.Top,
	RichText = ,
	Font = .Font.Code,
	TextSize = ,
	TextColor3 = .(, , ),
	Text = .(helpLines, ),
}, helpPanel)

  (color, letter)
	 f = (, {
		Size = .(, ),
		AnchorPoint = .(, ),
		BackgroundColor3 = color,
		BackgroundTransparency = ,
		BorderSizePixel = ,
		Visible = ,
	}, gui)
	(, {CornerRadius = .(, )}, f)
	(, {Color = color, Thickness = , Transparency = }, f)
	(, {
		Size = .(, ),
		BackgroundTransparency = ,
		Text = letter,
		TextColor3 = .(, , ),
		TextSize = ,
		Font = .Font.GothamBold,
	}, f)
	 f


 markerL = (.(, , ), )
 markerR = (.(, , ), )

 toast = (, {
	Size = .(, ),
	AnchorPoint = .(, ),
	Position = .(, , , -),
	BackgroundTransparency = ,
	TextColor3 = .(, , ),
	TextStrokeTransparency = ,
	TextTransparency = ,
	Font = .Font.GothamBold,
	TextSize = ,
	Text = ,
}, gui)

 toastId = 
  (text)
	toastId = toastId + 
	 id = toastId
	toast.Text = text
	toast.TextTransparency = 
	toast.TextStrokeTransparency = 
	.(, ()
		 id == toastId  toast.Parent 
			TweenService:(toast, TweenInfo.(), {TextTransparency = , TextStrokeTransparency = }):()
		
	)


  (m)
	 m ==  
		 
	 m ==  
		 
	 m ==  
		 
	 m ==  
		 
	
	 


  ()
	 on = S.enabled    
	 lines = {
		 .. on,
		 .. (currentMode),
		.(, hands.L.depth, hands.R.depth),
		.(, CFG.smooth, CFG.gripWidth),
		 .. (S.autoReturn    ),
		 .. (S.headLook    ),
		 .. (S.longReach    ),
	}
	 S.recording 
		lines[#lines + ] = .(, rec.t)
	 S.playing 
		lines[#lines + ] = 
	  remote 
		lines[#lines + ] = 
	
		lines[#lines + ] = 
	
	statusLabel.Text = .(lines, )


  (from, to)
	 dot = (from:(to), -, )
	 axis = from:(to)
	 axis.Magnitude <  
		 dot >  
			 .()
		
		 .(.xAxis, .pi)
	
	 .(axis.Unit, .(dot))


 joints = {}
  (char)
	 joints.char == char  joints.neck  joints.neck.Parent 
		
	
	joints.char = char
	joints.neck = char:(, )
	joints.L = char:(, )  char:(, )
	joints.R = char:(, )  char:(, )


  ()
	  S.enabled   state.valid 
		
	
	 char = plr.Character
	  char 
		
	
	(char)
	 n, l, r = joints.neck, joints.L, joints.R
	 n  n.Part0 
		n.Transform = n.C0.Rotation:() * n.Part0.CFrame.Rotation:() * state.headCF.Rotation * n.C1.Rotation
	
	 l  l.Part0 
		 fr = l.Part0.CFrame * l.C0
		l.Transform = (DOWN, fr:(state.dirL))
	
	 r  r.Part0 
		 fr = r.Part0.CFrame * r.C0
		r.Transform = (DOWN, fr:(state.dirR))
	


  ()
	 char = plr.Character
	  char 
		
	
	(char)
	 _, j  ({joints.neck, joints.L, joints.R}) 
		 j 
			j.Transform = .()
		
	


  (k)
	 UIS:(k)   UIS:()


  ()
	 (.KeyCode.G) 
		 
	
	 (.KeyCode.F) 
		 
	
	 l, r = (.KeyCode.Q), (.KeyCode.E)
	 l  r 
		 
	
	 l 
		 
	
	 r 
		 
	
	 


  (h, p)
	 v = p - h.shoulder
	 maxR = S.longReach  CFG.reachLong  CFG.reach
	 v.Magnitude > maxR 
		v = v.Unit * maxR
	
	 h.shoulder + v


  (h, target, dt)
	 w = CFG.smooth
	 e = (-w * dt)
	 x = h.pos - target
	 tmp = h.vel + x * w
	h.pos = target + (x + tmp * dt) * e
	h.vel = (h.vel - tmp * w * dt) * e
	h.roll = h.roll + (h.rollTarget - h.roll) * ( - (-w * dt))


  (h)
	 v = h.pos - h.shoulder
	 dir = v.Magnitude >   v.Unit  DOWN
	h.dir = dir
	 up = (dir.Y) >   (, , -)  .yAxis
	h.cf = .(h.pos, h.pos + dir, up) * .(, , h.roll)


  (n)
	slots[n] = {
		L = {pos = hands.L.pos, roll = hands.L.roll},
		R = {pos = hands.R.pos, roll = hands.R.roll},
	}
	( .. n .. )


  (n)
	 s = slots[n]
	  s 
		( .. n .. )
		
	
	 k, h  (hands) 
		h.target = s[k].pos
		h.rollTarget = s[k].roll
		h.pinned = 
	
	( .. n .. )


  ()
	rec.frames = {}
	rec.t = 
	S.recording = 
	S.playing = 
	()


  ()
	S.recording = 
	( .. #rec.frames .. )


  ()
	 #rec.frames <  
		()
		
	
	S.playing = 
	S.recording = 
	play.t = 
	play.i = 
	()


  (tm)
	 f = rec.frames
	 n = #f
	 i = play.i
	 i > n -  
		i = 
	
	 i < n -   f[i + ].t < tm 
		i = i + 
	
	play.i = i
	 a, b = f[i], f[i + ]
	 span = .(b.t - a.t, )
	 a, b, ((tm - a.t) / span, , )


  ()
	 _, h  (hands) 
		h.target = h.rest
		h.rollTarget = 
		h.depth = CFG.depth
		h.pinned = 
	
	S.recording = 
	S.playing = 
	()


  ()
	S.enabled =  S.enabled
	  S.enabled 
		state.valid = 
		()
	
	(S.enabled    )


(UIS.InputBegan, (input)
	 input.UserInputType ~= .UserInputType.Keyboard 
		
	
	 UIS:() 
		
	
	 k = input.KeyCode
	 ctrl = UIS:(.KeyCode.LeftControl)  UIS:(.KeyCode.RightControl)
	 k == .KeyCode.V 
		()
	 k == .KeyCode.T 
		S.autoReturn =  S.autoReturn
		(S.autoReturn    )
	 k == .KeyCode.L 
		S.headLook =  S.headLook
		(S.headLook    )
	 k == .KeyCode.X 
		S.longReach =  S.longReach
		(S.longReach    )
	 k == .KeyCode.N 
		S.noclip =  S.noclip
		(S.noclip    )
	 k == .KeyCode.H 
		S.help =  S.help
		helpPanel.Visible = S.help  S.hud
	 k == .KeyCode.U 
		S.hud =  S.hud
		panel.Visible = S.hud
		helpPanel.Visible = S.hud  S.help
	 k == .KeyCode.Y 
		()
	 k == .KeyCode.R   ctrl 
		 S.recording 
			()
		
			()
		
	 k == .KeyCode.P 
		 S.playing 
			S.playing = 
			()
		
			()
		
	 k == .KeyCode.LeftBracket 
		CFG.smooth = (CFG.smooth - , , )
	 k == .KeyCode.RightBracket 
		CFG.smooth = (CFG.smooth + , , )
	 k == .KeyCode.One  k == .KeyCode.Two  k == .KeyCode.Three 
		 n = k == .KeyCode.One    (k == .KeyCode.Two    )
		 ctrl 
			(n)
		
			(n)
		
	
)

CAS:(, (_, inputState, input)
	  S.enabled   currentMode 
		 .ContextActionResult.Pass
	
	 inputState ~= .UserInputState.Change 
		 .ContextActionResult.Sink
	
	 dz = input.Position.Z
	 UIS:(.KeyCode.LeftShift)  currentMode ==  
		CFG.gripWidth = (CFG.gripWidth + dz * , , )
	
		 d = dz * 
		  (h)
			h.depth = (h.depth + d, CFG.depthMin, CFG.depthMax)
		
		 currentMode ==  
			(hands.L)
		 currentMode ==  
			(hands.R)
		
			(hands.L)
			(hands.R)
		
	
	 .ContextActionResult.Sink
, , .ContextActionPriority.High.Value, .UserInputType.MouseWheel)

 lastSend = 
 statusAcc = 

(RunService.RenderStepped, (dt)
	dt = .(dt, )
	cam = .CurrentCamera
	statusAcc = statusAcc + dt
	 statusAcc >=  
		statusAcc = 
		()
	

	 char = plr.Character
	 root = char  char:()
	  root   S.enabled 
		state.valid = 
		markerL.Visible = 
		markerR.Visible = 
		
	

	 now = .()
	 rootCF = root.CFrame
	 chest = rootCF.Position + rootCF.UpVector * 
	 loc = UIS:()
	 ray = cam:(loc.X, loc.Y)

	  (depth)
		 s = (chest - ray.Origin):(ray.Direction) + depth
		 rootCF:(ray.Origin + ray.Direction * s)
	

	 mode = ()
	currentMode = mode
	 activeL = mode ==   mode ==   mode == 
	 activeR = mode ==   mode ==   mode == 

	 mode ==  
		hands.L.target = (hands.L, (hands.L.depth))
	 mode ==  
		hands.R.target = (hands.R, (hands.R.depth))
	 mode ==  
		 p = ((hands.L.depth + hands.R.depth) / )
		 rv = rootCF:(cam.CFrame.RightVector)
		hands.L.target = (hands.L, p - rv * (CFG.gripWidth / ))
		hands.R.target = (hands.R, p + rv * (CFG.gripWidth / ))
	 mode ==  
		 p = (hands.R.depth)
		 x = .((p.X), )
		hands.R.target = (hands.R, (x, p.Y, p.Z))
		hands.L.target = (hands.L, (-x, p.Y, p.Z))
	

	 rd = ((.KeyCode.Z)  -  ) + ((.KeyCode.C)    )
	 k, h  (hands) 
		 active = (k ==   activeL)  (k ==   activeR)
		 active 
			h.pinned = 
			 rd ~=  
				h.rollTarget = h.rollTarget + rd * CFG.rollSpeed * dt
			
		 S.autoReturn   h.pinned   S.playing 
			h.target = h.rest
			h.rollTarget = 
		
	

	 S.recording 
		rec.t = rec.t + dt
		rec.frames[#rec.frames + ] = {
			t = rec.t,
			L = {pos = hands.L.target, roll = hands.L.rollTarget},
			R = {pos = hands.R.target, roll = hands.R.rollTarget},
		}
		 rec.t >= CFG.maxRecord 
			()
		
	

	 S.playing 
		play.t = play.t + dt
		 total = rec.frames[#rec.frames].t
		 play.t > total 
			play.t = play.t - total
			play.i = 
		
		 a, b, al = (play.t)
		 k, h  (hands) 
			 active = (k ==   activeL)  (k ==   activeR)
			  active 
				h.target = a[k].pos:(b[k].pos, al)
				h.rollTarget = a[k].roll + (b[k].roll - a[k].roll) * al
				h.pinned = 
			
		
	

	 phase = 
	 _, h  (hands) 
		 sway = (, (now *  + phase) * , (now *  + phase) * )
		(h, h.target + sway, dt)
		(h)
		phase = phase + 
	

	 headPos = rootCF.Position + (, , )
	 headTarget
	 S.headLook 
		headTarget = .(headPos, headPos + ray.Direction)
	
		headTarget = .(headPos) * cam.CFrame.Rotation
	
	 S.headLook  headSmooth 
		headSmooth = headSmooth:(headTarget,  - (-dt * ))
	
		headSmooth = headTarget
	

	state.valid = 
	state.rootCF = rootCF
	state.headCF = headSmooth
	state.dirL = rootCF:(hands.L.dir)
	state.dirR = rootCF:(hands.R.dir)

	()

	 remote  now - lastSend >= CFG.sendRate 
		lastSend = now
		remote:(headSmooth, rootCF * hands.L.cf, rootCF * hands.R.cf)
	

	 S.hud 
		 pl, onL = cam:(rootCF:(hands.L.pos))
		 pr, onR = cam:(rootCF:(hands.R.pos))
		markerL.Visible = onL
		markerR.Visible = onR
		markerL.Position = .(pl.X, pl.Y)
		markerR.Position = .(pr.X, pr.Y)
		markerL.BackgroundTransparency = activeL    
		markerR.BackgroundTransparency = activeR    
	
		markerL.Visible = 
		markerR.Visible = 
	
)

 ncAcc = 
(RunService.Stepped, (_, dt)
	()
	 S.noclip 
		ncAcc = ncAcc + dt
		 ncAcc >=  
			ncAcc = 
			 _, other  (Players:()) 
				 other ~= plr  other.Character 
					 _, p  (other.Character:()) 
						 p:() 
							p.CanCollide = 
						
					
				
			
		
	
)

.NexusVRPC_Cleanup = ()
	 _, c  (conns) 
		c:()
	
	CAS:()
	S.enabled = 
	()
	 gui 
		gui:()
	
	.NexusVRPC_Cleanup = 


()
()