Vox 1.7 - Pastebin.com (2024)

  1. Updated 1.7 Voxiom Hacking script:

  2. // ==UserScript==

  3. // @name Voxiom.IO Aimbot, ESP & X-Ray

  4. // @namespace http://tampermonkey.net/

  5. // @version 1.7

  6. // @description Let's you see players and items behind walls in voxiom.io. Comes with an aimbot that locks aim at nearest enemy and auto fires at them. Also shows ores and names of the items that are far far away. NoAds

  7. // @author Zertalious (ads removed by me: Cqmbo__)

  8. // @match *://voxiom.io/*

  9. // @icon https://www.google.com/s2/favicons?sz=64&domain=voxiom.io

  10. // @grant none

  11. // @run-at document-start

  12. // @require https://unpkg.com/three@latest/build/three.min.js

  13. // @require https://cdn.jsdelivr.net/npm/lil-gui@0.19

  14. // @license MIT

  15. // @downloadURL

  16. // @updateURL

  17. // ==/UserScript==

  18. const THREE = window.THREE;

  19. Object.defineProperty( window, 'THREE', {

  20. get() {

  21. return undefined;

  22. }

  23. } );

  24. const settings = {

  25. showPlayers: true,

  26. showItems: true,

  27. showItemNames: false,

  28. showBlocks: true,

  29. showLines: true,

  30. showOres: true,

  31. worldWireframe: false,

  32. aimbotEnabled: true,

  33. aimbotOnRightMouse: false,

  34. aimBehindWalls: false,

  35. aimHeight: 0.9,

  36. autoFire: true,

  37. createdBy: 'Cqmbo__ (Thx Zert)',

  38. removedAds: 'Me',

  39. V: 'to show/hide players',

  40. I: 'to show/hide items',

  41. N: 'to show/hide item names',

  42. L: 'to show/hide blocks',

  43. H: 'to show/hide help',

  44. B: 'to toggle aimbot.',

  45. T: 'to toggle aimbot on right mouse.',

  46. K: 'to toggle aimbot auto fire',

  47. slash: 'to toggle control panel',

  48. semicolon: 'toggle wireframe',

  49. comma: 'toggle show & hide ores',

  50. showHelp() {

  51. dialogEl.style.display = dialogEl.style.display === '' ? 'none' : '';

  52. }

  53. };

  54. const gui = new lil.GUI();

  55. const controllers = {};

  56. for ( const key in settings ) {

  57. controllers[ key ] = gui.add( settings, key ).name( fromCamel( key ) ).listen();

  58. }

  59. controllers.aimHeight.min( 0 ).max( 1.5 );

  60. controllers.createdBy.disable();

  61. controllers.removedAds.disable();

  62. controllers.V.disable();

  63. controllers.I.disable();

  64. controllers.N.disable();

  65. controllers.L.disable();

  66. controllers.H.disable();

  67. controllers.B.disable();

  68. controllers.T.disable();

  69. controllers.K.disable();

  70. controllers.slash.disable();

  71. controllers.semicolon.disable();

  72. controllers.comma.disable();

  73. function fromCamel( text ) {

  74. const result = text.replace( /([A-Z])/g, ' $1' );

  75. return result.charAt( 0 ).toUpperCase() + result.slice( 1 );

  76. }

  77. let isRightDown = false;

  78. window.addEventListener( 'mousedown', event => {

  79. if ( event.button === 2 ) isRightDown = true;

  80. } );

  81. window.addEventListener( 'mouseup', event => {

  82. if ( event.button === 2 ) isRightDown = false;

  83. } );

  84. const geometry = new THREE.EdgesGeometry( new THREE.BoxGeometry( 1, 1, 1 ).translate( 0, 0.5, 0 ) );

  85. const camera = new THREE.PerspectiveCamera( 60, window.innerWidth / window.innerHeight, 0.1, 1000 );

  86. const renderer = new THREE.WebGLRenderer( {

  87. alpha: true,

  88. antialias: true

  89. } );

  90. renderer.setPixelRatio( window.devicePixelRatio );

  91. renderer.setSize( window.innerWidth, window.innerHeight );

  92. renderer.domElement.id = 'overlayCanvas';

  93. window.addEventListener( 'resize', () => {

  94. renderer.setSize( window.innerWidth, window.innerHeight );

  95. } );

  96. const WebGL = WebGLRenderingContext.prototype;

  97. const blocks = [

  98. [ 0, 3 ],

  99. [ 1, 3 ],

  100. [ 4, 2 ],

  101. [ 5, 2 ],

  102. [ 7, 3 ],

  103. [ 0, 4 ], [ 1, 4 ], [ 2, 4 ],

  104. [ 0, 5 ], [ 1, 5 ], [ 2, 5 ],

  105. [ 0, 6 ], [ 1, 6 ], [ 2, 6 ]

  106. ];

  107. const blockCheck = blocks.map( ( [ x, y ] ) => `( p.x == ${x.toFixed( 1 )} && p.y == ${y.toFixed( 1 )} )` ).join( ' || ' );

  108. WebGL.shaderSource = new Proxy( WebGL.shaderSource, {

  109. apply( target, thisArgs, args ) {

  110. let [ shader, src ] = args;

  111. if ( src.indexOf( 'vRealUv = realUv;' ) > - 1 ) {

  112. src = src.replace( 'void main()', `

  113. uniform bool showOres;

  114. uniform float currTime;

  115. void main()` )

  116. .replace( 'vRealUv = realUv;', `vRealUv = realUv;

  117. float atlasDim = 16.0;

  118. float tilePosX = max(0.01, min(0.99, fract(vRealUv.z)));

  119. float tilePosY = max(0.01, min(0.99, fract(vRealUv.w)));

  120. vec2 uv = vec2(vRealUv.x * (1.0 / atlasDim) + tilePosX * (1.0 / atlasDim), vRealUv.y * (1.0 / atlasDim) + tilePosY * (1.0 / atlasDim));

  121. if ( showOres ) {

  122. vec2 p = uv * ( atlasDim - 1.0 );

  123. p.x = fract( p.x ) > 0.5 ? ceil( p.x ) : floor( p.x );

  124. p.y = fract( p.y ) > 0.5 ? ceil( p.y ) : floor( p.y );

  125. if ( ${blockCheck} ) {

  126. gl_Position.z = 0.99;

  127. vAo += 0.25 + abs( sin( currTime * 2.0 ) ) * 0.5;

  128. }

  129. }

  130. ` );

  131. shader.isChunkShader = true;

  132. }

  133. args[ 1 ] = src;

  134. return Reflect.apply( ...arguments );

  135. }

  136. } );

  137. WebGL.attachShader = new Proxy( WebGL.attachShader, {

  138. apply( target, thisArgs, [ program, shader ] ) {

  139. if ( shader.isChunkShader ) program.isChunkProgram = true;

  140. return Reflect.apply( ...arguments );

  141. }

  142. } );

  143. WebGL.useProgram = new Proxy( WebGL.useProgram, {

  144. apply( target, gl, [ program ] ) {

  145. Reflect.apply( ...arguments );

  146. if ( program.isChunkProgram ) {

  147. if ( ! program.initialized ) {

  148. program.uniforms = {

  149. showOres: gl.getUniformLocation( program, 'showOres' ),

  150. currTime: gl.getUniformLocation( program, 'currTime' )

  151. };

  152. program.initialized = true;

  153. }

  154. gl.uniform1i( program.uniforms.showOres, settings.showOres );

  155. gl.uniform1f( program.uniforms.currTime, performance.now() / 1000 );

  156. }

  157. }

  158. } );

  159. function MyMaterial( color ) {

  160. return new THREE.RawShaderMaterial( {

  161. vertexShader: `

  162. attribute vec3 position;

  163. uniform mat4 projectionMatrix;

  164. uniform mat4 modelViewMatrix;

  165. void main() {

  166. gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );

  167. gl_Position.z = 1.0;

  168. }

  169. `,

  170. fragmentShader: `

  171. precision mediump float;

  172. uniform vec3 color;

  173. void main() {

  174. gl_FragColor = vec4( color, 1.0 );

  175. }

  176. `,

  177. uniforms: {

  178. color: { value: new THREE.Color( color ) }

  179. }

  180. } );

  181. }

  182. let target;

  183. let gameCamera;

  184. WeakMap.prototype.set = new Proxy( WeakMap.prototype.set, {

  185. apply( target, thisArgs, [ object ] ) {

  186. if ( object && typeof object === 'object' ) {

  187. if ( object.hasOwnProperty( 'background' ) && ! object.isMyScene ) checkScene( object );

  188. if ( typeof object.aspect === 'number' && object !== camera ) {

  189. object.projectionMatrix = new Proxy( object.projectionMatrix, {

  190. get() {

  191. setTransform( camera, object );

  192. camera.near = object.near;

  193. camera.far = object.far;

  194. camera.aspect = object.aspect;

  195. camera.fov = object.fov;

  196. camera.updateProjectionMatrix();

  197. gameCamera = object;

  198. return Reflect.get( ...arguments );

  199. }

  200. } );

  201. }

  202. }

  203. return Reflect.apply( ...arguments );

  204. }

  205. } );

  206. function setTransform( targetObject, sourceObject ) {

  207. const matrix = new THREE.Matrix4().fromArray( sourceObject.matrixWorld.toArray() );

  208. matrix.decompose( targetObject.position, targetObject.quaternion, targetObject.scale );

  209. }

  210. let worldScene;

  211. let childrenKey;

  212. function checkScene( scene ) {

  213. for ( const key in scene ) {

  214. const children = scene[ key ];

  215. if ( Array.isArray( children ) && children.length === 9 ) {

  216. for ( const child of children ) {

  217. if ( typeof child !== 'object' || ! child.hasOwnProperty( 'uuid' ) ) return;

  218. }

  219. worldScene = scene;

  220. childrenKey = key;

  221. return;

  222. }

  223. }

  224. }

  225. function isBlock( entity ) {

  226. try {

  227. const mesh = entity[ childrenKey ][ 0 ];

  228. return mesh.geometry.index.count === 36;

  229. } catch {

  230. return false;

  231. }

  232. }

  233. function isPlayer( entity ) {

  234. try {

  235. return entity[ childrenKey ].length > 2 || ! entity[ childrenKey ][ 1 ].geometry;

  236. } catch {

  237. return false;

  238. }

  239. }

  240. function isEnemy( entity ) {

  241. for ( const child of entity[ childrenKey ] ) {

  242. try {

  243. if ( child.material.map.image instanceof HTMLCanvasElement ) return false;

  244. } catch {}

  245. }

  246. return true;

  247. }

  248. const chunkMaterial = new THREE.MeshNormalMaterial();

  249. const raycaster = new THREE.Raycaster();

  250. const direction = new THREE.Vector3();

  251. const line = new THREE.LineSegments( new THREE.BufferGeometry(), MyMaterial( 'red' ) );

  252. line.frustumCulled = false;

  253. const linePositions = new THREE.BufferAttribute( new Float32Array( 200 * 2 * 3 ), 3 );

  254. line.geometry.setAttribute( 'position', linePositions );

  255. function animate() {

  256. window.requestAnimationFrame( animate );

  257. if ( typeof shouldShowAd !== 'boolean' || shouldShowAd !== false) return;

  258. if ( ! worldScene ) return;

  259. const now = Date.now();

  260. const scene = new THREE.Scene();

  261. scene.isMyScene = true;

  262. const rawChunks = worldScene[ childrenKey ][ 4 ][ childrenKey ];

  263. const chunks = [];

  264. for ( const chunk of rawChunks ) {

  265. if ( ! chunk.geometry ) continue;

  266. let myChunk = chunk.myChunk;

  267. if ( ! myChunk ) {

  268. const positionArray = chunk.geometry.attributes.position.array;

  269. if ( positionArray.length === 0 ) continue;

  270. const geometry = new THREE.BufferGeometry();

  271. geometry.setAttribute(

  272. 'position',

  273. new THREE.BufferAttribute( positionArray, 3 )

  274. );

  275. geometry.setIndex(

  276. new THREE.BufferAttribute( chunk.geometry.index.array, 1 )

  277. );

  278. geometry.computeVertexNormals();

  279. geometry.computeBoundingBox();

  280. myChunk = new THREE.Mesh( geometry, chunkMaterial );

  281. myChunk.box = new THREE.Box3();

  282. chunk.myChunk = myChunk;

  283. }

  284. if ( chunk.material ) chunk.material.wireframe = settings.worldWireframe;

  285. setTransform( myChunk, chunk );

  286. myChunk.updateMatrixWorld();

  287. myChunk.box.copy( myChunk.geometry.boundingBox ).applyMatrix4( myChunk.matrixWorld );

  288. chunks.push( myChunk );

  289. }

  290. chunks.sort( ( a, b ) => {

  291. return camera.position.distanceTo( a.position ) - camera.position.distanceTo( b.position );

  292. } );

  293. let lineCounter = 0;

  294. const lineOrigin = camera.localToWorld( new THREE.Vector3( 0, 4, - 10 ) );

  295. const entities = worldScene[ childrenKey ][ 5 ][ childrenKey ];

  296. let targetPlayer;

  297. let minDistance = Infinity;

  298. for ( let i = 0; i < entities.length; i ++ ) {

  299. const entity = entities[ i ];

  300. if ( entity[ childrenKey ].length === 0 ) continue;

  301. if ( ! entity.myContainer ) {

  302. entity.myContainer = new THREE.Object3D();

  303. entity.discoveredAt = now;

  304. }

  305. if ( now - entity.discoveredAt < 500 ) continue;

  306. if ( ! entity.myBox ) {

  307. const box = new THREE.LineSegments( geometry );

  308. // const name = entity[ childrenKey ][ 0 ].name;

  309. const name = entity.name;

  310. if ( isPlayer( entity ) ) {

  311. entity.isPlayer = true;

  312. entity.isEnemy = isEnemy( entity );

  313. box.material = MyMaterial( entity.isEnemy ? 'red' : 'lime' );

  314. box.scale.set( 0.5, 1.25, 0.5 );

  315. } else {

  316. // entity.isBlock = name === 'BlockModel';

  317. entity.isBlock = isBlock( entity );

  318. box.material = MyMaterial( entity.isBlock ? 'green' : 'gold' );

  319. box.scale.setScalar( 0.25, 0.1, 0.25 );

  320. if ( entity.isBlock === false ) {

  321. const fontSize = 40;

  322. const strokeSize = 8;

  323. const font = 'bolder ' + fontSize + 'px Arial';

  324. const canvas = document.createElement( 'canvas' );

  325. const ctx = canvas.getContext( '2d' );

  326. ctx.font = font;

  327. canvas.width = ctx.measureText( name ).width + strokeSize * 2;

  328. canvas.height = fontSize + strokeSize * 2;

  329. ctx.font = font;

  330. ctx.fillStyle = 'white';

  331. ctx.textBaseline = 'top';

  332. ctx.textAlign = 'left';

  333. ctx.lineWidth = strokeSize;

  334. ctx.strokeText( name, strokeSize, strokeSize );

  335. ctx.fillText( name, strokeSize, strokeSize );

  336. const sprite = new THREE.Sprite( new THREE.SpriteMaterial( {

  337. map: new THREE.CanvasTexture( canvas ),

  338. sizeAttenuation: false,

  339. fog: false,

  340. depthTest: false,

  341. depthWrite: false

  342. } ) );

  343. sprite.scale.y = 0.035;

  344. sprite.scale.x = sprite.scale.y * canvas.width / canvas.height;

  345. sprite.position.y = sprite.scale.y + 0.1;

  346. entity.mySprite = sprite;

  347. entity.myContainer.add( entity.mySprite );

  348. }

  349. }

  350. entity.myBox = box;

  351. entity.myContainer.add( entity.myBox );

  352. }

  353. if ( entity.isPlayer ) {

  354. entity.myBox.visible = settings.showPlayers;

  355. } else if ( entity.isBlock ) {

  356. entity.myBox.visible = settings.showBlocks;

  357. } else {

  358. entity.myBox.visible = settings.showItems;

  359. entity.mySprite.visible = settings.showItemNames;

  360. }

  361. if ( typeof entity.visible === 'boolean' && ! entity.visible ) continue;

  362. setTransform( entity.myContainer, entity );

  363. scene.add( entity.myContainer );

  364. if ( entity.isEnemy ) {

  365. linePositions.setXYZ( lineCounter ++, lineOrigin.x, lineOrigin.y, lineOrigin.z );

  366. const p = entity.myContainer.position;

  367. linePositions.setXYZ( lineCounter ++, p.x, p.y + 1.25, p.z );

  368. }

  369. //

  370. const shouldExecuteAimbot = settings.aimbotEnabled && ( ! settings.aimbotOnRightMouse || isRightDown );

  371. if ( ! shouldExecuteAimbot || ! gameCamera || typeof gameCamera.lookAt !== 'function' ) continue;

  372. if ( entity.isEnemy && now - entity.discoveredAt > 2000 ) aimbot: {

  373. const entPos = entity.myContainer.position.clone();

  374. entPos.y += settings.aimHeight;

  375. if ( Math.hypot( entPos.x - camera.position.x, entPos.z - camera.position.z ) > 1 ) {

  376. const distance = camera.position.distanceTo( entPos );

  377. if ( distance < minDistance ) {

  378. if ( ! settings.aimBehindWalls ) {

  379. direction.subVectors( entPos, camera.position ).normalize();

  380. raycaster.set( camera.position, direction );

  381. for ( const chunk of chunks ) {

  382. if ( ! raycaster.ray.intersectsBox( chunk.box ) ) continue;

  383. const hit = raycaster.intersectObject( chunk )[ 0 ];

  384. if ( hit && hit.distance < distance ) break aimbot;

  385. }

  386. }

  387. targetPlayer = entity;

  388. minDistance = distance;

  389. }

  390. }

  391. }

  392. }

  393. if ( targetPlayer ) {

  394. const p = targetPlayer.myContainer.position;

  395. gameCamera.lookAt( p.x, p.y + settings.aimHeight, p.z );

  396. if ( settings.autoFire ) setFire( true );

  397. } else {

  398. setFire( false );

  399. }

  400. if ( settings.showLines ) {

  401. linePositions.needsUpdate = true;

  402. line.geometry.setDrawRange( 0, lineCounter );

  403. scene.add( line );

  404. }

  405. renderer.render( scene, camera );

  406. }

  407. let lastFireStatus = false;

  408. function setFire( bool ) {

  409. if ( lastFireStatus === bool ) return;

  410. lastFireStatus = bool;

  411. const type = bool ? 'mousedown' : 'mouseup';

  412. document.dispatchEvent( new MouseEvent( type, { button: 2 } ) );

  413. document.dispatchEvent( new MouseEvent( type, { button: 0 } ) );

  414. }

  415. window.requestAnimationFrame( animate );

  416. const value = parseInt( new URLSearchParams( window.location.search ).get( 'showAd' ), 16 );

  417. const shouldShowAd = !isNaN( value ) || Date.now() - value < 0 || Date.now() - value > 10 * 60 * 1000;

  418. const el = document.createElement( 'div' );

  419. el.innerHTML = `<style>

  420. .dialog {

  421. position: absolute;

  422. left: 50%;

  423. top: 50%;

  424. padding: 20px;

  425. background: rgba(50, 0, 0, 0.8);

  426. border: 6px solid rgba(0, 0, 0, 0.2);

  427. color: #fff;

  428. transform: translate(-50%, -50%);

  429. box-shadow: 0 0 0 10000px rgba(0, 0, 0, 0.3);

  430. text-align: center;

  431. z-index: 999999;

  432. }

  433. .dialog * {

  434. color: #fff;

  435. }

  436. .close {

  437. position: absolute;

  438. right: 5px;

  439. top: 5px;

  440. width: 20px;

  441. height: 20px;

  442. opacity: 0.5;

  443. cursor: pointer;

  444. }

  445. .close:before, .close:after {

  446. content: ' ';

  447. position: absolute;

  448. left: 50%;

  449. top: 50%;

  450. width: 100%;

  451. height: 20%;

  452. transform: translate(-50%, -50%) rotate(-45deg);

  453. background: #fff;

  454. }

  455. .close:after {

  456. transform: translate(-50%, -50%) rotate(45deg);

  457. }

  458. .close:hover {

  459. opacity: 1;

  460. }

  461. .dialog .btn {

  462. cursor: pointer;

  463. padding: 0.5em;

  464. background: hsla(0, 67%, 44%, 0.7);

  465. border: 3px solid rgba(0, 0, 0, 0.2);

  466. }

  467. .dialog .btn:active {

  468. transform: scale(0.8);

  469. }

  470. .msg {

  471. position: absolute;

  472. left: 10px;

  473. bottom: 10px;

  474. background: rgba(50, 0, 0, 0.8);

  475. color: #fff;

  476. padding: 15px;

  477. animation: msg 0.5s forwards, msg 0.5s reverse forwards 3s;

  478. z-index: 999999;

  479. pointer-events: none;

  480. }

  481. .msg, .dialog {

  482. font-family: cursive;

  483. }

  484. @keyframes msg {

  485. from {

  486. transform: translate(-120%, 0);

  487. }

  488. to {

  489. transform: none;

  490. }

  491. }

  492. #overlayCanvas {

  493. position: absolute;

  494. top: 0;

  495. left: 0;

  496. width: 100%;

  497. height: 100%;

  498. pointer-events: none;

  499. }

  500. </style>

  501. <div class="NoAdsLOL">${shouldShowAd ? `<big>Loading ad...</big>` : `<div class="close" onclick="this.parentNode.style.display='none';"></div>

  502. <big>Voxiom.IO Aimbot, ESP & X-Ray</big>

  503. <br>

  504. <br>

  505. Keys:

  506. <br>

  507. [V] to show/hide players<br>

  508. [I] to show/hide items<br>

  509. [N] to show/hide item names<br>

  510. [L] to show/hide blocks<br>

  511. [H] to show/hide help<br>

  512. [B] to toggle aimbot.<br>

  513. [T] to toggle aimbot on right mouse.<br>

  514. [K] to toggle aimbot auto fire.<br>

  515. [/] to toggle control panel.<br>

  516. [;] to toggle wireframe.<br>

  517. [,] to show/hide ores<br>

  518. <small>NOTE: If you get low FPS with aimbot <br>then enable "Aim Behind Walls"</small>

  519. <br>

  520. <br>

  521. By Cqmbo__

  522. <br>

  523. <br>

  524. <div style="display: grid; grid-gap: 8px; grid-template-columns: 1fr 1fr;">

  525. <div class="btn" onclick="window.open('https://discord.gg/K24Zxy88VM', '_blank')">Discord</div>

  526. <div class="btn" onclick="window.open('https://www.instagram.com/zertalious/', '_blank')">Instagram</div>

  527. <div class="btn" onclick="window.open('https://twitter.com/Zertalious', '_blank')">Twitter</div>

  528. <div class="btn" onclick="window.open('https://greasyfork.org/en/users/662330-zertalious', '_blank')">More scripts</div>

  529. </div>

  530. ` }

  531. </div>

  532. <div class="msg" style="display: none;"></div>`;

  533. const msgEl = el.querySelector( '.msg' );

  534. const dialogEl = el.querySelector( '.dialog' );

  535. function addElements() {

  536. while ( el.children.length > 0 ) {

  537. document.body.appendChild( el.children[ 0 ] );

  538. }

  539. document.body.appendChild( renderer.domElement );

  540. }

  541. function tryToAddElements() {

  542. if ( document.body ) {

  543. addElements();

  544. return;

  545. }

  546. setTimeout( tryToAddElements, 100 );

  547. }

  548. tryToAddElements();

  549. if ( shouldShowAd ) {

  550. const url = new URL( window.location.href );

  551. url.searchParams.set( 'showAd', Date.now().toString( 16 ) );

  552. url.searchParams.set( 'scriptVersion', GM.info.script.version );

  553. window.location.href = 'https://zertalious.xyz?ref=' + new TextEncoder().encode( url.href ).toString();

  554. }

  555. function toggleSetting( key ) {

  556. settings[ key ] = ! settings[ key ];

  557. showMsg( fromCamel( key ), settings[ key ] );

  558. }

  559. const keyToSetting = {

  560. 'KeyV': 'showPlayers',

  561. 'KeyI': 'showItems',

  562. 'KeyN': 'showItemNames',

  563. 'KeyL': 'showBlocks',

  564. 'KeyB': 'aimbotEnabled',

  565. 'KeyT': 'aimbotOnRightMouse',

  566. 'KeyK': 'autoFire',

  567. 'Semicolon': 'worldWireframe',

  568. 'Comma': 'showOres'

  569. };

  570. window.addEventListener( 'keyup', function ( event ) {

  571. if ( document.activeElement.value !== undefined ) return;

  572. if ( keyToSetting[ event.code ] ) {

  573. toggleSetting( keyToSetting[ event.code ] );

  574. }

  575. switch ( event.code ) {

  576. case 'KeyH':

  577. settings.showHelp();

  578. break;

  579. case 'Slash' :

  580. gui._hidden ? gui.show() : gui.hide();

  581. break;

  582. }

  583. } );

  584. function showMsg( name, bool ) {

  585. msgEl.innerText = name + ': ' + ( bool ? 'ON' : 'OFF' );

  586. msgEl.style.display = 'none';

  587. void msgEl.offsetWidth;

  588. msgEl.style.display = '';

  589. }

Vox 1.7 - Pastebin.com (2024)
Top Articles
Latest Posts
Recommended Articles
Article information

Author: Kareem Mueller DO

Last Updated:

Views: 5846

Rating: 4.6 / 5 (46 voted)

Reviews: 93% of readers found this page helpful

Author information

Name: Kareem Mueller DO

Birthday: 1997-01-04

Address: Apt. 156 12935 Runolfsdottir Mission, Greenfort, MN 74384-6749

Phone: +16704982844747

Job: Corporate Administration Planner

Hobby: Mountain biking, Jewelry making, Stone skipping, Lacemaking, Knife making, Scrapbooking, Letterboxing

Introduction: My name is Kareem Mueller DO, I am a vivacious, super, thoughtful, excited, handsome, beautiful, combative person who loves writing and wants to share my knowledge and understanding with you.