tom/METH_Transcendence
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Game

Browse Source 
- Added 2 mods on cameras
This commit is contained in:
Kum1ta
2024-08-18 16:19:27 +02:00
parent 44ad413120
commit 950abd0943
10 changed files with 32911 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
site/real_game/class/Player.js
View File

@ -6,10 +6,13 @@
/* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/18 00:30:31 by edbernar #+# #+# */
/* Updated: 2024/08/18 01:47:15 by edbernar ### ########.fr */
/* Updated: 2024/08/18 16:17:18 by edbernar ### ########.fr */
/* */
/* ************************************************************************** */
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
import * as THREE from 'three';
/*
Explication du code :
- Un seul joueur peut etre instancié, sinon ça throw une erreur
@ -18,24 +21,41 @@
- Les lignes avec cleanup sont l'êquivalent d'un destructeur en CPP
- Pour appliquer des actions sur les touches, il suffit de faire ça dans la fonction
update en regardant si la touche voulue est pressée dans la variable "pressedButton"
- Par défaut, la caméra est accroché, si on veut qu'elle ne bouge plus, il faut
modifier "cameraFixed" à true
- Si on utilise une touche qui ne sera utilisée que pour un appui simple, il faudra la
mettre dans 'addEventListerner('keypress') et pas dans update()
*/
/*
Todo (Eddy) :
- Ajouter une camera sur l'object
- Faire une fonction pour changer le mode de la camera (fix ou accrochée)
- Ajouter une camera sur l'object (OK)
- Faire une fonction pour changer le mode de la camera (fix ou accrochée) (OK)
- Ajouter une rotation quand la caméra est fixe (OK)
*/
let playerExist = false;
class Player
{
pressedButton = [];
constructor (object)
pressedButton = [];
object = null;
camera = null;
speed = 0.05;
cameraFixed = false;
orbital = null;
constructor (object, renderer)
{
if (playerExist)
throw Error("Player is already init.");
playerExist = true;
this.object = object;
this.camera = new THREE.PerspectiveCamera(90, window.innerWidth / window.innerHeight, 0.1, 10000);
this.orbital = new OrbitControls(this.camera, renderer.domElement);
this.orbital.enableZoom = false;
this.cleanup = new FinalizationRegistry((heldValue) => {
playerExist = false;
})
@ -60,6 +80,21 @@ class Player
if (i != this.pressedButton.length)
this.pressedButton.splice(i, 1);
});
document.addEventListener('keypress', (e) => {
if (e.key == 'm')
{
this.cameraFixed = !this.cameraFixed;
if (!this.cameraFixed)
this.setCameraPosition(
this.object.position.x,
this.object.position.y + 0.5,
this.object.position.z + 1
);
else
this.setCameraPosition(0, 1, 1)
}
});
}
update()
@ -67,13 +102,35 @@ class Player
let i;
i = 0;
if (this.cameraFixed)
{
this.orbital.target = new THREE.Vector3(this.object.position.x, this.object.position.y, this.object.position.z - 5);
this.orbital.update();
}
else
this.camera.rotation.set(0, 0, 0);
while (i < this.pressedButton.length)
{
if (this.pressedButton[i] == 'a')
console.log('A is pressed !');
if (this.pressedButton[i] == 'w' || this.pressedButton[i] == 's')
{
this.object.position.y += (this.pressedButton[i] == 'w' ? this.speed : -this.speed);
if (!this.cameraFixed)
this.camera.position.y += (this.pressedButton[i] == 'w' ? this.speed : -this.speed);
}
if (this.pressedButton[i] == 'a' || this.pressedButton[i] == 'd')
{
this.object.position.x += (this.pressedButton[i] == 'a' ? -this.speed : this.speed);
if (!this.cameraFixed)
this.camera.position.x += (this.pressedButton[i] == 'a' ? -this.speed : this.speed);
}
i++;
}
}
setCameraPosition(x, y, z)
{
this.camera.position.set(x, y, z);
}
};

42
site/real_game/main.js
View File

@ -6,14 +6,44 @@
/* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/18 00:53:53 by edbernar #+# #+# */
/* Updated: 2024/08/18 01:09:38 by edbernar ### ########.fr */
/* Updated: 2024/08/18 15:52:03 by edbernar ### ########.fr */
/* */
/* ************************************************************************** */
import { Player } from './Player'
import * as THREE from 'three';
import { Player } from './class/Player'
const player = new Player(null);
function createBarPlayer(color)
{
const geometry = new THREE.BoxGeometry(1, 0.1, 0.1);
const material = new THREE.MeshPhysicalMaterial({color: color});
const mesh = new THREE.Mesh(geometry, material);
setInterval(() => {
player.update();
}, 100);
return (mesh);
}
function loop()
{
// controls.update();
player.update();
renderer.render(scene, player.camera);
}
const scene = new THREE.Scene();
const bar = createBarPlayer(0xed56ea);
const renderer = new THREE.WebGLRenderer();
const player = new Player(bar, renderer);
const spotLight = new THREE.SpotLight(0xffffff, 1, 0, Math.PI / 4);
const helper = new THREE.SpotLightHelper(spotLight);
// const controls = new OrbitControls(player.camera, renderer.domElement);
scene.add(player.object);
spotLight.target = player.object;
scene.add(spotLight);
scene.add(helper);
scene.background = new THREE.Color(0x1a1a1a);
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);
player.setCameraPosition(0, 0.5, 1)
renderer.setAnimationLoop(loop)

27
site/real_game/node_modules/.vite/deps/_metadata.json generated vendored
View File

@ -1,8 +1,25 @@
{
"hash": "d27ca5c8",
"configHash": "7970fc20",
"hash": "2b6c1fb1",
"configHash": "4027b9ee",
"lockfileHash": "13ac84ee",
"browserHash": "2d791e19",
"optimized": {},
"chunks": {}
"browserHash": "5053c46e",
"optimized": {
"three": {
"src": "../../three/build/three.module.js",
"file": "three.js",
"fileHash": "b62fcce2",
"needsInterop": false
},
"three/examples/jsm/controls/OrbitControls.js": {
"src": "../../three/examples/jsm/controls/OrbitControls.js",
"file": "three_examples_jsm_controls_OrbitControls__js.js",
"fileHash": "914c2fd8",
"needsInterop": false
}
},
"chunks": {
"chunk-IS2ZBFBB": {
"file": "chunk-IS2ZBFBB.js"
}
}
}

31135
site/real_game/node_modules/.vite/deps/chunk-IS2ZBFBB.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

7
site/real_game/node_modules/.vite/deps/chunk-IS2ZBFBB.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

841
site/real_game/node_modules/.vite/deps/three.js generated vendored Normal file
View File

@ -0,0 +1,841 @@
import {
ACESFilmicToneMapping,
AddEquation,
AddOperation,
AdditiveAnimationBlendMode,
AdditiveBlending,
AgXToneMapping,
AlphaFormat,
AlwaysCompare,
AlwaysDepth,
AlwaysStencilFunc,
AmbientLight,
AnimationAction,
AnimationClip,
AnimationLoader,
AnimationMixer,
AnimationObjectGroup,
AnimationUtils,
ArcCurve,
ArrayCamera,
ArrowHelper,
AttachedBindMode,
Audio,
AudioAnalyser,
AudioContext,
AudioListener,
AudioLoader,
AxesHelper,
BackSide,
BasicDepthPacking,
BasicShadowMap,
BatchedMesh,
Bone,
BooleanKeyframeTrack,
Box2,
Box3,
Box3Helper,
BoxGeometry,
BoxHelper,
BufferAttribute,
BufferGeometry,
BufferGeometryLoader,
ByteType,
Cache,
Camera,
CameraHelper,
CanvasTexture,
CapsuleGeometry,
CatmullRomCurve3,
CineonToneMapping,
CircleGeometry,
ClampToEdgeWrapping,
Clock,
Color,
ColorKeyframeTrack,
ColorManagement,
CompressedArrayTexture,
CompressedCubeTexture,
CompressedTexture,
CompressedTextureLoader,
ConeGeometry,
ConstantAlphaFactor,
ConstantColorFactor,
CubeCamera,
CubeReflectionMapping,
CubeRefractionMapping,
CubeTexture,
CubeTextureLoader,
CubeUVReflectionMapping,
CubicBezierCurve,
CubicBezierCurve3,
CubicInterpolant,
CullFaceBack,
CullFaceFront,
CullFaceFrontBack,
CullFaceNone,
Curve,
CurvePath,
CustomBlending,
CustomToneMapping,
CylinderGeometry,
Cylindrical,
Data3DTexture,
DataArrayTexture,
DataTexture,
DataTextureLoader,
DataUtils,
DecrementStencilOp,
DecrementWrapStencilOp,
DefaultLoadingManager,
DepthFormat,
DepthStencilFormat,
DepthTexture,
DetachedBindMode,
DirectionalLight,
DirectionalLightHelper,
DiscreteInterpolant,
DisplayP3ColorSpace,
DodecahedronGeometry,
DoubleSide,
DstAlphaFactor,
DstColorFactor,
DynamicCopyUsage,
DynamicDrawUsage,
DynamicReadUsage,
EdgesGeometry,
EllipseCurve,
EqualCompare,
EqualDepth,
EqualStencilFunc,
EquirectangularReflectionMapping,
EquirectangularRefractionMapping,
Euler,
EventDispatcher,
ExtrudeGeometry,
FileLoader,
Float16BufferAttribute,
Float32BufferAttribute,
FloatType,
Fog,
FogExp2,
FramebufferTexture,
FrontSide,
Frustum,
GLBufferAttribute,
GLSL1,
GLSL3,
GreaterCompare,
GreaterDepth,
GreaterEqualCompare,
GreaterEqualDepth,
GreaterEqualStencilFunc,
GreaterStencilFunc,
GridHelper,
Group,
HalfFloatType,
HemisphereLight,
HemisphereLightHelper,
IcosahedronGeometry,
ImageBitmapLoader,
ImageLoader,
ImageUtils,
IncrementStencilOp,
IncrementWrapStencilOp,
InstancedBufferAttribute,
InstancedBufferGeometry,
InstancedInterleavedBuffer,
InstancedMesh,
Int16BufferAttribute,
Int32BufferAttribute,
Int8BufferAttribute,
IntType,
InterleavedBuffer,
InterleavedBufferAttribute,
Interpolant,
InterpolateDiscrete,
InterpolateLinear,
InterpolateSmooth,
InvertStencilOp,
KeepStencilOp,
KeyframeTrack,
LOD,
LatheGeometry,
Layers,
LessCompare,
LessDepth,
LessEqualCompare,
LessEqualDepth,
LessEqualStencilFunc,
LessStencilFunc,
Light,
LightProbe,
Line,
Line3,
LineBasicMaterial,
LineCurve,
LineCurve3,
LineDashedMaterial,
LineLoop,
LineSegments,
LinearDisplayP3ColorSpace,
LinearFilter,
LinearInterpolant,
LinearMipMapLinearFilter,
LinearMipMapNearestFilter,
LinearMipmapLinearFilter,
LinearMipmapNearestFilter,
LinearSRGBColorSpace,
LinearToneMapping,
LinearTransfer,
Loader,
LoaderUtils,
LoadingManager,
LoopOnce,
LoopPingPong,
LoopRepeat,
LuminanceAlphaFormat,
LuminanceFormat,
MOUSE,
Material,
MaterialLoader,
MathUtils,
Matrix2,
Matrix3,
Matrix4,
MaxEquation,
Mesh,
MeshBasicMaterial,
MeshDepthMaterial,
MeshDistanceMaterial,
MeshLambertMaterial,
MeshMatcapMaterial,
MeshNormalMaterial,
MeshPhongMaterial,
MeshPhysicalMaterial,
MeshStandardMaterial,
MeshToonMaterial,
MinEquation,
MirroredRepeatWrapping,
MixOperation,
MultiplyBlending,
MultiplyOperation,
NearestFilter,
NearestMipMapLinearFilter,
NearestMipMapNearestFilter,
NearestMipmapLinearFilter,
NearestMipmapNearestFilter,
NeutralToneMapping,
NeverCompare,
NeverDepth,
NeverStencilFunc,
NoBlending,
NoColorSpace,
NoToneMapping,
NormalAnimationBlendMode,
NormalBlending,
NotEqualCompare,
NotEqualDepth,
NotEqualStencilFunc,
NumberKeyframeTrack,
Object3D,
ObjectLoader,
ObjectSpaceNormalMap,
OctahedronGeometry,
OneFactor,
OneMinusConstantAlphaFactor,
OneMinusConstantColorFactor,
OneMinusDstAlphaFactor,
OneMinusDstColorFactor,
OneMinusSrcAlphaFactor,
OneMinusSrcColorFactor,
OrthographicCamera,
P3Primaries,
PCFShadowMap,
PCFSoftShadowMap,
PMREMGenerator,
Path,
PerspectiveCamera,
Plane,
PlaneGeometry,
PlaneHelper,
PointLight,
PointLightHelper,
Points,
PointsMaterial,
PolarGridHelper,
PolyhedronGeometry,
PositionalAudio,
PropertyBinding,
PropertyMixer,
QuadraticBezierCurve,
QuadraticBezierCurve3,
Quaternion,
QuaternionKeyframeTrack,
QuaternionLinearInterpolant,
RED_GREEN_RGTC2_Format,
RED_RGTC1_Format,
REVISION,
RGBADepthPacking,
RGBAFormat,
RGBAIntegerFormat,
RGBA_ASTC_10x10_Format,
RGBA_ASTC_10x5_Format,
RGBA_ASTC_10x6_Format,
RGBA_ASTC_10x8_Format,
RGBA_ASTC_12x10_Format,
RGBA_ASTC_12x12_Format,
RGBA_ASTC_4x4_Format,
RGBA_ASTC_5x4_Format,
RGBA_ASTC_5x5_Format,
RGBA_ASTC_6x5_Format,
RGBA_ASTC_6x6_Format,
RGBA_ASTC_8x5_Format,
RGBA_ASTC_8x6_Format,
RGBA_ASTC_8x8_Format,
RGBA_BPTC_Format,
RGBA_ETC2_EAC_Format,
RGBA_PVRTC_2BPPV1_Format,
RGBA_PVRTC_4BPPV1_Format,
RGBA_S3TC_DXT1_Format,
RGBA_S3TC_DXT3_Format,
RGBA_S3TC_DXT5_Format,
RGBDepthPacking,
RGBFormat,
RGBIntegerFormat,
RGB_BPTC_SIGNED_Format,
RGB_BPTC_UNSIGNED_Format,
RGB_ETC1_Format,
RGB_ETC2_Format,
RGB_PVRTC_2BPPV1_Format,
RGB_PVRTC_4BPPV1_Format,
RGB_S3TC_DXT1_Format,
RGDepthPacking,
RGFormat,
RGIntegerFormat,
RawShaderMaterial,
Ray,
Raycaster,
Rec709Primaries,
RectAreaLight,
RedFormat,
RedIntegerFormat,
ReinhardToneMapping,
RenderTarget,
RepeatWrapping,
ReplaceStencilOp,
ReverseSubtractEquation,
RingGeometry,
SIGNED_RED_GREEN_RGTC2_Format,
SIGNED_RED_RGTC1_Format,
SRGBColorSpace,
SRGBTransfer,
Scene,
ShaderChunk,
ShaderLib,
ShaderMaterial,
ShadowMaterial,
Shape,
ShapeGeometry,
ShapePath,
ShapeUtils,
ShortType,
Skeleton,
SkeletonHelper,
SkinnedMesh,
Source,
Sphere,
SphereGeometry,
Spherical,
SphericalHarmonics3,
SplineCurve,
SpotLight,
SpotLightHelper,
Sprite,
SpriteMaterial,
SrcAlphaFactor,
SrcAlphaSaturateFactor,
SrcColorFactor,
StaticCopyUsage,
StaticDrawUsage,
StaticReadUsage,
StereoCamera,
StreamCopyUsage,
StreamDrawUsage,
StreamReadUsage,
StringKeyframeTrack,
SubtractEquation,
SubtractiveBlending,
TOUCH,
TangentSpaceNormalMap,
TetrahedronGeometry,
Texture,
TextureLoader,
TextureUtils,
TorusGeometry,
TorusKnotGeometry,
Triangle,
TriangleFanDrawMode,
TriangleStripDrawMode,
TrianglesDrawMode,
TubeGeometry,
UVMapping,
Uint16BufferAttribute,
Uint32BufferAttribute,
Uint8BufferAttribute,
Uint8ClampedBufferAttribute,
Uniform,
UniformsGroup,
UniformsLib,
UniformsUtils,
UnsignedByteType,
UnsignedInt248Type,
UnsignedInt5999Type,
UnsignedIntType,
UnsignedShort4444Type,
UnsignedShort5551Type,
UnsignedShortType,
VSMShadowMap,
Vector2,
Vector3,
Vector4,
VectorKeyframeTrack,
VideoTexture,
WebGL3DRenderTarget,
WebGLArrayRenderTarget,
WebGLCoordinateSystem,
WebGLCubeRenderTarget,
WebGLMultipleRenderTargets,
WebGLRenderTarget,
WebGLRenderer,
WebGLUtils,
WebGPUCoordinateSystem,
WireframeGeometry,
WrapAroundEnding,
ZeroCurvatureEnding,
ZeroFactor,
ZeroSlopeEnding,
ZeroStencilOp,
createCanvasElement
} from "./chunk-IS2ZBFBB.js";
export {
ACESFilmicToneMapping,
AddEquation,
AddOperation,
AdditiveAnimationBlendMode,
AdditiveBlending,
AgXToneMapping,
AlphaFormat,
AlwaysCompare,
AlwaysDepth,
AlwaysStencilFunc,
AmbientLight,
AnimationAction,
AnimationClip,
AnimationLoader,
AnimationMixer,
AnimationObjectGroup,
AnimationUtils,
ArcCurve,
ArrayCamera,
ArrowHelper,
AttachedBindMode,
Audio,
AudioAnalyser,
AudioContext,
AudioListener,
AudioLoader,
AxesHelper,
BackSide,
BasicDepthPacking,
BasicShadowMap,
BatchedMesh,
Bone,
BooleanKeyframeTrack,
Box2,
Box3,
Box3Helper,
BoxGeometry,
BoxHelper,
BufferAttribute,
BufferGeometry,
BufferGeometryLoader,
ByteType,
Cache,
Camera,
CameraHelper,
CanvasTexture,
CapsuleGeometry,
CatmullRomCurve3,
CineonToneMapping,
CircleGeometry,
ClampToEdgeWrapping,
Clock,
Color,
ColorKeyframeTrack,
ColorManagement,
CompressedArrayTexture,
CompressedCubeTexture,
CompressedTexture,
CompressedTextureLoader,
ConeGeometry,
ConstantAlphaFactor,
ConstantColorFactor,
CubeCamera,
CubeReflectionMapping,
CubeRefractionMapping,
CubeTexture,
CubeTextureLoader,
CubeUVReflectionMapping,
CubicBezierCurve,
CubicBezierCurve3,
CubicInterpolant,
CullFaceBack,
CullFaceFront,
CullFaceFrontBack,
CullFaceNone,
Curve,
CurvePath,
CustomBlending,
CustomToneMapping,
CylinderGeometry,
Cylindrical,
Data3DTexture,
DataArrayTexture,
DataTexture,
DataTextureLoader,
DataUtils,
DecrementStencilOp,
DecrementWrapStencilOp,
DefaultLoadingManager,
DepthFormat,
DepthStencilFormat,
DepthTexture,
DetachedBindMode,
DirectionalLight,
DirectionalLightHelper,
DiscreteInterpolant,
DisplayP3ColorSpace,
DodecahedronGeometry,
DoubleSide,
DstAlphaFactor,
DstColorFactor,
DynamicCopyUsage,
DynamicDrawUsage,
DynamicReadUsage,
EdgesGeometry,
EllipseCurve,
EqualCompare,
EqualDepth,
EqualStencilFunc,
EquirectangularReflectionMapping,
EquirectangularRefractionMapping,
Euler,
EventDispatcher,
ExtrudeGeometry,
FileLoader,
Float16BufferAttribute,
Float32BufferAttribute,
FloatType,
Fog,
FogExp2,
FramebufferTexture,
FrontSide,
Frustum,
GLBufferAttribute,
GLSL1,
GLSL3,
GreaterCompare,
GreaterDepth,
GreaterEqualCompare,
GreaterEqualDepth,
GreaterEqualStencilFunc,
GreaterStencilFunc,
GridHelper,
Group,
HalfFloatType,
HemisphereLight,
HemisphereLightHelper,
IcosahedronGeometry,
ImageBitmapLoader,
ImageLoader,
ImageUtils,
IncrementStencilOp,
IncrementWrapStencilOp,
InstancedBufferAttribute,
InstancedBufferGeometry,
InstancedInterleavedBuffer,
InstancedMesh,
Int16BufferAttribute,
Int32BufferAttribute,
Int8BufferAttribute,
IntType,
InterleavedBuffer,
InterleavedBufferAttribute,
Interpolant,
InterpolateDiscrete,
InterpolateLinear,
InterpolateSmooth,
InvertStencilOp,
KeepStencilOp,
KeyframeTrack,
LOD,
LatheGeometry,
Layers,
LessCompare,
LessDepth,
LessEqualCompare,
LessEqualDepth,
LessEqualStencilFunc,
LessStencilFunc,
Light,
LightProbe,
Line,
Line3,
LineBasicMaterial,
LineCurve,
LineCurve3,
LineDashedMaterial,
LineLoop,
LineSegments,
LinearDisplayP3ColorSpace,
LinearFilter,
LinearInterpolant,
LinearMipMapLinearFilter,
LinearMipMapNearestFilter,
LinearMipmapLinearFilter,
LinearMipmapNearestFilter,
LinearSRGBColorSpace,
LinearToneMapping,
LinearTransfer,
Loader,
LoaderUtils,
LoadingManager,
LoopOnce,
LoopPingPong,
LoopRepeat,
LuminanceAlphaFormat,
LuminanceFormat,
MOUSE,
Material,
MaterialLoader,
MathUtils,
Matrix2,
Matrix3,
Matrix4,
MaxEquation,
Mesh,
MeshBasicMaterial,
MeshDepthMaterial,
MeshDistanceMaterial,
MeshLambertMaterial,
MeshMatcapMaterial,
MeshNormalMaterial,
MeshPhongMaterial,
MeshPhysicalMaterial,
MeshStandardMaterial,
MeshToonMaterial,
MinEquation,
MirroredRepeatWrapping,
MixOperation,
MultiplyBlending,
MultiplyOperation,
NearestFilter,
NearestMipMapLinearFilter,
NearestMipMapNearestFilter,
NearestMipmapLinearFilter,
NearestMipmapNearestFilter,
NeutralToneMapping,
NeverCompare,
NeverDepth,
NeverStencilFunc,
NoBlending,
NoColorSpace,
NoToneMapping,
NormalAnimationBlendMode,
NormalBlending,
NotEqualCompare,
NotEqualDepth,
NotEqualStencilFunc,
NumberKeyframeTrack,
Object3D,
ObjectLoader,
ObjectSpaceNormalMap,
OctahedronGeometry,
OneFactor,
OneMinusConstantAlphaFactor,
OneMinusConstantColorFactor,
OneMinusDstAlphaFactor,
OneMinusDstColorFactor,
OneMinusSrcAlphaFactor,
OneMinusSrcColorFactor,
OrthographicCamera,
P3Primaries,
PCFShadowMap,
PCFSoftShadowMap,
PMREMGenerator,
Path,
PerspectiveCamera,
Plane,
PlaneGeometry,
PlaneHelper,
PointLight,
PointLightHelper,
Points,
PointsMaterial,
PolarGridHelper,
PolyhedronGeometry,
PositionalAudio,
PropertyBinding,
PropertyMixer,
QuadraticBezierCurve,
QuadraticBezierCurve3,
Quaternion,
QuaternionKeyframeTrack,
QuaternionLinearInterpolant,
RED_GREEN_RGTC2_Format,
RED_RGTC1_Format,
REVISION,
RGBADepthPacking,
RGBAFormat,
RGBAIntegerFormat,
RGBA_ASTC_10x10_Format,
RGBA_ASTC_10x5_Format,
RGBA_ASTC_10x6_Format,
RGBA_ASTC_10x8_Format,
RGBA_ASTC_12x10_Format,
RGBA_ASTC_12x12_Format,
RGBA_ASTC_4x4_Format,
RGBA_ASTC_5x4_Format,
RGBA_ASTC_5x5_Format,
RGBA_ASTC_6x5_Format,
RGBA_ASTC_6x6_Format,
RGBA_ASTC_8x5_Format,
RGBA_ASTC_8x6_Format,
RGBA_ASTC_8x8_Format,
RGBA_BPTC_Format,
RGBA_ETC2_EAC_Format,
RGBA_PVRTC_2BPPV1_Format,
RGBA_PVRTC_4BPPV1_Format,
RGBA_S3TC_DXT1_Format,
RGBA_S3TC_DXT3_Format,
RGBA_S3TC_DXT5_Format,
RGBDepthPacking,
RGBFormat,
RGBIntegerFormat,
RGB_BPTC_SIGNED_Format,
RGB_BPTC_UNSIGNED_Format,
RGB_ETC1_Format,
RGB_ETC2_Format,
RGB_PVRTC_2BPPV1_Format,
RGB_PVRTC_4BPPV1_Format,
RGB_S3TC_DXT1_Format,
RGDepthPacking,
RGFormat,
RGIntegerFormat,
RawShaderMaterial,
Ray,
Raycaster,
Rec709Primaries,
RectAreaLight,
RedFormat,
RedIntegerFormat,
ReinhardToneMapping,
RenderTarget,
RepeatWrapping,
ReplaceStencilOp,
ReverseSubtractEquation,
RingGeometry,
SIGNED_RED_GREEN_RGTC2_Format,
SIGNED_RED_RGTC1_Format,
SRGBColorSpace,
SRGBTransfer,
Scene,
ShaderChunk,
ShaderLib,
ShaderMaterial,
ShadowMaterial,
Shape,
ShapeGeometry,
ShapePath,
ShapeUtils,
ShortType,
Skeleton,
SkeletonHelper,
SkinnedMesh,
Source,
Sphere,
SphereGeometry,
Spherical,
SphericalHarmonics3,
SplineCurve,
SpotLight,
SpotLightHelper,
Sprite,
SpriteMaterial,
SrcAlphaFactor,
SrcAlphaSaturateFactor,
SrcColorFactor,
StaticCopyUsage,
StaticDrawUsage,
StaticReadUsage,
StereoCamera,
StreamCopyUsage,
StreamDrawUsage,
StreamReadUsage,
StringKeyframeTrack,
SubtractEquation,
SubtractiveBlending,
TOUCH,
TangentSpaceNormalMap,
TetrahedronGeometry,
Texture,
TextureLoader,
TextureUtils,
TorusGeometry,
TorusKnotGeometry,
Triangle,
TriangleFanDrawMode,
TriangleStripDrawMode,
TrianglesDrawMode,
TubeGeometry,
UVMapping,
Uint16BufferAttribute,
Uint32BufferAttribute,
Uint8BufferAttribute,
Uint8ClampedBufferAttribute,
Uniform,
UniformsGroup,
UniformsLib,
UniformsUtils,
UnsignedByteType,
UnsignedInt248Type,
UnsignedInt5999Type,
UnsignedIntType,
UnsignedShort4444Type,
UnsignedShort5551Type,
UnsignedShortType,
VSMShadowMap,
Vector2,
Vector3,
Vector4,
VectorKeyframeTrack,
VideoTexture,
WebGL3DRenderTarget,
WebGLArrayRenderTarget,
WebGLCoordinateSystem,
WebGLCubeRenderTarget,
WebGLMultipleRenderTargets,
WebGLRenderTarget,
WebGLRenderer,
WebGLUtils,
WebGPUCoordinateSystem,
WireframeGeometry,
WrapAroundEnding,
ZeroCurvatureEnding,
ZeroFactor,
ZeroSlopeEnding,
ZeroStencilOp,
createCanvasElement
};
//# sourceMappingURL=three.js.map

7
site/real_game/node_modules/.vite/deps/three.js.map generated vendored Normal file
View File

@ -0,0 +1,7 @@
{
"version": 3,
"sources": [],
"sourcesContent": [],
"mappings": "",
"names": []
}

790
site/real_game/node_modules/.vite/deps/three_examples_jsm_controls_OrbitControls__js.js generated vendored Normal file
View File

@ -0,0 +1,790 @@
import {
EventDispatcher,
MOUSE,
MathUtils,
Plane,
Quaternion,
Ray,
Spherical,
TOUCH,
Vector2,
Vector3
} from "./chunk-IS2ZBFBB.js";
// node_modules/three/examples/jsm/controls/OrbitControls.js
var _changeEvent = { type: "change" };
var _startEvent = { type: "start" };
var _endEvent = { type: "end" };
var _ray = new Ray();
var _plane = new Plane();
var TILT_LIMIT = Math.cos(70 * MathUtils.DEG2RAD);
var OrbitControls = class extends EventDispatcher {
constructor(object, domElement) {
super();
this.object = object;
this.domElement = domElement;
this.domElement.style.touchAction = "none";
this.enabled = true;
this.target = new Vector3();
this.cursor = new Vector3();
this.minDistance = 0;
this.maxDistance = Infinity;
this.minZoom = 0;
this.maxZoom = Infinity;
this.minTargetRadius = 0;
this.maxTargetRadius = Infinity;
this.minPolarAngle = 0;
this.maxPolarAngle = Math.PI;
this.minAzimuthAngle = -Infinity;
this.maxAzimuthAngle = Infinity;
this.enableDamping = false;
this.dampingFactor = 0.05;
this.enableZoom = true;
this.zoomSpeed = 1;
this.enableRotate = true;
this.rotateSpeed = 1;
this.enablePan = true;
this.panSpeed = 1;
this.screenSpacePanning = true;
this.keyPanSpeed = 7;
this.zoomToCursor = false;
this.autoRotate = false;
this.autoRotateSpeed = 2;
this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
this.touches = { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN };
this.target0 = this.target.clone();
this.position0 = this.object.position.clone();
this.zoom0 = this.object.zoom;
this._domElementKeyEvents = null;
this.getPolarAngle = function() {
return spherical.phi;
};
this.getAzimuthalAngle = function() {
return spherical.theta;
};
this.getDistance = function() {
return this.object.position.distanceTo(this.target);
};
this.listenToKeyEvents = function(domElement2) {
domElement2.addEventListener("keydown", onKeyDown);
this._domElementKeyEvents = domElement2;
};
this.stopListenToKeyEvents = function() {
this._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
this._domElementKeyEvents = null;
};
this.saveState = function() {
scope.target0.copy(scope.target);
scope.position0.copy(scope.object.position);
scope.zoom0 = scope.object.zoom;
};
this.reset = function() {
scope.target.copy(scope.target0);
scope.object.position.copy(scope.position0);
scope.object.zoom = scope.zoom0;
scope.object.updateProjectionMatrix();
scope.dispatchEvent(_changeEvent);
scope.update();
state = STATE.NONE;
};
this.update = function() {
const offset = new Vector3();
const quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));
const quatInverse = quat.clone().invert();
const lastPosition = new Vector3();
const lastQuaternion = new Quaternion();
const lastTargetPosition = new Vector3();
const twoPI = 2 * Math.PI;
return function update(deltaTime = null) {
const position = scope.object.position;
offset.copy(position).sub(scope.target);
offset.applyQuaternion(quat);
spherical.setFromVector3(offset);
if (scope.autoRotate && state === STATE.NONE) {
rotateLeft(getAutoRotationAngle(deltaTime));
}
if (scope.enableDamping) {
spherical.theta += sphericalDelta.theta * scope.dampingFactor;
spherical.phi += sphericalDelta.phi * scope.dampingFactor;
} else {
spherical.theta += sphericalDelta.theta;
spherical.phi += sphericalDelta.phi;
}
let min = scope.minAzimuthAngle;
let max = scope.maxAzimuthAngle;
if (isFinite(min) && isFinite(max)) {
if (min < -Math.PI) min += twoPI;
else if (min > Math.PI) min -= twoPI;
if (max < -Math.PI) max += twoPI;
else if (max > Math.PI) max -= twoPI;
if (min <= max) {
spherical.theta = Math.max(min, Math.min(max, spherical.theta));
} else {
spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
}
}
spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
spherical.makeSafe();
if (scope.enableDamping === true) {
scope.target.addScaledVector(panOffset, scope.dampingFactor);
} else {
scope.target.add(panOffset);
}
scope.target.sub(scope.cursor);
scope.target.clampLength(scope.minTargetRadius, scope.maxTargetRadius);
scope.target.add(scope.cursor);
let zoomChanged = false;
if (scope.zoomToCursor && performCursorZoom || scope.object.isOrthographicCamera) {
spherical.radius = clampDistance(spherical.radius);
} else {
const prevRadius = spherical.radius;
spherical.radius = clampDistance(spherical.radius * scale);
zoomChanged = prevRadius != spherical.radius;
}
offset.setFromSpherical(spherical);
offset.applyQuaternion(quatInverse);
position.copy(scope.target).add(offset);
scope.object.lookAt(scope.target);
if (scope.enableDamping === true) {
sphericalDelta.theta *= 1 - scope.dampingFactor;
sphericalDelta.phi *= 1 - scope.dampingFactor;
panOffset.multiplyScalar(1 - scope.dampingFactor);
} else {
sphericalDelta.set(0, 0, 0);
panOffset.set(0, 0, 0);
}
if (scope.zoomToCursor && performCursorZoom) {
let newRadius = null;
if (scope.object.isPerspectiveCamera) {
const prevRadius = offset.length();
newRadius = clampDistance(prevRadius * scale);
const radiusDelta = prevRadius - newRadius;
scope.object.position.addScaledVector(dollyDirection, radiusDelta);
scope.object.updateMatrixWorld();
zoomChanged = !!radiusDelta;
} else if (scope.object.isOrthographicCamera) {
const mouseBefore = new Vector3(mouse.x, mouse.y, 0);
mouseBefore.unproject(scope.object);
const prevZoom = scope.object.zoom;
scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / scale));
scope.object.updateProjectionMatrix();
zoomChanged = prevZoom !== scope.object.zoom;
const mouseAfter = new Vector3(mouse.x, mouse.y, 0);
mouseAfter.unproject(scope.object);
scope.object.position.sub(mouseAfter).add(mouseBefore);
scope.object.updateMatrixWorld();
newRadius = offset.length();
} else {
console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.");
scope.zoomToCursor = false;
}
if (newRadius !== null) {
if (this.screenSpacePanning) {
scope.target.set(0, 0, -1).transformDirection(scope.object.matrix).multiplyScalar(newRadius).add(scope.object.position);
} else {
_ray.origin.copy(scope.object.position);
_ray.direction.set(0, 0, -1).transformDirection(scope.object.matrix);
if (Math.abs(scope.object.up.dot(_ray.direction)) < TILT_LIMIT) {
object.lookAt(scope.target);
} else {
_plane.setFromNormalAndCoplanarPoint(scope.object.up, scope.target);
_ray.intersectPlane(_plane, scope.target);
}
}
}
} else if (scope.object.isOrthographicCamera) {
const prevZoom = scope.object.zoom;
scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / scale));
if (prevZoom !== scope.object.zoom) {
scope.object.updateProjectionMatrix();
zoomChanged = true;
}
}
scale = 1;
performCursorZoom = false;
if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS || lastTargetPosition.distanceToSquared(scope.target) > EPS) {
scope.dispatchEvent(_changeEvent);
lastPosition.copy(scope.object.position);
lastQuaternion.copy(scope.object.quaternion);
lastTargetPosition.copy(scope.target);
return true;
}
return false;
};
}();
this.dispose = function() {
scope.domElement.removeEventListener("contextmenu", onContextMenu);
scope.domElement.removeEventListener("pointerdown", onPointerDown);
scope.domElement.removeEventListener("pointercancel", onPointerUp);
scope.domElement.removeEventListener("wheel", onMouseWheel);
scope.domElement.removeEventListener("pointermove", onPointerMove);
scope.domElement.removeEventListener("pointerup", onPointerUp);
const document2 = scope.domElement.getRootNode();
document2.removeEventListener("keydown", interceptControlDown, { capture: true });
if (scope._domElementKeyEvents !== null) {
scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
scope._domElementKeyEvents = null;
}
};
const scope = this;
const STATE = {
NONE: -1,
ROTATE: 0,
DOLLY: 1,
PAN: 2,
TOUCH_ROTATE: 3,
TOUCH_PAN: 4,
TOUCH_DOLLY_PAN: 5,
TOUCH_DOLLY_ROTATE: 6
};
let state = STATE.NONE;
const EPS = 1e-6;
const spherical = new Spherical();
const sphericalDelta = new Spherical();
let scale = 1;
const panOffset = new Vector3();
const rotateStart = new Vector2();
const rotateEnd = new Vector2();
const rotateDelta = new Vector2();
const panStart = new Vector2();
const panEnd = new Vector2();
const panDelta = new Vector2();
const dollyStart = new Vector2();
const dollyEnd = new Vector2();
const dollyDelta = new Vector2();
const dollyDirection = new Vector3();
const mouse = new Vector2();
let performCursorZoom = false;
const pointers = [];
const pointerPositions = {};
let controlActive = false;
function getAutoRotationAngle(deltaTime) {
if (deltaTime !== null) {
return 2 * Math.PI / 60 * scope.autoRotateSpeed * deltaTime;
} else {
return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
}
}
function getZoomScale(delta) {
const normalizedDelta = Math.abs(delta * 0.01);
return Math.pow(0.95, scope.zoomSpeed * normalizedDelta);
}
function rotateLeft(angle) {
sphericalDelta.theta -= angle;
}
function rotateUp(angle) {
sphericalDelta.phi -= angle;
}
const panLeft = function() {
const v = new Vector3();
return function panLeft2(distance, objectMatrix) {
v.setFromMatrixColumn(objectMatrix, 0);
v.multiplyScalar(-distance);
panOffset.add(v);
};
}();
const panUp = function() {
const v = new Vector3();
return function panUp2(distance, objectMatrix) {
if (scope.screenSpacePanning === true) {
v.setFromMatrixColumn(objectMatrix, 1);
} else {
v.setFromMatrixColumn(objectMatrix, 0);
v.crossVectors(scope.object.up, v);
}
v.multiplyScalar(distance);
panOffset.add(v);
};
}();
const pan = function() {
const offset = new Vector3();
return function pan2(deltaX, deltaY) {
const element = scope.domElement;
if (scope.object.isPerspectiveCamera) {
const position = scope.object.position;
offset.copy(position).sub(scope.target);
let targetDistance = offset.length();
targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
} else if (scope.object.isOrthographicCamera) {
panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
} else {
console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
scope.enablePan = false;
}
};
}();
function dollyOut(dollyScale) {
if (scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera) {
scale /= dollyScale;
} else {
console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
scope.enableZoom = false;
}
}
function dollyIn(dollyScale) {
if (scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera) {
scale *= dollyScale;
} else {
console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
scope.enableZoom = false;
}
}
function updateZoomParameters(x, y) {
if (!scope.zoomToCursor) {
return;
}
performCursorZoom = true;
const rect = scope.domElement.getBoundingClientRect();
const dx = x - rect.left;
const dy = y - rect.top;
const w = rect.width;
const h = rect.height;
mouse.x = dx / w * 2 - 1;
mouse.y = -(dy / h) * 2 + 1;
dollyDirection.set(mouse.x, mouse.y, 1).unproject(scope.object).sub(scope.object.position).normalize();
}
function clampDistance(dist) {
return Math.max(scope.minDistance, Math.min(scope.maxDistance, dist));
}
function handleMouseDownRotate(event) {
rotateStart.set(event.clientX, event.clientY);
}
function handleMouseDownDolly(event) {
updateZoomParameters(event.clientX, event.clientX);
dollyStart.set(event.clientX, event.clientY);
}
function handleMouseDownPan(event) {
panStart.set(event.clientX, event.clientY);
}
function handleMouseMoveRotate(event) {
rotateEnd.set(event.clientX, event.clientY);
rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
const element = scope.domElement;
rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
rotateStart.copy(rotateEnd);
scope.update();
}
function handleMouseMoveDolly(event) {
dollyEnd.set(event.clientX, event.clientY);
dollyDelta.subVectors(dollyEnd, dollyStart);
if (dollyDelta.y > 0) {
dollyOut(getZoomScale(dollyDelta.y));
} else if (dollyDelta.y < 0) {
dollyIn(getZoomScale(dollyDelta.y));
}
dollyStart.copy(dollyEnd);
scope.update();
}
function handleMouseMovePan(event) {
panEnd.set(event.clientX, event.clientY);
panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
pan(panDelta.x, panDelta.y);
panStart.copy(panEnd);
scope.update();
}
function handleMouseWheel(event) {
updateZoomParameters(event.clientX, event.clientY);
if (event.deltaY < 0) {
dollyIn(getZoomScale(event.deltaY));
} else if (event.deltaY > 0) {
dollyOut(getZoomScale(event.deltaY));
}
scope.update();
}
function handleKeyDown(event) {
let needsUpdate = false;
switch (event.code) {
case scope.keys.UP:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
rotateUp(2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight);
} else {
pan(0, scope.keyPanSpeed);
}
needsUpdate = true;
break;
case scope.keys.BOTTOM:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
rotateUp(-2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight);
} else {
pan(0, -scope.keyPanSpeed);
}
needsUpdate = true;
break;
case scope.keys.LEFT:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
rotateLeft(2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight);
} else {
pan(scope.keyPanSpeed, 0);
}
needsUpdate = true;
break;
case scope.keys.RIGHT:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
rotateLeft(-2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight);
} else {
pan(-scope.keyPanSpeed, 0);
}
needsUpdate = true;
break;
}
if (needsUpdate) {
event.preventDefault();
scope.update();
}
}
function handleTouchStartRotate(event) {
if (pointers.length === 1) {
rotateStart.set(event.pageX, event.pageY);
} else {
const position = getSecondPointerPosition(event);
const x = 0.5 * (event.pageX + position.x);
const y = 0.5 * (event.pageY + position.y);
rotateStart.set(x, y);
}
}
function handleTouchStartPan(event) {
if (pointers.length === 1) {
panStart.set(event.pageX, event.pageY);
} else {
const position = getSecondPointerPosition(event);
const x = 0.5 * (event.pageX + position.x);
const y = 0.5 * (event.pageY + position.y);
panStart.set(x, y);
}
}
function handleTouchStartDolly(event) {
const position = getSecondPointerPosition(event);
const dx = event.pageX - position.x;
const dy = event.pageY - position.y;
const distance = Math.sqrt(dx * dx + dy * dy);
dollyStart.set(0, distance);
}
function handleTouchStartDollyPan(event) {
if (scope.enableZoom) handleTouchStartDolly(event);
if (scope.enablePan) handleTouchStartPan(event);
}
function handleTouchStartDollyRotate(event) {
if (scope.enableZoom) handleTouchStartDolly(event);
if (scope.enableRotate) handleTouchStartRotate(event);
}
function handleTouchMoveRotate(event) {
if (pointers.length == 1) {
rotateEnd.set(event.pageX, event.pageY);
} else {
const position = getSecondPointerPosition(event);
const x = 0.5 * (event.pageX + position.x);
const y = 0.5 * (event.pageY + position.y);
rotateEnd.set(x, y);
}
rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
const element = scope.domElement;
rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
rotateStart.copy(rotateEnd);
}
function handleTouchMovePan(event) {
if (pointers.length === 1) {
panEnd.set(event.pageX, event.pageY);
} else {
const position = getSecondPointerPosition(event);
const x = 0.5 * (event.pageX + position.x);
const y = 0.5 * (event.pageY + position.y);
panEnd.set(x, y);
}
panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
pan(panDelta.x, panDelta.y);
panStart.copy(panEnd);
}
function handleTouchMoveDolly(event) {
const position = getSecondPointerPosition(event);
const dx = event.pageX - position.x;
const dy = event.pageY - position.y;
const distance = Math.sqrt(dx * dx + dy * dy);
dollyEnd.set(0, distance);
dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
dollyOut(dollyDelta.y);
dollyStart.copy(dollyEnd);
const centerX = (event.pageX + position.x) * 0.5;
const centerY = (event.pageY + position.y) * 0.5;
updateZoomParameters(centerX, centerY);
}
function handleTouchMoveDollyPan(event) {
if (scope.enableZoom) handleTouchMoveDolly(event);
if (scope.enablePan) handleTouchMovePan(event);
}
function handleTouchMoveDollyRotate(event) {
if (scope.enableZoom) handleTouchMoveDolly(event);
if (scope.enableRotate) handleTouchMoveRotate(event);
}
function onPointerDown(event) {
if (scope.enabled === false) return;
if (pointers.length === 0) {
scope.domElement.setPointerCapture(event.pointerId);
scope.domElement.addEventListener("pointermove", onPointerMove);
scope.domElement.addEventListener("pointerup", onPointerUp);
}
if (isTrackingPointer(event)) return;
addPointer(event);
if (event.pointerType === "touch") {
onTouchStart(event);
} else {
onMouseDown(event);
}
}
function onPointerMove(event) {
if (scope.enabled === false) return;
if (event.pointerType === "touch") {
onTouchMove(event);
} else {
onMouseMove(event);
}
}
function onPointerUp(event) {
removePointer(event);
switch (pointers.length) {
case 0:
scope.domElement.releasePointerCapture(event.pointerId);
scope.domElement.removeEventListener("pointermove", onPointerMove);
scope.domElement.removeEventListener("pointerup", onPointerUp);
scope.dispatchEvent(_endEvent);
state = STATE.NONE;
break;
case 1:
const pointerId = pointers[0];
const position = pointerPositions[pointerId];
onTouchStart({ pointerId, pageX: position.x, pageY: position.y });
break;
}
}
function onMouseDown(event) {
let mouseAction;
switch (event.button) {
case 0:
mouseAction = scope.mouseButtons.LEFT;
break;
case 1:
mouseAction = scope.mouseButtons.MIDDLE;
break;
case 2:
mouseAction = scope.mouseButtons.RIGHT;
break;
default:
mouseAction = -1;
}
switch (mouseAction) {
case MOUSE.DOLLY:
if (scope.enableZoom === false) return;
handleMouseDownDolly(event);
state = STATE.DOLLY;
break;
case MOUSE.ROTATE:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
if (scope.enablePan === false) return;
handleMouseDownPan(event);
state = STATE.PAN;
} else {
if (scope.enableRotate === false) return;
handleMouseDownRotate(event);
state = STATE.ROTATE;
}
break;
case MOUSE.PAN:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
if (scope.enableRotate === false) return;
handleMouseDownRotate(event);
state = STATE.ROTATE;
} else {
if (scope.enablePan === false) return;
handleMouseDownPan(event);
state = STATE.PAN;
}
break;
default:
state = STATE.NONE;
}
if (state !== STATE.NONE) {
scope.dispatchEvent(_startEvent);
}
}
function onMouseMove(event) {
switch (state) {
case STATE.ROTATE:
if (scope.enableRotate === false) return;
handleMouseMoveRotate(event);
break;
case STATE.DOLLY:
if (scope.enableZoom === false) return;
handleMouseMoveDolly(event);
break;
case STATE.PAN:
if (scope.enablePan === false) return;
handleMouseMovePan(event);
break;
}
}
function onMouseWheel(event) {
if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;
event.preventDefault();
scope.dispatchEvent(_startEvent);
handleMouseWheel(customWheelEvent(event));
scope.dispatchEvent(_endEvent);
}
function customWheelEvent(event) {
const mode = event.deltaMode;
const newEvent = {
clientX: event.clientX,
clientY: event.clientY,
deltaY: event.deltaY
};
switch (mode) {
case 1:
newEvent.deltaY *= 16;
break;
case 2:
newEvent.deltaY *= 100;
break;
}
if (event.ctrlKey && !controlActive) {
newEvent.deltaY *= 10;
}
return newEvent;
}
function interceptControlDown(event) {
if (event.key === "Control") {
controlActive = true;
const document2 = scope.domElement.getRootNode();
document2.addEventListener("keyup", interceptControlUp, { passive: true, capture: true });
}
}
function interceptControlUp(event) {
if (event.key === "Control") {
controlActive = false;
const document2 = scope.domElement.getRootNode();
document2.removeEventListener("keyup", interceptControlUp, { passive: true, capture: true });
}
}
function onKeyDown(event) {
if (scope.enabled === false || scope.enablePan === false) return;
handleKeyDown(event);
}
function onTouchStart(event) {
trackPointer(event);
switch (pointers.length) {
case 1:
switch (scope.touches.ONE) {
case TOUCH.ROTATE:
if (scope.enableRotate === false) return;
handleTouchStartRotate(event);
state = STATE.TOUCH_ROTATE;
break;
case TOUCH.PAN:
if (scope.enablePan === false) return;
handleTouchStartPan(event);
state = STATE.TOUCH_PAN;
break;
default:
state = STATE.NONE;
}
break;
case 2:
switch (scope.touches.TWO) {
case TOUCH.DOLLY_PAN:
if (scope.enableZoom === false && scope.enablePan === false) return;
handleTouchStartDollyPan(event);
state = STATE.TOUCH_DOLLY_PAN;
break;
case TOUCH.DOLLY_ROTATE:
if (scope.enableZoom === false && scope.enableRotate === false) return;
handleTouchStartDollyRotate(event);
state = STATE.TOUCH_DOLLY_ROTATE;
break;
default:
state = STATE.NONE;
}
break;
default:
state = STATE.NONE;
}
if (state !== STATE.NONE) {
scope.dispatchEvent(_startEvent);
}
}
function onTouchMove(event) {
trackPointer(event);
switch (state) {
case STATE.TOUCH_ROTATE:
if (scope.enableRotate === false) return;
handleTouchMoveRotate(event);
scope.update();
break;
case STATE.TOUCH_PAN:
if (scope.enablePan === false) return;
handleTouchMovePan(event);
scope.update();
break;
case STATE.TOUCH_DOLLY_PAN:
if (scope.enableZoom === false && scope.enablePan === false) return;
handleTouchMoveDollyPan(event);
scope.update();
break;
case STATE.TOUCH_DOLLY_ROTATE:
if (scope.enableZoom === false && scope.enableRotate === false) return;
handleTouchMoveDollyRotate(event);
scope.update();
break;
default:
state = STATE.NONE;
}
}
function onContextMenu(event) {
if (scope.enabled === false) return;
event.preventDefault();
}
function addPointer(event) {
pointers.push(event.pointerId);
}
function removePointer(event) {
delete pointerPositions[event.pointerId];
for (let i = 0; i < pointers.length; i++) {
if (pointers[i] == event.pointerId) {
pointers.splice(i, 1);
return;
}
}
}
function isTrackingPointer(event) {
for (let i = 0; i < pointers.length; i++) {
if (pointers[i] == event.pointerId) return true;
}
return false;
}
function trackPointer(event) {
let position = pointerPositions[event.pointerId];
if (position === void 0) {
position = new Vector2();
pointerPositions[event.pointerId] = position;
}
position.set(event.pageX, event.pageY);
}
function getSecondPointerPosition(event) {
const pointerId = event.pointerId === pointers[0] ? pointers[1] : pointers[0];
return pointerPositions[pointerId];
}
scope.domElement.addEventListener("contextmenu", onContextMenu);
scope.domElement.addEventListener("pointerdown", onPointerDown);
scope.domElement.addEventListener("pointercancel", onPointerUp);
scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false });
const document = scope.domElement.getRootNode();
document.addEventListener("keydown", interceptControlDown, { passive: true, capture: true });
this.update();
}
};
export {
OrbitControls
};
//# sourceMappingURL=three_examples_jsm_controls_OrbitControls__js.js.map

7
site/real_game/node_modules/.vite/deps/three_examples_jsm_controls_OrbitControls__js.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long