├── .gitignore ├── .haxelib ├── three-toolkit │ ├── .current │ └── git │ │ ├── CompileTime.hx │ │ ├── Partial.hx │ │ ├── README.md │ │ ├── Structure.hx │ │ ├── animation │ │ ├── Animator.hx │ │ ├── Easing.hx │ │ ├── Spring.hx │ │ └── Tween.hx │ │ ├── control │ │ └── ArcBallControl.hx │ │ ├── ds │ │ └── Watchable.hx │ │ ├── environment │ │ └── EnvironmentManager.hx │ │ ├── event │ │ ├── KeyboardEvent.hx │ │ ├── PointerEvent.hx │ │ ├── PointerState.hx │ │ ├── ViewEventManager.hx │ │ └── WheelEvent.hx │ │ ├── fluid │ │ ├── FluidSimulation.hx │ │ ├── shared.glsl │ │ └── vertex-shader.glsl │ │ ├── haxelib.json │ │ ├── material │ │ └── CustomPhysicalMaterial.hx │ │ ├── math │ │ ├── ExponentialMovingAverage.hx │ │ ├── Matrix.hx │ │ ├── Quat.hx │ │ └── Scalar.hx │ │ ├── noise │ │ ├── CurlNoise.hx │ │ └── Snoise.hx │ │ ├── objects │ │ ├── BackgroundEnvironment.hx │ │ ├── ClipSpaceTriangle.hx │ │ ├── GlassReflectiveFloor.hx │ │ ├── PbrPlanarReflector.hx │ │ ├── UVTriangle.hx │ │ ├── UnitPlaneGeometry.hx │ │ └── XZPlaneBufferGeometry.hx │ │ ├── rendering │ │ ├── CompLayer.hx │ │ ├── DualRenderTarget.hx │ │ ├── FloatTexturePacker.hx │ │ ├── FragmentRenderer.hx │ │ ├── FragmentShader.hx │ │ ├── HeightMapRenderer.hx │ │ ├── PosDeltaSampler.hx │ │ ├── PostProcess.hx │ │ ├── RenderLayer.hx │ │ ├── RenderTargetStore.hx │ │ ├── ShaderMaterialParameters.hx │ │ ├── Texture.hx │ │ ├── UVRenderer.hx │ │ ├── WebGLRenderTarget.hx │ │ └── WorldPositionRenderer.hx │ │ ├── shaders │ │ ├── BloomBlend.hx │ │ ├── Blur1D.hx │ │ ├── Copy.hx │ │ ├── Fxaa.hx │ │ ├── OutputMap.hx │ │ ├── ShaderLib.hx │ │ ├── SignedDistances.hx │ │ ├── fxaa-frag.glsl │ │ ├── fxaa-vert.glsl │ │ ├── hash.glsl │ │ └── noise │ │ │ ├── README │ │ │ ├── cellular2D.glsl │ │ │ ├── cellular2x2.glsl │ │ │ ├── cellular2x2x2.glsl │ │ │ ├── cellular3D.glsl │ │ │ ├── classicnoise2D.glsl │ │ │ ├── classicnoise3D.glsl │ │ │ ├── classicnoise4D.glsl │ │ │ ├── noise2D.glsl │ │ │ ├── noise3D.glsl │ │ │ ├── noise3Dgrad.glsl │ │ │ ├── noise4D.glsl │ │ │ ├── noise4Dgrad.glsl │ │ │ └── psrdnoise2D.glsl │ │ ├── three │ │ ├── Layers.hx │ │ ├── Uniform.hx │ │ └── WebGLRenderTargetOptions.hx │ │ ├── tool │ │ ├── CameraTools.hx │ │ ├── CpuTextureSampler.hx │ │ ├── EventEmitter.hx │ │ ├── EventTools.hx │ │ ├── IBLGenerator.hx │ │ ├── LightingDebugProbes.hx │ │ ├── Object3DTools.hx │ │ ├── ShaderDev.hx │ │ ├── StringTools.hx │ │ ├── TextureTools.hx │ │ ├── VectorMathTools.hx │ │ └── WebGLPerformanceMonitor.hx │ │ └── ui │ │ ├── DevUI.hx │ │ └── dat_gui │ │ ├── GUI.hx │ │ ├── GUIController.hx │ │ └── GUIParams.hx ├── three │ ├── .current │ └── 0,135,0 │ │ ├── README.md │ │ ├── Three.hx │ │ ├── haxelib.json │ │ ├── js │ │ ├── html │ │ │ ├── EventListenerObject.hx │ │ │ ├── EventListenerOrEventListenerObject.hx │ │ │ ├── IProgressEvent.hx │ │ │ └── ProgressEvent_.hx │ │ └── lib │ │ │ ├── ArrayLike.hx │ │ │ ├── IterableIterator.hx │ │ │ ├── IteratorResult.hx │ │ │ ├── IteratorReturnResult.hx │ │ │ └── IteratorYieldResult.hx │ │ ├── three │ │ ├── AmbientLight.hx │ │ ├── AmbientLightProbe.hx │ │ ├── AnimationAction.hx │ │ ├── AnimationActionLoopStyles.hx │ │ ├── AnimationBlendMode.hx │ │ ├── AnimationClip.hx │ │ ├── AnimationLoader.hx │ │ ├── AnimationMixer.hx │ │ ├── AnimationObjectGroup.hx │ │ ├── AnimationUtils.hx │ │ ├── ArcCurve.hx │ │ ├── ArrayCamera.hx │ │ ├── ArrowHelper.hx │ │ ├── Audio.hx │ │ ├── AudioAnalyser.hx │ │ ├── AudioContext.hx │ │ ├── AudioListener.hx │ │ ├── AudioLoader.hx │ │ ├── AxesHelper.hx │ │ ├── BaseEvent.hx │ │ ├── Blending.hx │ │ ├── BlendingDstFactor.hx │ │ ├── BlendingEquation.hx │ │ ├── BlendingSrcFactor.hx │ │ ├── Bone.hx │ │ ├── BooleanKeyframeTrack.hx │ │ ├── Box2.hx │ │ ├── Box3.hx │ │ ├── Box3Helper.hx │ │ ├── BoxGeometry.hx │ │ ├── BoxHelper.hx │ │ ├── BufferAttribute.hx │ │ ├── BufferGeometry.hx │ │ ├── BufferGeometryLoader.hx │ │ ├── BufferGeometryUtils.hx │ │ ├── BuiltinShaderAttributeName.hx │ │ ├── Cache.hx │ │ ├── Camera.hx │ │ ├── CameraHelper.hx │ │ ├── CanvasTexture.hx │ │ ├── CatmullRomCurve3.hx │ │ ├── CircleGeometry.hx │ │ ├── Clock.hx │ │ ├── Color.hx │ │ ├── ColorKeyframeTrack.hx │ │ ├── ColorRepresentation.hx │ │ ├── Combine.hx │ │ ├── CompressedPixelFormat.hx │ │ ├── CompressedTexture.hx │ │ ├── CompressedTextureLoader.hx │ │ ├── ConeGeometry.hx │ │ ├── Constructor.hx │ │ ├── CubeCamera.hx │ │ ├── CubeTexture.hx │ │ ├── CubeTextureLoader.hx │ │ ├── CubicBezierCurve.hx │ │ ├── CubicBezierCurve3.hx │ │ ├── CubicInterpolant.hx │ │ ├── CullFace.hx │ │ ├── Curve.hx │ │ ├── CurvePath.hx │ │ ├── CurveUtils.hx │ │ ├── CylinderGeometry.hx │ │ ├── Cylindrical.hx │ │ ├── DOMPointInit.hx │ │ ├── DataTexture.hx │ │ ├── DataTexture2DArray.hx │ │ ├── DataTexture3D.hx │ │ ├── DataTextureLoader.hx │ │ ├── DataUtils.hx │ │ ├── DepthModes.hx │ │ ├── DepthPackingStrategies.hx │ │ ├── DepthTexture.hx │ │ ├── DirectionalLight.hx │ │ ├── DirectionalLightHelper.hx │ │ ├── DirectionalLightShadow.hx │ │ ├── DiscreteInterpolant.hx │ │ ├── DodecahedronGeometry.hx │ │ ├── EdgesGeometry.hx │ │ ├── EllipseCurve.hx │ │ ├── Euler.hx │ │ ├── Event.hx │ │ ├── EventDispatcher.hx │ │ ├── EventListener.hx │ │ ├── ExtrudeGeometry.hx │ │ ├── ExtrudeGeometryOptions.hx │ │ ├── Face.hx │ │ ├── FileLoader.hx │ │ ├── Float16BufferAttribute.hx │ │ ├── Float32Attribute.hx │ │ ├── Float32BufferAttribute.hx │ │ ├── Float64Attribute.hx │ │ ├── Float64BufferAttribute.hx │ │ ├── Fog.hx │ │ ├── FogBase.hx │ │ ├── FogExp2.hx │ │ ├── Frustum.hx │ │ ├── GLBufferAttribute.hx │ │ ├── GLSLVersion.hx │ │ ├── GeometryUtils.hx │ │ ├── GridHelper.hx │ │ ├── Group.hx │ │ ├── HSL.hx │ │ ├── HemisphereLight.hx │ │ ├── HemisphereLightHelper.hx │ │ ├── HemisphereLightProbe.hx │ │ ├── ILoaderUtils.hx │ │ ├── IUniform.hx │ │ ├── IcosahedronGeometry.hx │ │ ├── ImageBitmapLoader.hx │ │ ├── ImageLoader.hx │ │ ├── ImageUtils.hx │ │ ├── InstancedBufferAttribute.hx │ │ ├── InstancedBufferGeometry.hx │ │ ├── InstancedInterleavedBuffer.hx │ │ ├── InstancedMesh.hx │ │ ├── Int16Attribute.hx │ │ ├── Int16BufferAttribute.hx │ │ ├── Int32Attribute.hx │ │ ├── Int32BufferAttribute.hx │ │ ├── Int8Attribute.hx │ │ ├── Int8BufferAttribute.hx │ │ ├── InterleavedBuffer.hx │ │ ├── InterleavedBufferAttribute.hx │ │ ├── Interpolant.hx │ │ ├── InterpolationEndingModes.hx │ │ ├── InterpolationModes.hx │ │ ├── Intersection.hx │ │ ├── KeyframeTrack.hx │ │ ├── LOD.hx │ │ ├── LatheGeometry.hx │ │ ├── Layers.hx │ │ ├── Light.hx │ │ ├── LightProbe.hx │ │ ├── LightShadow.hx │ │ ├── Line.hx │ │ ├── Line3.hx │ │ ├── LineBasicMaterial.hx │ │ ├── LineBasicMaterialParameters.hx │ │ ├── LineCurve.hx │ │ ├── LineCurve3.hx │ │ ├── LineDashedMaterial.hx │ │ ├── LineDashedMaterialParameters.hx │ │ ├── LineLoop.hx │ │ ├── LineSegments.hx │ │ ├── LinearInterpolant.hx │ │ ├── Loader.hx │ │ ├── LoaderUtils.hx │ │ ├── LoadingManager.hx │ │ ├── MOUSE.hx │ │ ├── Mapping.hx │ │ ├── Material.hx │ │ ├── MaterialLoader.hx │ │ ├── MaterialParameters.hx │ │ ├── Matrix.hx │ │ ├── Matrix3.hx │ │ ├── Matrix3Tuple.hx │ │ ├── Matrix4.hx │ │ ├── Matrix4Tuple.hx │ │ ├── Mesh.hx │ │ ├── MeshBasicMaterial.hx │ │ ├── MeshBasicMaterialParameters.hx │ │ ├── MeshDepthMaterial.hx │ │ ├── MeshDepthMaterialParameters.hx │ │ ├── MeshDistanceMaterial.hx │ │ ├── MeshDistanceMaterialParameters.hx │ │ ├── MeshLambertMaterial.hx │ │ ├── MeshLambertMaterialParameters.hx │ │ ├── MeshMatcapMaterial.hx │ │ ├── MeshMatcapMaterialParameters.hx │ │ ├── MeshNormalMaterial.hx │ │ ├── MeshNormalMaterialParameters.hx │ │ ├── MeshPhongMaterial.hx │ │ ├── MeshPhongMaterialParameters.hx │ │ ├── MeshPhysicalMaterial.hx │ │ ├── MeshPhysicalMaterialParameters.hx │ │ ├── MeshStandardMaterial.hx │ │ ├── MeshStandardMaterialParameters.hx │ │ ├── MeshToonMaterial.hx │ │ ├── MeshToonMaterialParameters.hx │ │ ├── MorphTarget.hx │ │ ├── Navigator.hx │ │ ├── NormalMapTypes.hx │ │ ├── NumberKeyframeTrack.hx │ │ ├── Object3D.hx │ │ ├── ObjectLoader.hx │ │ ├── OctahedronGeometry.hx │ │ ├── OffscreenCanvas.hx │ │ ├── OrthographicCamera.hx │ │ ├── PMREMGenerator.hx │ │ ├── ParseTrackNameResults.hx │ │ ├── Path.hx │ │ ├── PerspectiveCamera.hx │ │ ├── PixelFormat.hx │ │ ├── PixelFormatGPU.hx │ │ ├── Plane.hx │ │ ├── PlaneGeometry.hx │ │ ├── PlaneHelper.hx │ │ ├── PointLight.hx │ │ ├── PointLightHelper.hx │ │ ├── PointLightShadow.hx │ │ ├── Points.hx │ │ ├── PointsMaterial.hx │ │ ├── PointsMaterialParameters.hx │ │ ├── PolarGridHelper.hx │ │ ├── PolyhedronGeometry.hx │ │ ├── PositionalAudio.hx │ │ ├── PropertyBinding.hx │ │ ├── PropertyMixer.hx │ │ ├── QuadraticBezierCurve.hx │ │ ├── QuadraticBezierCurve3.hx │ │ ├── Quaternion.hx │ │ ├── QuaternionKeyframeTrack.hx │ │ ├── QuaternionLinearInterpolant.hx │ │ ├── RawShaderMaterial.hx │ │ ├── Ray.hx │ │ ├── Raycaster.hx │ │ ├── RaycasterParameters.hx │ │ ├── RectAreaLight.hx │ │ ├── RenderItem.hx │ │ ├── Renderer.hx │ │ ├── RingGeometry.hx │ │ ├── Scene.hx │ │ ├── Shader.hx │ │ ├── ShaderMaterial.hx │ │ ├── ShaderMaterialParameters.hx │ │ ├── Shading.hx │ │ ├── ShadowMapType.hx │ │ ├── ShadowMaterial.hx │ │ ├── ShadowMaterialParameters.hx │ │ ├── Shape.hx │ │ ├── ShapeGeometry.hx │ │ ├── ShapePath.hx │ │ ├── ShapeUtils.hx │ │ ├── Side.hx │ │ ├── Skeleton.hx │ │ ├── SkeletonHelper.hx │ │ ├── SkinnedMesh.hx │ │ ├── Sphere.hx │ │ ├── SphereGeometry.hx │ │ ├── Spherical.hx │ │ ├── SphericalHarmonics3.hx │ │ ├── SplineCurve.hx │ │ ├── SpotLight.hx │ │ ├── SpotLightHelper.hx │ │ ├── SpotLightShadow.hx │ │ ├── Sprite.hx │ │ ├── SpriteMaterial.hx │ │ ├── SpriteMaterialParameters.hx │ │ ├── StencilFunc.hx │ │ ├── StencilOp.hx │ │ ├── StereoCamera.hx │ │ ├── StringKeyframeTrack.hx │ │ ├── TOUCH.hx │ │ ├── TetrahedronGeometry.hx │ │ ├── Texture.hx │ │ ├── TextureDataType.hx │ │ ├── TextureEncoding.hx │ │ ├── TextureFilter.hx │ │ ├── TextureLoader.hx │ │ ├── ToneMapping.hx │ │ ├── TorusGeometry.hx │ │ ├── TorusKnotGeometry.hx │ │ ├── Triangle.hx │ │ ├── TrianglesDrawModes.hx │ │ ├── TubeGeometry.hx │ │ ├── UVGenerator.hx │ │ ├── Uint16Attribute.hx │ │ ├── Uint16BufferAttribute.hx │ │ ├── Uint32Attribute.hx │ │ ├── Uint32BufferAttribute.hx │ │ ├── Uint8Attribute.hx │ │ ├── Uint8BufferAttribute.hx │ │ ├── Uint8ClampedAttribute.hx │ │ ├── Uint8ClampedBufferAttribute.hx │ │ ├── Uniform.hx │ │ ├── UniformsUtils.hx │ │ ├── Usage.hx │ │ ├── Vec2.hx │ │ ├── Vector.hx │ │ ├── Vector2.hx │ │ ├── Vector2Tuple.hx │ │ ├── Vector3.hx │ │ ├── Vector3Tuple.hx │ │ ├── Vector4.hx │ │ ├── Vector4Tuple.hx │ │ ├── VectorKeyframeTrack.hx │ │ ├── VideoTexture.hx │ │ ├── WebGL1Renderer.hx │ │ ├── WebGLBufferRenderer.hx │ │ ├── WebGLCapabilities.hx │ │ ├── WebGLCapabilitiesParameters.hx │ │ ├── WebGLClipping.hx │ │ ├── WebGLColorBuffer.hx │ │ ├── WebGLCubeRenderTarget.hx │ │ ├── WebGLCubeUVMaps.hx │ │ ├── WebGLDebug.hx │ │ ├── WebGLDepthBuffer.hx │ │ ├── WebGLExtensions.hx │ │ ├── WebGLGeometries.hx │ │ ├── WebGLIndexedBufferRenderer.hx │ │ ├── WebGLInfo.hx │ │ ├── WebGLLights.hx │ │ ├── WebGLMultipleRenderTargets.hx │ │ ├── WebGLMultisampleRenderTarget.hx │ │ ├── WebGLObjects.hx │ │ ├── WebGLProgram.hx │ │ ├── WebGLPrograms.hx │ │ ├── WebGLProperties.hx │ │ ├── WebGLRenderList.hx │ │ ├── WebGLRenderLists.hx │ │ ├── WebGLRenderTarget.hx │ │ ├── WebGLRenderTargetOptions.hx │ │ ├── WebGLRenderer.hx │ │ ├── WebGLRendererParameters.hx │ │ ├── WebGLRenderingContext.hx │ │ ├── WebGLShadowMap.hx │ │ ├── WebGLState.hx │ │ ├── WebGLStencilBuffer.hx │ │ ├── WebGLTextures.hx │ │ ├── WebGLUniforms.hx │ │ ├── WebXRController.hx │ │ ├── WebXRManager.hx │ │ ├── Window.hx │ │ ├── WireframeGeometry.hx │ │ ├── Wrapping.hx │ │ ├── XR.hx │ │ ├── XRAnchor.hx │ │ ├── XRAnchorSet.hx │ │ ├── XRAnimationLoopCallback.hx │ │ ├── XRControllerEventType.hx │ │ ├── XREnvironmentBlendMode.hx │ │ ├── XREventType.hx │ │ ├── XREye.hx │ │ ├── XRFrame.hx │ │ ├── XRFrameRequestCallback.hx │ │ ├── XRGamepad.hx │ │ ├── XRHand.hx │ │ ├── XRHandJoint.hx │ │ ├── XRHandedness.hx │ │ ├── XRHitResult.hx │ │ ├── XRHitTestOptionsInit.hx │ │ ├── XRHitTestResult.hx │ │ ├── XRHitTestSource.hx │ │ ├── XRHitTestTrackableType.hx │ │ ├── XRInputSource.hx │ │ ├── XRInputSourceChangeEvent.hx │ │ ├── XRInputSourceEvent.hx │ │ ├── XRJointPose.hx │ │ ├── XRJointSpace.hx │ │ ├── XRPlane.hx │ │ ├── XRPlaneSet.hx │ │ ├── XRPose.hx │ │ ├── XRRay.hx │ │ ├── XRRayDirectionInit.hx │ │ ├── XRReferenceSpace.hx │ │ ├── XRReferenceSpaceType.hx │ │ ├── XRRenderState.hx │ │ ├── XRRenderStateInit.hx │ │ ├── XRRigidTransform.hx │ │ ├── XRSession.hx │ │ ├── XRSessionInit.hx │ │ ├── XRSessionMode.hx │ │ ├── XRTargetRayMode.hx │ │ ├── XRTransientInputHitTestOptionsInit.hx │ │ ├── XRTransientInputHitTestResult.hx │ │ ├── XRTransientInputHitTestSource.hx │ │ ├── XRView.hx │ │ ├── XRViewerPose.hx │ │ ├── XRViewport.hx │ │ ├── XRVisibilityState.hx │ │ ├── XRWebGLLayer.hx │ │ ├── XRWebGLLayerInit.hx │ │ ├── examples │ │ │ └── jsm │ │ │ │ ├── loaders │ │ │ │ ├── dracoloader │ │ │ │ │ └── DRACOLoader.hx │ │ │ │ ├── gltfloader │ │ │ │ │ ├── GLTF.hx │ │ │ │ │ ├── GLTFLoader.hx │ │ │ │ │ ├── GLTFLoaderPlugin.hx │ │ │ │ │ ├── GLTFParser.hx │ │ │ │ │ ├── GLTFReference.hx │ │ │ │ │ └── GLTFReferenceType.hx │ │ │ │ ├── ktx2loader │ │ │ │ │ └── KTX2Loader.hx │ │ │ │ └── rgbeloader │ │ │ │ │ ├── RGBE.hx │ │ │ │ │ └── RGBELoader.hx │ │ │ │ └── objects │ │ │ │ └── reflector │ │ │ │ ├── Reflector.hx │ │ │ │ └── ReflectorOptions.hx │ │ ├── propertybinding │ │ │ └── Composite.hx │ │ └── src │ │ │ ├── Constants.hx │ │ │ ├── Three.hx │ │ │ ├── loaders │ │ │ ├── LoaderUtils.hx │ │ │ └── LoadingManager.hx │ │ │ ├── math │ │ │ └── MathUtils.hx │ │ │ ├── objects │ │ │ └── LineSegments.hx │ │ │ └── renderers │ │ │ ├── shaders │ │ │ ├── ShaderChunk.hx │ │ │ ├── ShaderLib.hx │ │ │ ├── UniformsLib.hx │ │ │ └── UniformsUtils.hx │ │ │ └── webgl │ │ │ ├── WebGLShader.hx │ │ │ ├── webglattributes │ │ │ └── WebGLAttributes.hx │ │ │ ├── webglbindingstates │ │ │ └── WebGLBindingStates.hx │ │ │ ├── webglcubemaps │ │ │ └── WebGLCubeMaps.hx │ │ │ └── webglutils │ │ │ └── WebGLUtils.hx │ │ └── ts │ │ ├── AnyOf2.hx │ │ ├── AnyOf3.hx │ │ ├── AnyOf4.hx │ │ ├── Tuple1.hx │ │ ├── Tuple16.hx │ │ ├── Tuple2.hx │ │ ├── Tuple3.hx │ │ ├── Tuple4.hx │ │ ├── Tuple9.hx │ │ └── Undefined.hx └── vector-math │ ├── .current │ └── 2,4,0 │ ├── LICENSE │ ├── Mat2.hx │ ├── Mat3.hx │ ├── Mat4.hx │ ├── README.md │ ├── Vec2.hx │ ├── Vec3.hx │ ├── Vec4.hx │ ├── VectorMath.hx │ ├── VectorMath.macro.hx │ ├── haxelib.json │ └── test │ ├── .gitignore │ ├── Main.hx │ ├── TestFramework.hx │ ├── each.hxml │ ├── test-all.hxml │ ├── test-cpp.hxml │ ├── test-eval.hxml │ ├── test-hl.hxml │ ├── test-hlc.hxml │ └── test-js.hxml ├── .vscode ├── settings.json └── tasks.json ├── README.md ├── assets └── env │ ├── README.md │ ├── birchwood_2k.rgbd.png │ ├── blouberg_sunrise_1_2k.rgbd.png │ ├── hilly_terrain_01_1k.rgbd.png │ ├── kiara_1_dawn_2k.rgbd.png │ ├── night_bridge_2k.rgbd.png │ ├── snowy_forest_path_01_1k.rgbd.png │ ├── snowy_park_01_1k.rgbd.png │ ├── the_sky_is_on_fire_2k.rgbd.png │ ├── venice_sunset_2k.rgbd.png │ └── winter_lake_01_1k.rgbd.png ├── bin ├── app.js ├── bundle.js └── bundle.js.map ├── build.hxml ├── index.html ├── package-lock.json ├── package.json └── src ├── Main.hx ├── haxe-logo.glb └── import.hx /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules -------------------------------------------------------------------------------- /.haxelib/three-toolkit/.current: -------------------------------------------------------------------------------- 1 | git -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/README.md: -------------------------------------------------------------------------------- 1 | # Three.js Toolkit 2 | 3 | This is an assortment of classes I use when developing three.js haxe projects. Feel free to use them too, however, it's not designed to be a user-friendly library and code here is likely to change frequently. To use it, it's best to link to a specific commit to avoid troubles building in the future 4 | 5 | Happy to accept PRs and issues! 6 | 7 | ## Requirements 8 | - I use three.js r135 via dts2hx, other version may work 9 | - Newer versions of three.js require `-D js-es=6` (however three.js and earlier r121 does not) 10 | 11 | To generate the required three.js types: 12 | ``` 13 | npm install three@0.135.0 @types/three@0.135.0 dts2hx 14 | dts2hx three three/examples/jsm/loaders/RGBELoader three/examples/jsm/loaders/GLTFLoader three/examples/jsm/objects/Reflector -m 15 | ``` 16 | 17 | Some types rely on [VectorMath](https://github.com/haxiomic/vector-math), install with `haxelib install vector-math` 18 | 19 | See [haxiomic/haxe-threejs-template](https://github.com/haxiomic/haxe-threejs-template) for an example on usage 20 | -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/ds/Watchable.hx: -------------------------------------------------------------------------------- 1 | package ds; 2 | 3 | class Watchable { 4 | 5 | @:isVar public var value(get, set): T; 6 | final callbacks = new Array<(v:T) -> Void>(); 7 | 8 | public inline function new(v: T) { 9 | this.value = v; 10 | } 11 | 12 | public inline function watch(cb: (v: T) -> Void) { 13 | callbacks.push(cb); 14 | cb(value); 15 | return { unwatch: () -> unwatch(cb) }; 16 | } 17 | 18 | public inline function unwatch(cb: (v: T) -> Void) { 19 | return callbacks.remove(cb); 20 | } 21 | 22 | inline function set_value(v: T) { 23 | this.value = v; 24 | for (cb in callbacks) cb(v); 25 | return v; 26 | } 27 | 28 | inline function get_value() { 29 | return this.value; 30 | } 31 | 32 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/fluid/shared.glsl: -------------------------------------------------------------------------------- 1 | vec2 clipToSimSpace(vec2 clipSpace){ 2 | return vec2(clipSpace.x / invResolution.z, clipSpace.y); 3 | } 4 | 5 | vec2 simToTexelSpace(vec2 simSpace){ 6 | return vec2(simSpace.x * invResolution.z + 1.0 , simSpace.y + 1.0)*.5; 7 | } 8 | 9 | // pure Neumann boundary conditions: 0 pressure gradient across the boundary 10 | // dP/dx = 0 11 | // this is implict applied with CLAMP_TO_EDGE when reading from the pressure texture so we don't actually need to to anything in the shader 12 | // #define PRESSURE_BOUNDARY 13 | 14 | // free-slip boundary: the average flow across the boundary is restricted to 0 15 | // avg(uA.xy, uB.xy) dot (boundary normal).xy = 0 16 | // this is applied by reflecting the velocity across the boundary (i.e, multipling the boundary velocity by -1 when reading outside) 17 | 18 | // must not make any changes to coord after it arrives from vertex shader (including no swizzle) to enable inter-stage texture prefetching 19 | #define samplePressure(texture, coord) ( texture2D(pressure, coord).x ) 20 | #define outOfBoundsVelocityMultiplier(coord) (velocityBoundaryEnabled ? (step(vec2(0.), coord) * step(coord, vec2(1.)) * 2. - 1. ) : vec2(1.0)) 21 | 22 | #define sampleVelocity(texture, coord) ( outOfBoundsVelocityMultiplier(coord) * texture2D(velocity, coord).xy ) -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/fluid/vertex-shader.glsl: -------------------------------------------------------------------------------- 1 | // clip-space 2 | attribute vec2 position; 3 | 4 | uniform vec3 invResolution; // (1/w, 1/h, h/w) 5 | 6 | #ifdef UV 7 | varying vec2 vUv; 8 | #endif 9 | 10 | #ifdef FINITE_DIFFERENCE 11 | // precomute texel offsets as varyings to enable texture prefetching 12 | varying vec2 vL; 13 | varying vec2 vR; 14 | varying vec2 vB; 15 | varying vec2 vT; 16 | #endif 17 | 18 | #ifdef SIMULATION_POSITION 19 | // clip-space where aspect ratio is maintained and height is fixed at 1 20 | varying vec2 p; 21 | #endif 22 | 23 | void main() { 24 | vec2 texelCoord = position * 0.5 + 0.5; 25 | 26 | #ifdef FINITE_DIFFERENCE 27 | vL = texelCoord - vec2(invResolution.x,0); 28 | vR = texelCoord + vec2(invResolution.x,0); 29 | vB = texelCoord - vec2(0,invResolution.y); 30 | vT = texelCoord + vec2(0,invResolution.y); 31 | #endif 32 | 33 | #ifdef UV 34 | vUv = texelCoord; 35 | #endif 36 | 37 | #ifdef SIMULATION_POSITION 38 | p = vec2(position.x / invResolution.z, position.y); 39 | #endif 40 | 41 | gl_Position = vec4(position, 0.0, 1.0 ); 42 | } 43 | -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "three-toolkit", 3 | "url": "https://github.com/haxiomic/three-toolkit", 4 | "dependencies": { 5 | "vector-math": "" 6 | } 7 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/math/ExponentialMovingAverage.hx: -------------------------------------------------------------------------------- 1 | package math; 2 | 3 | class ExponentialMovingAverage { 4 | 5 | // decay parameter 6 | public var alpha: Float; 7 | 8 | public var average (default, null): Float; 9 | public var variance (default, null): Float; 10 | public var stdDev (default, null): Float; 11 | 12 | /** 13 | Using an alpha value closer to 1 means rapid exponential decay (fast transition to new values) 14 | **/ 15 | public function new(initialValue: Float, alpha: Float) { 16 | this.alpha = alpha; 17 | this.average = initialValue; 18 | addSample(initialValue); 19 | } 20 | 21 | public function addSample(v: Float) { 22 | var q = v - average; 23 | average = average + alpha * q; 24 | variance = (1.0 - alpha) * (variance + alpha * q * q); 25 | stdDev = Math.sqrt(variance); 26 | } 27 | 28 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/math/Matrix.hx: -------------------------------------------------------------------------------- 1 | package math; 2 | 3 | import three.Matrix4; 4 | import three.Plane; 5 | 6 | function reflectionMatrixFromPlane(plane: Plane, ?target: Matrix4): Matrix4 { 7 | var reflectionMatrix = target != null ? target : new Matrix4(); 8 | var a = plane.normal.x; 9 | var b = plane.normal.y; 10 | var c = plane.normal.z; 11 | var d = plane.constant; 12 | reflectionMatrix.set( 13 | 1-2*a*a, -2*a*b, -2*a*c, -2*a*d, 14 | -2*a*b, 1-2*b*b, -2*b*c, -2*b*d, 15 | -2*a*c, -2*b*c, 1-2*c*c, -2*c*d, 16 | 0, 0, 0, 1 17 | ); 18 | return reflectionMatrix; 19 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/objects/ClipSpaceTriangle.hx: -------------------------------------------------------------------------------- 1 | package objects; 2 | 3 | import three.Material; 4 | import three.BufferAttribute; 5 | import js.lib.Float32Array; 6 | import three.BufferGeometry; 7 | import three.Mesh; 8 | 9 | class ClipSpaceTriangle extends Mesh { 10 | 11 | public function new(material: Null) { 12 | super(globalGeom, material); 13 | this.frustumCulled = false; 14 | this.castShadow = false; 15 | this.receiveShadow = false; 16 | } 17 | 18 | static final globalGeom: BufferGeometry = { 19 | var buffer = new BufferGeometry(); 20 | var triangle = new Float32Array([ 21 | -1, -1, 22 | 3, -1, 23 | -1, 3, 24 | ]); 25 | var uv = new Float32Array(triangle.map(v -> v * 0.5 + 0.5)); 26 | buffer.setAttribute('position', new BufferAttribute(triangle, 2)); 27 | buffer.setAttribute('uv', new BufferAttribute(uv, 2)); 28 | 29 | buffer; 30 | }; 31 | 32 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/objects/UVTriangle.hx: -------------------------------------------------------------------------------- 1 | package objects; 2 | 3 | import three.Material; 4 | import three.BufferAttribute; 5 | import js.lib.Float32Array; 6 | import three.BufferGeometry; 7 | import three.Mesh; 8 | 9 | class UVTriangle extends Mesh { 10 | 11 | public function new(material: Null) { 12 | super(globalGeom, material); 13 | this.frustumCulled = false; 14 | this.castShadow = false; 15 | this.receiveShadow = false; 16 | } 17 | 18 | static final globalGeom: BufferGeometry = { 19 | var buffer = new BufferGeometry(); 20 | var triangle = new Float32Array([ 21 | 0, 0, 22 | 2, 0, 23 | 0, 2, 24 | ]); 25 | buffer.setAttribute('position', new BufferAttribute(triangle, 2)); 26 | 27 | buffer; 28 | }; 29 | 30 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/objects/UnitPlaneGeometry.hx: -------------------------------------------------------------------------------- 1 | package objects; 2 | 3 | import three.PlaneGeometry; 4 | 5 | class UnitPlaneGeometry extends three.PlaneGeometry { 6 | 7 | public function new() { 8 | super(1, 1, 1, 1); 9 | } 10 | 11 | static public final instance = new UnitPlaneGeometry(); 12 | 13 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/rendering/FragmentShader.hx: -------------------------------------------------------------------------------- 1 | package rendering; 2 | 3 | import three.RawShaderMaterial; 4 | 5 | /** 6 | Base for fragment renderer shaders 7 | **/ 8 | class FragmentShader extends RawShaderMaterial { 9 | 10 | public final typedUniforms: T; 11 | 12 | public function new(?parameters: ShaderMaterialParameters, ?fragmentShader: String) { 13 | var baseParameters = { 14 | uniforms: { }, 15 | vertexShader: ' 16 | attribute vec2 position; 17 | varying vec2 vUv; 18 | void main() { 19 | vUv = position * 0.5 + 0.5; 20 | gl_Position = vec4(position, 0., 1.); 21 | } 22 | ', 23 | fragmentShader: ' 24 | precision highp float; 25 | varying vec2 vUv; 26 | 27 | void main() { 28 | gl_FragColor = vec4(vUv, 0.0, 1.); 29 | } 30 | ', 31 | depthWrite: false, 32 | depthTest: false, 33 | } 34 | if (parameters != null) { 35 | baseParameters = Structure.extendAny(baseParameters, parameters); 36 | } 37 | if (fragmentShader != null) { 38 | baseParameters.fragmentShader = fragmentShader; 39 | } 40 | 41 | super(baseParameters); 42 | 43 | this.typedUniforms = cast this.uniforms; 44 | } 45 | 46 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/rendering/RenderLayer.hx: -------------------------------------------------------------------------------- 1 | package rendering; 2 | 3 | enum abstract RenderLayer(Int) { 4 | var Main = 0; 5 | var Blended; 6 | var DepthPrepass; 7 | var WorldPosition; 8 | var UVPosition; 9 | @:to inline function toFloat(): Float return this; 10 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/rendering/Texture.hx: -------------------------------------------------------------------------------- 1 | package rendering; 2 | 3 | /** 4 | Represents a three.Texture with a width and height field defined 5 | **/ 6 | @:forward 7 | @:forward.new 8 | @:transitive 9 | abstract Texture(three.Texture) to three.Texture { 10 | 11 | public var width(get, never): Float; 12 | public var height(get, never): Float; 13 | inline function get_width() return untyped this.image.width; 14 | inline function get_height() return untyped this.image.height; 15 | 16 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/rendering/UVRenderer.hx: -------------------------------------------------------------------------------- 1 | package rendering; 2 | 3 | import three.TextureDataType; 4 | import three.Side; 5 | import three.WebGLRenderer; 6 | 7 | class UVRenderer extends WorldPositionRenderer { 8 | 9 | public function new( 10 | renderer: WebGLRenderer, 11 | width: Int, 12 | height: Int, 13 | renderLayer: RenderLayer = UVPosition, 14 | depthPrepassLayer: RenderLayer = DepthPrepass, 15 | side: Side = DoubleSide, 16 | type: TextureDataType = HalfFloatType 17 | ) { 18 | super( 19 | renderer, 20 | width, 21 | height, 22 | renderLayer, 23 | depthPrepassLayer, 24 | side, 25 | type 26 | ); 27 | this.shaderMaterial.vertexShader = ' 28 | varying vec3 vUv; 29 | 30 | void main() { 31 | vUv = vec3(uv, 0.); 32 | 33 | // use the red channel of the vertex color for uv.z 34 | // this can be used to distinguish vertex islands 35 | #ifdef USE_COLOR 36 | vUv.z = color.r; 37 | #endif 38 | 39 | vec4 p = vec4(position, 1.0); 40 | vec4 worldP = modelMatrix * p; 41 | 42 | gl_Position = projectionMatrix * viewMatrix * worldP; 43 | } 44 | '; 45 | this.shaderMaterial.fragmentShader = ' 46 | varying vec3 vUv; 47 | 48 | void main() { 49 | gl_FragColor = vec4(vUv, 1.0); 50 | } 51 | '; 52 | this.shaderMaterial.vertexColors = true; 53 | } 54 | 55 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/rendering/WebGLRenderTarget.hx: -------------------------------------------------------------------------------- 1 | package rendering; 2 | 3 | /** 4 | Wraps three.WebGLRenderTarget but ensures its inner texture always has width and height defined 5 | **/ 6 | @:forward 7 | @:forward.new 8 | abstract WebGLRenderTarget(three.WebGLRenderTarget) from three.WebGLRenderTarget to three.WebGLRenderTarget { 9 | 10 | public var texture(get, never): rendering.Texture; 11 | inline function get_texture() return cast this.texture; 12 | 13 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/shaders/Copy.hx: -------------------------------------------------------------------------------- 1 | package shaders; 2 | 3 | import three.Texture; 4 | import three.Uniform; 5 | import three.RawShaderMaterial; 6 | 7 | class Copy extends RawShaderMaterial { 8 | 9 | static public inline function get(texture: Texture) { 10 | instance.uTexture.value = texture; 11 | return instance; 12 | } 13 | static final instance = new Copy(); 14 | 15 | public final uTexture: Uniform; 16 | 17 | public function new() { 18 | var uTexture = new Uniform(cast null); 19 | super({ 20 | uniforms: { 21 | uTexture: uTexture, 22 | }, 23 | vertexShader: ' 24 | attribute vec2 position; 25 | 26 | varying vec2 vUv; 27 | 28 | void main() { 29 | vUv = position * 0.5 + 0.5; 30 | gl_Position = vec4(position, 0., 1.); 31 | } 32 | ', 33 | fragmentShader: ' 34 | precision highp float; 35 | 36 | uniform sampler2D uTexture; 37 | 38 | varying vec2 vUv; 39 | 40 | void main() { 41 | gl_FragColor = texture2D(uTexture, vUv); 42 | } 43 | ', 44 | side: DoubleSide 45 | }); 46 | this.uTexture = uTexture; 47 | } 48 | 49 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/shaders/Fxaa.hx: -------------------------------------------------------------------------------- 1 | package shaders; 2 | 3 | import three.Vector2; 4 | import js.html.HTMLAllCollection; 5 | import three.Texture; 6 | import three.Uniform; 7 | import three.RawShaderMaterial; 8 | 9 | class Fxaa extends RawShaderMaterial { 10 | 11 | static public inline function get(texture: Texture, width: Float, height: Float) { 12 | instance.uTexture.value = texture; 13 | instance.uTexelSize.value.set(1/width, 1/height); 14 | return instance; 15 | } 16 | static final instance = new Fxaa(); 17 | 18 | public final uTexture = new Uniform(null); 19 | public final uTexelSize = new Uniform(new Vector2(1,1)); 20 | 21 | public function new() { 22 | super({ 23 | uniforms: { 24 | textureSampler: uTexture, 25 | texelSize: uTexelSize, 26 | }, 27 | vertexShader: tool.CompileTime.embedShader('./fxaa-vert.glsl'), 28 | fragmentShader: tool.CompileTime.embedShader('./fxaa-frag.glsl'), 29 | side: DoubleSide 30 | }); 31 | } 32 | 33 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/shaders/ShaderLib.hx: -------------------------------------------------------------------------------- 1 | package shaders; 2 | 3 | import tool.CompileTime; 4 | 5 | final hash = CompileTime.embedShader('hash.glsl'); -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/shaders/SignedDistances.hx: -------------------------------------------------------------------------------- 1 | package shaders; 2 | 3 | class SignedDistances { 4 | 5 | public static final sdSegment = ' 6 | // generalizes to n dimensions 7 | float sdSegment(vec2 x, vec2 a, vec2 b, out float alpha) { 8 | vec2 ab = b - a; 9 | vec2 ax = x - a; 10 | alpha = dot(ab, ax) / dot(ab, ab); 11 | vec2 d = ax - clamp(alpha, 0., 1.) * ab; 12 | return length(d); 13 | } 14 | 15 | float sdSegment(vec2 x, vec2 a, vec2 b) { 16 | float alpha; 17 | return sdSegment(x, a, b, alpha); 18 | } 19 | '; 20 | 21 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/shaders/fxaa-vert.glsl: -------------------------------------------------------------------------------- 1 | precision mediump float; 2 | 3 | // Attributes 4 | attribute vec2 position; 5 | uniform vec2 texelSize; 6 | 7 | // Output 8 | varying vec2 vUV; 9 | varying vec2 sampleCoordS; 10 | varying vec2 sampleCoordE; 11 | varying vec2 sampleCoordN; 12 | varying vec2 sampleCoordW; 13 | varying vec2 sampleCoordNW; 14 | varying vec2 sampleCoordSE; 15 | varying vec2 sampleCoordNE; 16 | varying vec2 sampleCoordSW; 17 | 18 | const vec2 madd = vec2(0.5, 0.5); 19 | 20 | void main(void) { 21 | vUV = (position * madd + madd); 22 | 23 | sampleCoordS = vUV + vec2( 0.0, 1.0) * texelSize; 24 | sampleCoordE = vUV + vec2( 1.0, 0.0) * texelSize; 25 | sampleCoordN = vUV + vec2( 0.0,-1.0) * texelSize; 26 | sampleCoordW = vUV + vec2(-1.0, 0.0) * texelSize; 27 | 28 | sampleCoordNW = vUV + vec2(-1.0,-1.0) * texelSize; 29 | sampleCoordSE = vUV + vec2( 1.0, 1.0) * texelSize; 30 | sampleCoordNE = vUV + vec2( 1.0,-1.0) * texelSize; 31 | sampleCoordSW = vUV + vec2(-1.0, 1.0) * texelSize; 32 | 33 | gl_Position = vec4(position, 0.0, 1.0); 34 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/shaders/noise/README: -------------------------------------------------------------------------------- 1 | These files contain noise functions that are compatible with all 2 | current versions of GLSL (1.20 and up), and all you need to use them 3 | is provided in the source file. There is no external data, and no 4 | setup procedure. Just cut and paste and call the function. 5 | 6 | GLSL has a very rudimentary linker, so some helper functions are 7 | included in several of the files with the same name. If you want to 8 | use more than one of these functions in the same shader, you may run 9 | into problems with redefinition of the functions mod289() and permute(). 10 | If that happens, just delete any superfluous definitions. 11 | 12 | 13 | ----- 14 | 15 | @haxiomic 16 | Added noise4Dgrad.glsl from @Markyparky56 -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/three/Layers.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | import rendering.RenderLayer; 4 | 5 | @:jsRequire("three", "Layers") extern class Layers { 6 | function new(); 7 | var mask : Int; 8 | function set(channel:RenderLayer):Void; 9 | function enable(channel:RenderLayer):Void; 10 | function enableAll():Void; 11 | function toggle(channel:RenderLayer):Void; 12 | function disable(channel:RenderLayer):Void; 13 | function disableAll():Void; 14 | function test(layers:Layers):Bool; 15 | static var prototype : Layers; 16 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/three/Uniform.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | Overrides Uniform to give it a type parameter, which was removed from @types/three at one point 5 | **/ 6 | @:jsRequire("three", "Uniform") extern class Uniform { 7 | @:overload(function(type:String, value:T): Uniform { }) 8 | function new(value:T); 9 | var type : String; 10 | var value : T; 11 | @:native("dynamic") 12 | var dynamic_ : Bool; 13 | dynamic function onUpdateCallback():Void; 14 | function onUpdate(callback:haxe.Constraints.Function):Uniform; 15 | static var prototype : Uniform; 16 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/three/WebGLRenderTargetOptions.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | import three.PixelFormat; 4 | 5 | /** 6 | Redefines WebGLRenderTargetOptions to correct type of format (PixelFormat) 7 | **/ 8 | typedef WebGLRenderTargetOptions = { 9 | @:optional 10 | var wrapS : Wrapping; 11 | @:optional 12 | var wrapT : Wrapping; 13 | @:optional 14 | var magFilter : TextureFilter; 15 | @:optional 16 | var minFilter : TextureFilter; 17 | @:optional 18 | var format : PixelFormat; 19 | @:optional 20 | var type : TextureDataType; 21 | @:optional 22 | var anisotropy : Float; 23 | @:optional 24 | var depthBuffer : Bool; 25 | @:optional 26 | var stencilBuffer : Bool; 27 | @:optional 28 | var generateMipmaps : Bool; 29 | @:optional 30 | var depthTexture : DepthTexture; 31 | @:optional 32 | var encoding : TextureEncoding; 33 | }; -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/tool/EventEmitter.hx: -------------------------------------------------------------------------------- 1 | package tool; 2 | 3 | private typedef Listener = { 4 | var callback: T -> Void; 5 | var once: Bool; 6 | } 7 | 8 | class EventEmitter { 9 | 10 | final listeners = new Map>>(); 11 | 12 | public function dispatchEvent(name: String, data: Dynamic = null) { 13 | var array = listeners.get(name); 14 | if (array != null) { 15 | var i = array.length - 1; 16 | while (i >= 0) { 17 | var listener = array[i]; 18 | var callback = listener.callback; 19 | callback(data); 20 | if (listener.once) { 21 | array.splice(i, 1); 22 | } 23 | i--; 24 | } 25 | } 26 | } 27 | 28 | public function addEventListener(name: String, callback: (data: Null) -> Void, once: Bool = false) { 29 | var array = listeners.get(name); 30 | if (array == null) { 31 | array = []; 32 | listeners.set(name, array); 33 | } 34 | array.push({ 35 | callback: callback, 36 | once: once, 37 | }); 38 | } 39 | 40 | public function removeEventListener(name: String, callback: (data: Null) -> Void) { 41 | var array = listeners.get(name); 42 | if (array != null) { 43 | var i = array.length - 1; 44 | while (i >= 0) { 45 | if (array[i].callback == callback) { 46 | array.splice(i, 1); 47 | } 48 | i--; 49 | } 50 | } 51 | if (array.length == 0) { 52 | listeners.remove(name); 53 | } 54 | } 55 | 56 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/tool/LightingDebugProbes.hx: -------------------------------------------------------------------------------- 1 | package tool; 2 | 3 | import three.Color; 4 | import three.Mesh; 5 | import three.MeshStandardMaterial; 6 | import three.Object3D; 7 | import three.SphereGeometry; 8 | 9 | #if (three >= "0.133.0") 10 | private typedef Object3D = three.Object3D; 11 | #end 12 | 13 | class LightingDebugProbes extends Object3D { 14 | 15 | public function new() { 16 | super(); 17 | var probeGeom = new SphereGeometry(1, 20, 20); 18 | var nProbes = 4; 19 | var width = 2; 20 | for ( i in 0...nProbes) { 21 | for (j in 0...nProbes) { 22 | for (k in 0...nProbes) { 23 | var u = nProbes == 1 ? 0 : i / (nProbes - 1); 24 | var v = nProbes == 1 ? 0 : j / (nProbes - 1); 25 | var w = nProbes == 1 ? 0 : k / (nProbes - 1); 26 | var probeMat = new MeshStandardMaterial({ 27 | color: new Color(Math.pow(u, 2.2), Math.pow(u, 2.2), Math.pow(u, 2.2)), 28 | metalness: w, 29 | roughness: v, 30 | fog: true, 31 | blending: NoBlending, 32 | }); 33 | var probe = new Mesh(probeGeom, probeMat); 34 | probe.layers.enable(DepthPrepass); 35 | probe.scale.setScalar(0.1); 36 | probe.position.x = u * width - width * 0.5; 37 | probe.position.y = v * width - width * 0.5; 38 | probe.position.z = w * width - width * 0.5; 39 | this.add(probe); 40 | } 41 | } 42 | } 43 | } 44 | 45 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/tool/VectorMathTools.hx: -------------------------------------------------------------------------------- 1 | package tool; 2 | 3 | import three.Vector3; 4 | 5 | inline function asMat4(m: three.Matrix4) { 6 | var e = m.elements; 7 | return new Mat4( 8 | e[0], e[1], e[2], e[3], 9 | e[4], e[5], e[6], e[7], 10 | e[8], e[9], e[10], e[11], 11 | e[12], e[13], e[14], e[15] 12 | ); 13 | } 14 | 15 | inline function asVec3(v: Vector3) { 16 | return new Vec3(v.x, v.y, v.z); 17 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/ui/dat_gui/GUIController.hx: -------------------------------------------------------------------------------- 1 | package ui.dat_gui; 2 | 3 | @:jsRequire("dat.gui", "GUIController") extern class GUIController { 4 | function new(object:Dynamic, property:String); 5 | var domElement : js.html.Element; 6 | var object : Dynamic; 7 | var property : String; 8 | function options(option:Dynamic):GUIController; 9 | function name(name:String):GUIController; 10 | function listen():GUIController; 11 | function remove():GUIController; 12 | function onChange(fnc:ts.AnyOf2<() -> Void, (value:Dynamic) -> Void>):GUIController; 13 | function onFinishChange(fnc:ts.AnyOf2<() -> Void, (value:Dynamic) -> Void>):GUIController; 14 | function setValue(value:Dynamic):GUIController; 15 | function getValue():Dynamic; 16 | function updateDisplay():GUIController; 17 | function isModified():Bool; 18 | function min(n:Float):GUIController; 19 | function max(n:Float):GUIController; 20 | function step(n:Float):GUIController; 21 | function fire():GUIController; 22 | static var prototype : GUIController; 23 | } -------------------------------------------------------------------------------- /.haxelib/three-toolkit/git/ui/dat_gui/GUIParams.hx: -------------------------------------------------------------------------------- 1 | package ui.dat_gui; 2 | 3 | typedef GUIParams = { 4 | /** 5 | Handles GUI's element placement for you. 6 | **/ 7 | @:optional 8 | var autoPlace : Bool; 9 | /** 10 | If true, starts closed. 11 | **/ 12 | @:optional 13 | var closed : Bool; 14 | /** 15 | If true, close/open button shows on top of the GUI. 16 | **/ 17 | @:optional 18 | var closeOnTop : Bool; 19 | /** 20 | If true, GUI is closed by the "h" keypress. 21 | **/ 22 | @:optional 23 | var hideable : Bool; 24 | /** 25 | JSON object representing the saved state of this GUI. 26 | **/ 27 | @:optional 28 | var load : Dynamic; 29 | /** 30 | The name of this GUI. 31 | **/ 32 | @:optional 33 | var name : String; 34 | /** 35 | The identifier for a set of saved values. 36 | **/ 37 | @:optional 38 | var preset : String; 39 | /** 40 | The width of GUI element. 41 | **/ 42 | @:optional 43 | var width : Float; 44 | }; -------------------------------------------------------------------------------- /.haxelib/three/.current: -------------------------------------------------------------------------------- 1 | 0.135.0 -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/README.md: -------------------------------------------------------------------------------- 1 | # Haxe Externs for three 2 | 3 | Generated from **[@types/three v0.135.0](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three)** by **[dts2hx](https://github.com/haxiomic/dts2hx) 0.18.1** using **TypeScript 3.7.4** with arguments: 4 | 5 | dts2hx three three/examples/jsm/loaders/RGBELoader three/examples/jsm/loaders/GLTFLoader three/examples/jsm/objects/Reflector -m 6 | 7 | ## Contributors to @types/three 8 | - [Josh Ellis](https://github.com/joshuaellis) 9 | - [Nathan Bierema](https://github.com/Methuselah96) -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "three", 3 | "tags": [ 4 | "three", 5 | "externs", 6 | "typescript", 7 | "javascript", 8 | "dts2hx" 9 | ], 10 | "description": "Externs for three v0.135.0 automatically generated by dts2hx", 11 | "contributors": [ 12 | "haxiomic" 13 | ], 14 | "dependencies": {}, 15 | "version": "0.135.0" 16 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/js/html/EventListenerObject.hx: -------------------------------------------------------------------------------- 1 | package js.html; 2 | 3 | typedef EventListenerObject = { 4 | function handleEvent(evt:js.html.Event):Void; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/js/html/EventListenerOrEventListenerObject.hx: -------------------------------------------------------------------------------- 1 | package js.html; 2 | 3 | typedef EventListenerOrEventListenerObject = ts.AnyOf2; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/js/lib/ArrayLike.hx: -------------------------------------------------------------------------------- 1 | package js.lib; 2 | 3 | typedef ArrayLike = { 4 | final length : Float; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/js/lib/IterableIterator.hx: -------------------------------------------------------------------------------- 1 | package js.lib; 2 | 3 | typedef IterableIterator = { 4 | function next(args:haxe.extern.Rest):IteratorResult; 5 | @:optional 6 | @:native("return") 7 | function return_(?value:Dynamic):IteratorResult; 8 | @:optional 9 | @:native("throw") 10 | function throw_(?e:Dynamic):IteratorResult; 11 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/js/lib/IteratorResult.hx: -------------------------------------------------------------------------------- 1 | package js.lib; 2 | 3 | typedef IteratorResult = ts.AnyOf2, IteratorReturnResult>; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/js/lib/IteratorReturnResult.hx: -------------------------------------------------------------------------------- 1 | package js.lib; 2 | 3 | typedef IteratorReturnResult = { 4 | var done : Bool; 5 | var value : TReturn; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/js/lib/IteratorYieldResult.hx: -------------------------------------------------------------------------------- 1 | package js.lib; 2 | 3 | typedef IteratorYieldResult = { 4 | @:optional 5 | var done : Bool; 6 | var value : TYield; 7 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AnimationActionLoopStyles.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract AnimationActionLoopStyles(Int) from Int to Int { 4 | final LoopOnce : AnimationActionLoopStyles; 5 | final LoopRepeat : AnimationActionLoopStyles; 6 | final LoopPingPong : AnimationActionLoopStyles; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AnimationBlendMode.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract AnimationBlendMode(Int) from Int to Int { 4 | final NormalAnimationBlendMode : AnimationBlendMode; 5 | final AdditiveAnimationBlendMode : AnimationBlendMode; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AnimationClip.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "AnimationClip") extern class AnimationClip { 4 | function new(?name:String, ?duration:Float, ?tracks:Array, ?blendMode:AnimationBlendMode); 5 | var name : String; 6 | var tracks : Array; 7 | var blendMode : AnimationBlendMode; 8 | var duration : Float; 9 | var uuid : String; 10 | var results : Array; 11 | function resetDuration():AnimationClip; 12 | function trim():AnimationClip; 13 | function validate():Bool; 14 | function optimize():AnimationClip; 15 | function clone():AnimationClip; 16 | function toJSON(clip:AnimationClip):Dynamic; 17 | static var prototype : AnimationClip; 18 | static function CreateFromMorphTargetSequence(name:String, morphTargetSequence:Array, fps:Float, noLoop:Bool):AnimationClip; 19 | static function findByName(clipArray:Array, name:String):AnimationClip; 20 | static function CreateClipsFromMorphTargetSequences(morphTargets:Array, fps:Float, noLoop:Bool):Array; 21 | static function parse(json:Dynamic):AnimationClip; 22 | static function parseAnimation(animation:Dynamic, bones:Array):AnimationClip; 23 | @:native("toJSON") 24 | static function toJSON_(clip:AnimationClip):Dynamic; 25 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AnimationLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "AnimationLoader") extern class AnimationLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | function load(url:String, onLoad:(response:Array) -> Void, ?onProgress:(request:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):Void; 6 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise>; 7 | function parse(json:Dynamic):Array; 8 | function setCrossOrigin(crossOrigin:String):AnimationLoader; 9 | function setWithCredentials(value:Bool):AnimationLoader; 10 | function setPath(path:String):AnimationLoader; 11 | function setResourcePath(resourcePath:String):AnimationLoader; 12 | function setRequestHeader(requestHeader:{ }):AnimationLoader; 13 | static var prototype : AnimationLoader; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AnimationObjectGroup.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "AnimationObjectGroup") extern class AnimationObjectGroup { 4 | function new(args:haxe.extern.Rest); 5 | var uuid : String; 6 | var stats : { 7 | var bindingsPerObject : Float; 8 | var objects : { 9 | var total : Float; 10 | var inUse : Float; 11 | }; 12 | }; 13 | final isAnimationObjectGroup : Bool; 14 | function add(args:haxe.extern.Rest):Void; 15 | function remove(args:haxe.extern.Rest):Void; 16 | function uncache(args:haxe.extern.Rest):Void; 17 | static var prototype : AnimationObjectGroup; 18 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AnimationUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "AnimationUtils") @valueModuleOnly extern class AnimationUtils { 4 | static function arraySlice(array:Dynamic, from:Float, to:Float):Dynamic; 5 | static function convertArray(array:Dynamic, type:Dynamic, forceClone:Bool):Dynamic; 6 | static function isTypedArray(object:Dynamic):Bool; 7 | static function getKeyFrameOrder(times:Array):Array; 8 | static function sortedArray(values:Array, stride:Float, order:Array):Array; 9 | static function flattenJSON(jsonKeys:Array, times:Array, values:Array, valuePropertyName:String):Void; 10 | static function subclip(sourceClip:AnimationClip, name:String, startFrame:Float, endFrame:Float, ?fps:Float):AnimationClip; 11 | static function makeClipAdditive(targetClip:AnimationClip, ?referenceFrame:Float, ?referenceClip:AnimationClip, ?fps:Float):AnimationClip; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ArcCurve.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ArcCurve") extern class ArcCurve extends EllipseCurve { 4 | function new(aX:Float, aY:Float, aRadius:Float, aStartAngle:Float, aEndAngle:Float, aClockwise:Bool); 5 | function clone():ArcCurve; 6 | function copy(source:Curve):ArcCurve; 7 | function fromJSON(json:Dynamic):ArcCurve; 8 | static var prototype : ArcCurve; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AudioAnalyser.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "AudioAnalyser") extern class AudioAnalyser { 4 | function new(audio:Audio, ?fftSize:Float); 5 | var analyser : js.html.audio.AnalyserNode; 6 | var data : js.lib.Uint8Array; 7 | function getFrequencyData():js.lib.Uint8Array; 8 | function getAverageFrequency():Float; 9 | function getData(file:Dynamic):Dynamic; 10 | static var prototype : AudioAnalyser; 11 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AudioContext.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | see {@link https://github.com/mrdoob/three.js/blob/master/src/audio/AudioContext.js|src/audio/AudioContext.js} 5 | **/ 6 | @:jsRequire("three", "AudioContext") @valueModuleOnly extern class AudioContext { 7 | static function getContext():js.html.audio.AudioContext; 8 | static function setContext():Void; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/AudioLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "AudioLoader") extern class AudioLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | function load(url:String, onLoad:(audioBuffer:js.html.audio.AudioBuffer) -> Void, ?onProgress:(request:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):Void; 6 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 7 | function setCrossOrigin(crossOrigin:String):AudioLoader; 8 | function setWithCredentials(value:Bool):AudioLoader; 9 | function setPath(path:String):AudioLoader; 10 | function setResourcePath(resourcePath:String):AudioLoader; 11 | function setRequestHeader(requestHeader:{ }):AudioLoader; 12 | static var prototype : AudioLoader; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BaseEvent.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef BaseEvent = { 4 | var type : String; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Blending.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract Blending(Int) from Int to Int { 4 | final NoBlending : Blending; 5 | final NormalBlending : Blending; 6 | final AdditiveBlending : Blending; 7 | final SubtractiveBlending : Blending; 8 | final MultiplyBlending : Blending; 9 | final CustomBlending : Blending; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BlendingDstFactor.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract BlendingDstFactor(Int) from Int to Int { 4 | final ZeroFactor : BlendingDstFactor; 5 | final OneFactor : BlendingDstFactor; 6 | final SrcColorFactor : BlendingDstFactor; 7 | final OneMinusSrcColorFactor : BlendingDstFactor; 8 | final SrcAlphaFactor : BlendingDstFactor; 9 | final OneMinusSrcAlphaFactor : BlendingDstFactor; 10 | final DstAlphaFactor : BlendingDstFactor; 11 | final OneMinusDstAlphaFactor : BlendingDstFactor; 12 | final DstColorFactor : BlendingDstFactor; 13 | final OneMinusDstColorFactor : BlendingDstFactor; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BlendingEquation.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract BlendingEquation(Int) from Int to Int { 4 | final AddEquation : BlendingEquation; 5 | final SubtractEquation : BlendingEquation; 6 | final ReverseSubtractEquation : BlendingEquation; 7 | final MinEquation : BlendingEquation; 8 | final MaxEquation : BlendingEquation; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BlendingSrcFactor.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract BlendingSrcFactor(Int) from Int to Int { 4 | final SrcAlphaSaturateFactor : BlendingSrcFactor; 5 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BooleanKeyframeTrack.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "BooleanKeyframeTrack") extern class BooleanKeyframeTrack extends KeyframeTrack { 4 | function new(name:String, times:Array, values:Array); 5 | function clone():BooleanKeyframeTrack; 6 | static var prototype : BooleanKeyframeTrack; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Box2.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Box2") extern class Box2 { 4 | function new(?min:Vector2, ?max:Vector2); 5 | var min : Vector2; 6 | var max : Vector2; 7 | function set(min:Vector2, max:Vector2):Box2; 8 | function setFromPoints(points:Array):Box2; 9 | function setFromCenterAndSize(center:Vector2, size:Vector2):Box2; 10 | function clone():Box2; 11 | function copy(box:Box2):Box2; 12 | function makeEmpty():Box2; 13 | function isEmpty():Bool; 14 | function getCenter(target:Vector2):Vector2; 15 | function getSize(target:Vector2):Vector2; 16 | function expandByPoint(point:Vector2):Box2; 17 | function expandByVector(vector:Vector2):Box2; 18 | function expandByScalar(scalar:Float):Box2; 19 | function containsPoint(point:Vector2):Bool; 20 | function containsBox(box:Box2):Bool; 21 | function getParameter(point:Vector2, target:Vector2):Vector2; 22 | function intersectsBox(box:Box2):Bool; 23 | function clampPoint(point:Vector2, target:Vector2):Vector2; 24 | function distanceToPoint(point:Vector2):Float; 25 | function intersect(box:Box2):Box2; 26 | function union(box:Box2):Box2; 27 | function translate(offset:Vector2):Box2; 28 | function equals(box:Box2):Bool; 29 | function empty():Dynamic; 30 | function isIntersectionBox(b:Dynamic):Dynamic; 31 | static var prototype : Box2; 32 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BoxGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "BoxGeometry") extern class BoxGeometry extends BufferGeometry { 4 | function new(?width:Float, ?height:Float, ?depth:Float, ?widthSegments:Float, ?heightSegments:Float, ?depthSegments:Float); 5 | var parameters : { 6 | var width : Float; 7 | var height : Float; 8 | var depth : Float; 9 | var widthSegments : Float; 10 | var heightSegments : Float; 11 | var depthSegments : Float; 12 | }; 13 | function copy(source:BufferGeometry):BoxGeometry; 14 | /** 15 | Adds a listener to an event type. 16 | **/ 17 | function addEventListener(type:T, listener:EventListener):Void; 18 | /** 19 | Checks if listener is added to an event type. 20 | **/ 21 | function hasEventListener(type:T, listener:EventListener):Bool; 22 | /** 23 | Removes a listener from an event type. 24 | **/ 25 | function removeEventListener(type:T, listener:EventListener):Void; 26 | static var prototype : BoxGeometry; 27 | static function fromJSON(data:Dynamic):BoxGeometry; 28 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BufferGeometryLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "BufferGeometryLoader") extern class BufferGeometryLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | function load(url:String, onLoad:(bufferGeometry:ts.AnyOf2) -> Void, ?onProgress:(request:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):Void; 6 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise>; 7 | function parse(json:Dynamic):ts.AnyOf2; 8 | function setCrossOrigin(crossOrigin:String):BufferGeometryLoader; 9 | function setWithCredentials(value:Bool):BufferGeometryLoader; 10 | function setPath(path:String):BufferGeometryLoader; 11 | function setResourcePath(resourcePath:String):BufferGeometryLoader; 12 | function setRequestHeader(requestHeader:{ }):BufferGeometryLoader; 13 | static var prototype : BufferGeometryLoader; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BufferGeometryUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | see {@link https://github.com/mrdoob/three.js/blob/master/examples/jsm/utils/BufferGeometryUtils.js|examples/jsm/utils/BufferGeometryUtils.js} 5 | **/ 6 | @:jsRequire("three", "BufferGeometryUtils") @valueModuleOnly extern class BufferGeometryUtils { 7 | static function mergeBufferGeometries(geometries:Array):BufferGeometry; 8 | static function computeTangents(geometry:BufferGeometry):Dynamic; 9 | static function mergeBufferAttributes(attributes:Array):BufferAttribute; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/BuiltinShaderAttributeName.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef BuiltinShaderAttributeName = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Cache.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Cache") @valueModuleOnly extern class Cache { 4 | static function add(key:String, file:Dynamic):Void; 5 | static function get(key:String):Dynamic; 6 | static function remove(key:String):Void; 7 | static function clear():Void; 8 | static var enabled : Bool; 9 | static var files : Dynamic; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CanvasTexture.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CanvasTexture") extern class CanvasTexture extends Texture { 4 | function new(canvas:ts.AnyOf4, ?mapping:Mapping, ?wrapS:Wrapping, ?wrapT:Wrapping, ?magFilter:TextureFilter, ?minFilter:TextureFilter, ?format:PixelFormat, ?type:TextureDataType, ?anisotropy:Float); 5 | final isCanvasTexture : Bool; 6 | function clone():CanvasTexture; 7 | function copy(source:Texture):CanvasTexture; 8 | /** 9 | Adds a listener to an event type. 10 | **/ 11 | function addEventListener(type:T, listener:EventListener):Void; 12 | /** 13 | Checks if listener is added to an event type. 14 | **/ 15 | function hasEventListener(type:T, listener:EventListener):Bool; 16 | /** 17 | Removes a listener from an event type. 18 | **/ 19 | function removeEventListener(type:T, listener:EventListener):Void; 20 | static var prototype : CanvasTexture; 21 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CatmullRomCurve3.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CatmullRomCurve3") extern class CatmullRomCurve3 extends Curve { 4 | function new(?points:Array, ?closed:Bool, ?curveType:String, ?tension:Float); 5 | var points : Array; 6 | function clone():CatmullRomCurve3; 7 | function copy(source:Curve):CatmullRomCurve3; 8 | function fromJSON(json:Dynamic):CatmullRomCurve3; 9 | static var prototype : CatmullRomCurve3; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CircleGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CircleGeometry") extern class CircleGeometry extends BufferGeometry { 4 | function new(?radius:Float, ?segments:Float, ?thetaStart:Float, ?thetaLength:Float); 5 | var parameters : { 6 | var radius : Float; 7 | var segments : Float; 8 | var thetaStart : Float; 9 | var thetaLength : Float; 10 | }; 11 | function copy(source:BufferGeometry):CircleGeometry; 12 | /** 13 | Adds a listener to an event type. 14 | **/ 15 | function addEventListener(type:T, listener:EventListener):Void; 16 | /** 17 | Checks if listener is added to an event type. 18 | **/ 19 | function hasEventListener(type:T, listener:EventListener):Bool; 20 | /** 21 | Removes a listener from an event type. 22 | **/ 23 | function removeEventListener(type:T, listener:EventListener):Void; 24 | static var prototype : CircleGeometry; 25 | static function fromJSON(data:Dynamic):CircleGeometry; 26 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ColorKeyframeTrack.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ColorKeyframeTrack") extern class ColorKeyframeTrack extends KeyframeTrack { 4 | function new(name:String, times:Array, values:Array, ?interpolation:InterpolationModes); 5 | function clone():ColorKeyframeTrack; 6 | static var prototype : ColorKeyframeTrack; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ColorRepresentation.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef ColorRepresentation = ts.AnyOf3; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Combine.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract Combine(Int) from Int to Int { 4 | final MultiplyOperation : Combine; 5 | final MixOperation : Combine; 6 | final AddOperation : Combine; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CompressedTexture.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CompressedTexture") extern class CompressedTexture extends Texture { 4 | function new(mipmaps:Array, width:Float, height:Float, ?format:CompressedPixelFormat, ?type:TextureDataType, ?mapping:Mapping, ?wrapS:Wrapping, ?wrapT:Wrapping, ?magFilter:TextureFilter, ?minFilter:TextureFilter, ?anisotropy:Float, ?encoding:TextureEncoding); 5 | final isCompressedTexture : Bool; 6 | function clone():CompressedTexture; 7 | function copy(source:Texture):CompressedTexture; 8 | /** 9 | Adds a listener to an event type. 10 | **/ 11 | function addEventListener(type:T, listener:EventListener):Void; 12 | /** 13 | Checks if listener is added to an event type. 14 | **/ 15 | function hasEventListener(type:T, listener:EventListener):Bool; 16 | /** 17 | Removes a listener from an event type. 18 | **/ 19 | function removeEventListener(type:T, listener:EventListener):Void; 20 | static var prototype : CompressedTexture; 21 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CompressedTextureLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CompressedTextureLoader") extern class CompressedTextureLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | function load(url:String, onLoad:(texture:CompressedTexture) -> Void, ?onProgress:(event:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):CompressedTexture; 6 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 7 | function setCrossOrigin(crossOrigin:String):CompressedTextureLoader; 8 | function setWithCredentials(value:Bool):CompressedTextureLoader; 9 | function setPath(path:String):CompressedTextureLoader; 10 | function setResourcePath(resourcePath:String):CompressedTextureLoader; 11 | function setRequestHeader(requestHeader:{ }):CompressedTextureLoader; 12 | static var prototype : CompressedTextureLoader; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ConeGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ConeGeometry") extern class ConeGeometry extends CylinderGeometry { 4 | function new(?radius:Float, ?height:Float, ?radialSegments:Float, ?heightSegments:Float, ?openEnded:Bool, ?thetaStart:Float, ?thetaLength:Float); 5 | function copy(source:BufferGeometry):ConeGeometry; 6 | /** 7 | Adds a listener to an event type. 8 | **/ 9 | function addEventListener(type:T, listener:EventListener):Void; 10 | /** 11 | Checks if listener is added to an event type. 12 | **/ 13 | function hasEventListener(type:T, listener:EventListener):Bool; 14 | /** 15 | Removes a listener from an event type. 16 | **/ 17 | function removeEventListener(type:T, listener:EventListener):Void; 18 | static var prototype : ConeGeometry; 19 | static function fromJSON(data:Dynamic):ConeGeometry; 20 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Constructor.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Constructor = { 4 | var prototype : T; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CubeTexture.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CubeTexture") extern class CubeTexture extends Texture { 4 | function new(?images:Array, ?mapping:Mapping, ?wrapS:Wrapping, ?wrapT:Wrapping, ?magFilter:TextureFilter, ?minFilter:TextureFilter, ?format:PixelFormat, ?type:TextureDataType, ?anisotropy:Float, ?encoding:TextureEncoding); 5 | var images : Dynamic; 6 | final isCubeTexture : Bool; 7 | function clone():CubeTexture; 8 | function copy(source:Texture):CubeTexture; 9 | /** 10 | Adds a listener to an event type. 11 | **/ 12 | function addEventListener(type:T, listener:EventListener):Void; 13 | /** 14 | Checks if listener is added to an event type. 15 | **/ 16 | function hasEventListener(type:T, listener:EventListener):Bool; 17 | /** 18 | Removes a listener from an event type. 19 | **/ 20 | function removeEventListener(type:T, listener:EventListener):Void; 21 | static var prototype : CubeTexture; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CubeTextureLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CubeTextureLoader") extern class CubeTextureLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | function load(urls:Array, ?onLoad:(texture:CubeTexture) -> Void, ?onProgress:(event:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):CubeTexture; 6 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 7 | function setCrossOrigin(crossOrigin:String):CubeTextureLoader; 8 | function setWithCredentials(value:Bool):CubeTextureLoader; 9 | function setPath(path:String):CubeTextureLoader; 10 | function setResourcePath(resourcePath:String):CubeTextureLoader; 11 | function setRequestHeader(requestHeader:{ }):CubeTextureLoader; 12 | static var prototype : CubeTextureLoader; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CubicBezierCurve.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CubicBezierCurve") extern class CubicBezierCurve extends Curve { 4 | function new(v0:Vector2, v1:Vector2, v2:Vector2, v3:Vector2); 5 | var v0 : Vector2; 6 | var v1 : Vector2; 7 | var v2 : Vector2; 8 | var v3 : Vector2; 9 | function clone():CubicBezierCurve; 10 | function copy(source:Curve):CubicBezierCurve; 11 | function fromJSON(json:Dynamic):CubicBezierCurve; 12 | static var prototype : CubicBezierCurve; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CubicBezierCurve3.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CubicBezierCurve3") extern class CubicBezierCurve3 extends Curve { 4 | function new(v0:Vector3, v1:Vector3, v2:Vector3, v3:Vector3); 5 | var v0 : Vector3; 6 | var v1 : Vector3; 7 | var v2 : Vector3; 8 | var v3 : Vector3; 9 | function clone():CubicBezierCurve3; 10 | function copy(source:Curve):CubicBezierCurve3; 11 | function fromJSON(json:Dynamic):CubicBezierCurve3; 12 | static var prototype : CubicBezierCurve3; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CubicInterpolant.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CubicInterpolant") extern class CubicInterpolant extends Interpolant { 4 | function new(parameterPositions:Dynamic, samplesValues:Dynamic, sampleSize:Float, ?resultBuffer:Dynamic); 5 | function interpolate_(i1:Float, t0:Float, t:Float, t1:Float):Dynamic; 6 | static var prototype : CubicInterpolant; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CullFace.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract CullFace(Int) from Int to Int { 4 | final CullFaceNone : CullFace; 5 | final CullFaceBack : CullFace; 6 | final CullFaceFront : CullFace; 7 | final CullFaceFrontBack : CullFace; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CurvePath.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CurvePath") extern class CurvePath extends Curve { 4 | function new(); 5 | var curves : Array>; 6 | var autoClose : Bool; 7 | function add(curve:Curve):Void; 8 | function closePath():Void; 9 | function getCurveLengths():Array; 10 | function clone():CurvePath; 11 | function copy(source:Curve):CurvePath; 12 | function fromJSON(json:Dynamic):CurvePath; 13 | static var prototype : CurvePath; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CurveUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CurveUtils") @valueModuleOnly extern class CurveUtils { 4 | static function tangentQuadraticBezier(t:Float, p0:Float, p1:Float, p2:Float):Float; 5 | static function tangentCubicBezier(t:Float, p0:Float, p1:Float, p2:Float, p3:Float):Float; 6 | static function tangentSpline(t:Float, p0:Float, p1:Float, p2:Float, p3:Float):Float; 7 | static function interpolate(p0:Float, p1:Float, p2:Float, p3:Float, t:Float):Float; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/CylinderGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "CylinderGeometry") extern class CylinderGeometry extends BufferGeometry { 4 | function new(?radiusTop:Float, ?radiusBottom:Float, ?height:Float, ?radialSegments:Float, ?heightSegments:Float, ?openEnded:Bool, ?thetaStart:Float, ?thetaLength:Float); 5 | var parameters : { 6 | var radiusTop : Float; 7 | var radiusBottom : Float; 8 | var height : Float; 9 | var radialSegments : Float; 10 | var heightSegments : Float; 11 | var openEnded : Bool; 12 | var thetaStart : Float; 13 | var thetaLength : Float; 14 | }; 15 | function copy(source:BufferGeometry):CylinderGeometry; 16 | /** 17 | Adds a listener to an event type. 18 | **/ 19 | function addEventListener(type:T, listener:EventListener):Void; 20 | /** 21 | Checks if listener is added to an event type. 22 | **/ 23 | function hasEventListener(type:T, listener:EventListener):Bool; 24 | /** 25 | Removes a listener from an event type. 26 | **/ 27 | function removeEventListener(type:T, listener:EventListener):Void; 28 | static var prototype : CylinderGeometry; 29 | static function fromJSON(data:Dynamic):CylinderGeometry; 30 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Cylindrical.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Cylindrical") extern class Cylindrical { 4 | function new(?radius:Float, ?theta:Float, ?y:Float); 5 | var radius : Float; 6 | var theta : Float; 7 | var y : Float; 8 | function clone():Cylindrical; 9 | function copy(other:Cylindrical):Cylindrical; 10 | function set(radius:Float, theta:Float, y:Float):Cylindrical; 11 | function setFromVector3(vec3:Vector3):Cylindrical; 12 | function setFromCartesianCoords(x:Float, y:Float, z:Float):Cylindrical; 13 | static var prototype : Cylindrical; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DOMPointInit.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef DOMPointInit = { 4 | @:optional 5 | var w : Float; 6 | @:optional 7 | var x : Float; 8 | @:optional 9 | var y : Float; 10 | @:optional 11 | var z : Float; 12 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DataTexture.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DataTexture") extern class DataTexture extends Texture { 4 | function new(?data:js.lib.BufferSource, ?width:Float, ?height:Float, ?format:PixelFormat, ?type:TextureDataType, ?mapping:Mapping, ?wrapS:Wrapping, ?wrapT:Wrapping, ?magFilter:TextureFilter, ?minFilter:TextureFilter, ?anisotropy:Float, ?encoding:TextureEncoding); 5 | final isDataTexture : Bool; 6 | function clone():DataTexture; 7 | function copy(source:Texture):DataTexture; 8 | /** 9 | Adds a listener to an event type. 10 | **/ 11 | function addEventListener(type:T, listener:EventListener):Void; 12 | /** 13 | Checks if listener is added to an event type. 14 | **/ 15 | function hasEventListener(type:T, listener:EventListener):Bool; 16 | /** 17 | Removes a listener from an event type. 18 | **/ 19 | function removeEventListener(type:T, listener:EventListener):Void; 20 | static var prototype : DataTexture; 21 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DataTexture2DArray.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DataTexture2DArray") extern class DataTexture2DArray extends Texture { 4 | function new(?data:js.lib.BufferSource, ?width:Float, ?height:Float, ?depth:Float); 5 | var wrapR : Bool; 6 | final isDataTexture2DArray : Bool; 7 | function clone():DataTexture2DArray; 8 | function copy(source:Texture):DataTexture2DArray; 9 | /** 10 | Adds a listener to an event type. 11 | **/ 12 | function addEventListener(type:T, listener:EventListener):Void; 13 | /** 14 | Checks if listener is added to an event type. 15 | **/ 16 | function hasEventListener(type:T, listener:EventListener):Bool; 17 | /** 18 | Removes a listener from an event type. 19 | **/ 20 | function removeEventListener(type:T, listener:EventListener):Void; 21 | static var prototype : DataTexture2DArray; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DataTexture3D.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DataTexture3D") extern class DataTexture3D extends Texture { 4 | function new(data:js.lib.BufferSource, width:Float, height:Float, depth:Float); 5 | var wrapR : Bool; 6 | final isDataTexture3D : Bool; 7 | function clone():DataTexture3D; 8 | function copy(source:Texture):DataTexture3D; 9 | /** 10 | Adds a listener to an event type. 11 | **/ 12 | function addEventListener(type:T, listener:EventListener):Void; 13 | /** 14 | Checks if listener is added to an event type. 15 | **/ 16 | function hasEventListener(type:T, listener:EventListener):Bool; 17 | /** 18 | Removes a listener from an event type. 19 | **/ 20 | function removeEventListener(type:T, listener:EventListener):Void; 21 | static var prototype : DataTexture3D; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DataTextureLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DataTextureLoader") extern class DataTextureLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | function load(url:String, onLoad:(dataTexture:DataTexture, texData:Dynamic) -> Void, ?onProgress:(event:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):DataTexture; 6 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 7 | function setCrossOrigin(crossOrigin:String):DataTextureLoader; 8 | function setWithCredentials(value:Bool):DataTextureLoader; 9 | function setPath(path:String):DataTextureLoader; 10 | function setResourcePath(resourcePath:String):DataTextureLoader; 11 | function setRequestHeader(requestHeader:{ }):DataTextureLoader; 12 | static var prototype : DataTextureLoader; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DataUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DataUtils") @valueModuleOnly extern class DataUtils { 4 | static function toHalfFloat(val:Float):Float; 5 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DepthModes.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract DepthModes(Int) from Int to Int { 4 | final NeverDepth : DepthModes; 5 | final AlwaysDepth : DepthModes; 6 | final LessDepth : DepthModes; 7 | final LessEqualDepth : DepthModes; 8 | final EqualDepth : DepthModes; 9 | final GreaterEqualDepth : DepthModes; 10 | final GreaterDepth : DepthModes; 11 | final NotEqualDepth : DepthModes; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DepthPackingStrategies.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract DepthPackingStrategies(Int) from Int to Int { 4 | final BasicDepthPacking : DepthPackingStrategies; 5 | final RGBADepthPacking : DepthPackingStrategies; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DepthTexture.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DepthTexture") extern class DepthTexture extends Texture { 4 | function new(width:Float, height:Float, ?type:TextureDataType, ?mapping:Mapping, ?wrapS:Wrapping, ?wrapT:Wrapping, ?magFilter:TextureFilter, ?minFilter:TextureFilter, ?anisotropy:Float); 5 | final isDepthTexture : Bool; 6 | function clone():DepthTexture; 7 | function copy(source:Texture):DepthTexture; 8 | /** 9 | Adds a listener to an event type. 10 | **/ 11 | function addEventListener(type:T, listener:EventListener):Void; 12 | /** 13 | Checks if listener is added to an event type. 14 | **/ 15 | function hasEventListener(type:T, listener:EventListener):Bool; 16 | /** 17 | Removes a listener from an event type. 18 | **/ 19 | function removeEventListener(type:T, listener:EventListener):Void; 20 | static var prototype : DepthTexture; 21 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DirectionalLightShadow.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DirectionalLightShadow") extern class DirectionalLightShadow extends LightShadow { 4 | function new(); 5 | final isDirectionalLightShadow : Bool; 6 | function copy(source:LightShadow):DirectionalLightShadow; 7 | function clone(?recursive:Bool):DirectionalLightShadow; 8 | static var prototype : DirectionalLightShadow; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DiscreteInterpolant.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DiscreteInterpolant") extern class DiscreteInterpolant extends Interpolant { 4 | function new(parameterPositions:Dynamic, samplesValues:Dynamic, sampleSize:Float, ?resultBuffer:Dynamic); 5 | function interpolate_(i1:Float, t0:Float, t:Float, t1:Float):Dynamic; 6 | static var prototype : DiscreteInterpolant; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/DodecahedronGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "DodecahedronGeometry") extern class DodecahedronGeometry extends PolyhedronGeometry { 4 | function new(?radius:Float, ?detail:Float); 5 | function copy(source:BufferGeometry):DodecahedronGeometry; 6 | /** 7 | Adds a listener to an event type. 8 | **/ 9 | function addEventListener(type:T, listener:EventListener):Void; 10 | /** 11 | Checks if listener is added to an event type. 12 | **/ 13 | function hasEventListener(type:T, listener:EventListener):Bool; 14 | /** 15 | Removes a listener from an event type. 16 | **/ 17 | function removeEventListener(type:T, listener:EventListener):Void; 18 | static var prototype : DodecahedronGeometry; 19 | static function fromJSON(data:Dynamic):DodecahedronGeometry; 20 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/EdgesGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "EdgesGeometry") extern class EdgesGeometry extends BufferGeometry { 4 | function new(?geometry:TBufferGeometry, ?thresholdAngle:Float); 5 | var parameters : { 6 | var geometry : TBufferGeometry; 7 | var thresholdAngle : Float; 8 | }; 9 | function copy(source:BufferGeometry):EdgesGeometry; 10 | /** 11 | Adds a listener to an event type. 12 | **/ 13 | function addEventListener(type:T, listener:EventListener>):Void; 14 | /** 15 | Checks if listener is added to an event type. 16 | **/ 17 | function hasEventListener(type:T, listener:EventListener>):Bool; 18 | /** 19 | Removes a listener from an event type. 20 | **/ 21 | function removeEventListener(type:T, listener:EventListener>):Void; 22 | static var prototype : EdgesGeometry; 23 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/EllipseCurve.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "EllipseCurve") extern class EllipseCurve extends Curve { 4 | function new(aX:Float, aY:Float, xRadius:Float, yRadius:Float, aStartAngle:Float, aEndAngle:Float, aClockwise:Bool, aRotation:Float); 5 | var aX : Float; 6 | var aY : Float; 7 | var xRadius : Float; 8 | var yRadius : Float; 9 | var aStartAngle : Float; 10 | var aEndAngle : Float; 11 | var aClockwise : Bool; 12 | var aRotation : Float; 13 | function clone():EllipseCurve; 14 | function copy(source:Curve):EllipseCurve; 15 | function fromJSON(json:Dynamic):EllipseCurve; 16 | static var prototype : EllipseCurve; 17 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Euler.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Euler") extern class Euler { 4 | function new(?x:Float, ?y:Float, ?z:Float, ?order:String); 5 | var x : Float; 6 | var y : Float; 7 | var z : Float; 8 | var order : String; 9 | final isEuler : Bool; 10 | dynamic function _onChangeCallback():Void; 11 | function set(x:Float, y:Float, z:Float, ?order:String):Euler; 12 | function clone():Euler; 13 | function copy(euler:Euler):Euler; 14 | function setFromRotationMatrix(m:Matrix4, ?order:String, ?update:Bool):Euler; 15 | function setFromQuaternion(q:Quaternion, ?order:String, ?update:Bool):Euler; 16 | function setFromVector3(v:Vector3, ?order:String):Euler; 17 | function reorder(newOrder:String):Euler; 18 | function equals(euler:Euler):Bool; 19 | function fromArray(xyzo:Array):Euler; 20 | function toArray(?array:Array, ?offset:Float):Array; 21 | function toVector3(?optionalResult:Vector3):Vector3; 22 | function _onChange(callback:() -> Void):Euler; 23 | static var prototype : Euler; 24 | static var RotationOrders : Array; 25 | static var DefaultOrder : String; 26 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Event.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | Event object. 5 | **/ 6 | typedef Event = { 7 | @:optional 8 | var target : Dynamic; 9 | var type : String; 10 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/EventDispatcher.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | JavaScript events for custom objects 5 | **/ 6 | @:jsRequire("three", "EventDispatcher") extern class EventDispatcher { 7 | /** 8 | Creates eventDispatcher object. It needs to be call with '.call' to add the functionality to an object. 9 | **/ 10 | function new(); 11 | /** 12 | Adds a listener to an event type. 13 | **/ 14 | function addEventListener(type:T, listener:EventListener>):Void; 15 | /** 16 | Checks if listener is added to an event type. 17 | **/ 18 | function hasEventListener(type:T, listener:EventListener>):Bool; 19 | /** 20 | Removes a listener from an event type. 21 | **/ 22 | function removeEventListener(type:T, listener:EventListener>):Void; 23 | /** 24 | Fire an event type. 25 | **/ 26 | function dispatchEvent(event:E):Void; 27 | static var prototype : EventDispatcher; 28 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/EventListener.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef EventListener = (event:Dynamic) -> Void; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ExtrudeGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ExtrudeGeometry") extern class ExtrudeGeometry extends BufferGeometry { 4 | function new(?shapes:ts.AnyOf2>, ?options:ExtrudeGeometryOptions); 5 | function addShapeList(shapes:Array, ?options:Dynamic):Void; 6 | function addShape(shape:Shape, ?options:Dynamic):Void; 7 | function copy(source:BufferGeometry):ExtrudeGeometry; 8 | /** 9 | Adds a listener to an event type. 10 | **/ 11 | function addEventListener(type:T, listener:EventListener):Void; 12 | /** 13 | Checks if listener is added to an event type. 14 | **/ 15 | function hasEventListener(type:T, listener:EventListener):Bool; 16 | /** 17 | Removes a listener from an event type. 18 | **/ 19 | function removeEventListener(type:T, listener:EventListener):Void; 20 | static var prototype : ExtrudeGeometry; 21 | static function fromJSON(data:Dynamic):ExtrudeGeometry; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ExtrudeGeometryOptions.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef ExtrudeGeometryOptions = { 4 | @:optional 5 | var curveSegments : Float; 6 | @:optional 7 | var steps : Float; 8 | @:optional 9 | var depth : Float; 10 | @:optional 11 | var bevelEnabled : Bool; 12 | @:optional 13 | var bevelThickness : Float; 14 | @:optional 15 | var bevelSize : Float; 16 | @:optional 17 | var bevelOffset : Float; 18 | @:optional 19 | var bevelSegments : Float; 20 | @:optional 21 | var extrudePath : Curve; 22 | @:optional 23 | var UVGenerator : UVGenerator; 24 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Face.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Face = { 4 | var a : Float; 5 | var b : Float; 6 | var c : Float; 7 | var normal : Vector3; 8 | var materialIndex : Float; 9 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/FileLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "FileLoader") extern class FileLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | var mimeType : Null; 6 | var responseType : Null; 7 | function load(url:String, ?onLoad:(response:ts.AnyOf2) -> Void, ?onProgress:(request:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):Dynamic; 8 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise>; 9 | function setMimeType(mimeType:js.html.MimeType):FileLoader; 10 | function setResponseType(responseType:String):FileLoader; 11 | function setCrossOrigin(crossOrigin:String):FileLoader; 12 | function setWithCredentials(value:Bool):FileLoader; 13 | function setPath(path:String):FileLoader; 14 | function setResourcePath(resourcePath:String):FileLoader; 15 | function setRequestHeader(requestHeader:{ }):FileLoader; 16 | static var prototype : FileLoader; 17 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Fog.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | This class contains the parameters that define linear fog, i.e., that grows linearly denser with the distance. 5 | **/ 6 | @:jsRequire("three", "Fog") extern class Fog { 7 | function new(color:ColorRepresentation, ?near:Float, ?far:Float); 8 | var name : String; 9 | /** 10 | Fog color. 11 | **/ 12 | var color : Color; 13 | /** 14 | The minimum distance to start applying fog. Objects that are less than 'near' units from the active camera won't be affected by fog. 15 | **/ 16 | var near : Float; 17 | /** 18 | The maximum distance at which fog stops being calculated and applied. Objects that are more than 'far' units away from the active camera won't be affected by fog. 19 | **/ 20 | var far : Float; 21 | final isFog : Bool; 22 | function clone():Fog; 23 | function toJSON():Dynamic; 24 | static var prototype : Fog; 25 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/FogBase.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef FogBase = { 4 | var name : String; 5 | var color : Color; 6 | function clone():FogBase; 7 | function toJSON():Dynamic; 8 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/FogExp2.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | This class contains the parameters that define linear fog, i.e., that grows exponentially denser with the distance. 5 | **/ 6 | @:jsRequire("three", "FogExp2") extern class FogExp2 { 7 | function new(hex:ts.AnyOf2, ?density:Float); 8 | var name : String; 9 | var color : Color; 10 | /** 11 | Defines how fast the fog will grow dense. 12 | **/ 13 | var density : Float; 14 | final isFogExp2 : Bool; 15 | function clone():FogExp2; 16 | function toJSON():Dynamic; 17 | static var prototype : FogExp2; 18 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Frustum.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | Frustums are used to determine what is inside the camera's field of view. They help speed up the rendering process. 5 | **/ 6 | @:jsRequire("three", "Frustum") extern class Frustum { 7 | function new(?p0:Plane, ?p1:Plane, ?p2:Plane, ?p3:Plane, ?p4:Plane, ?p5:Plane); 8 | /** 9 | Array of 6 vectors. 10 | **/ 11 | var planes : Array; 12 | function set(p0:Plane, p1:Plane, p2:Plane, p3:Plane, p4:Plane, p5:Plane):Frustum; 13 | function clone():Frustum; 14 | function copy(frustum:Frustum):Frustum; 15 | function setFromProjectionMatrix(m:Matrix4):Frustum; 16 | function intersectsObject(object:Object3D):Bool; 17 | function intersectsSprite(sprite:Sprite):Bool; 18 | function intersectsSphere(sphere:Sphere):Bool; 19 | function intersectsBox(box:Box3):Bool; 20 | function containsPoint(point:Vector3):Bool; 21 | static var prototype : Frustum; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/GLBufferAttribute.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | see {@link https://github.com/mrdoob/three.js/blob/master/src/core/GLBufferAttribute.js|src/core/GLBufferAttribute.js} 5 | **/ 6 | @:jsRequire("three", "GLBufferAttribute") extern class GLBufferAttribute { 7 | function new(buffer:js.html.webgl.Buffer, type:Float, itemSize:Float, elementSize:Int, count:Float); 8 | var buffer : js.html.webgl.Buffer; 9 | var type : Float; 10 | var itemSize : Float; 11 | var elementSize : Int; 12 | var count : Float; 13 | var version : Float; 14 | final isGLBufferAttribute : Bool; 15 | var needsUpdate : Bool; 16 | function setBuffer(buffer:js.html.webgl.Buffer):GLBufferAttribute; 17 | function setType(type:Float, elementSize:Int):GLBufferAttribute; 18 | function setItemSize(itemSize:Float):GLBufferAttribute; 19 | function setCount(count:Float):GLBufferAttribute; 20 | static var prototype : GLBufferAttribute; 21 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/GLSLVersion.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract GLSLVersion(Int) from Int to Int { 4 | final GLSL1 : GLSLVersion; 5 | final GLSL3 : GLSLVersion; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/GeometryUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "GeometryUtils") @valueModuleOnly extern class GeometryUtils { 4 | static function merge(geometry1:Dynamic, geometry2:Dynamic, ?materialIndexOffset:Dynamic):Dynamic; 5 | static function center(geometry:Dynamic):Dynamic; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/HSL.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef HSL = { 4 | var h : Float; 5 | var s : Float; 6 | var l : Float; 7 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ILoaderUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef ILoaderUtils = { 4 | function decodeText(array:js.lib.BufferSource):String; 5 | function extractUrlBase(url:String):String; 6 | function resolveURL(url:String, path:String):String; 7 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/IUniform.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef IUniform = { 4 | var value : TValue; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/IcosahedronGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "IcosahedronGeometry") extern class IcosahedronGeometry extends PolyhedronGeometry { 4 | function new(?radius:Float, ?detail:Float); 5 | function copy(source:BufferGeometry):IcosahedronGeometry; 6 | /** 7 | Adds a listener to an event type. 8 | **/ 9 | function addEventListener(type:T, listener:EventListener):Void; 10 | /** 11 | Checks if listener is added to an event type. 12 | **/ 13 | function hasEventListener(type:T, listener:EventListener):Bool; 14 | /** 15 | Removes a listener from an event type. 16 | **/ 17 | function removeEventListener(type:T, listener:EventListener):Void; 18 | static var prototype : IcosahedronGeometry; 19 | static function fromJSON(data:Dynamic):IcosahedronGeometry; 20 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ImageBitmapLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ImageBitmapLoader") extern class ImageBitmapLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | var options : Null; 6 | final isImageBitmapLoader : Bool; 7 | function setOptions(options:Dynamic):ImageBitmapLoader; 8 | function load(url:String, ?onLoad:(response:js.html.ImageBitmap) -> Void, ?onProgress:(request:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):Dynamic; 9 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 10 | function setCrossOrigin(crossOrigin:String):ImageBitmapLoader; 11 | function setWithCredentials(value:Bool):ImageBitmapLoader; 12 | function setPath(path:String):ImageBitmapLoader; 13 | function setResourcePath(resourcePath:String):ImageBitmapLoader; 14 | function setRequestHeader(requestHeader:{ }):ImageBitmapLoader; 15 | static var prototype : ImageBitmapLoader; 16 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ImageLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | A loader for loading an image. 5 | Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object. 6 | **/ 7 | @:jsRequire("three", "ImageLoader") extern class ImageLoader extends Loader { 8 | function new(?manager:LoadingManager); 9 | function load(url:String, ?onLoad:(image:js.html.ImageElement) -> Void, ?onProgress:(event:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):js.html.ImageElement; 10 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 11 | function setCrossOrigin(crossOrigin:String):ImageLoader; 12 | function setWithCredentials(value:Bool):ImageLoader; 13 | function setPath(path:String):ImageLoader; 14 | function setResourcePath(resourcePath:String):ImageLoader; 15 | function setRequestHeader(requestHeader:{ }):ImageLoader; 16 | static var prototype : ImageLoader; 17 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ImageUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ImageUtils") @valueModuleOnly extern class ImageUtils { 4 | static function getDataURL(image:Dynamic):String; 5 | static function loadTexture(url:String, ?mapping:Mapping, ?onLoad:(texture:Texture) -> Void, ?onError:(message:String) -> Void):Texture; 6 | static function loadTextureCube(array:Array, ?mapping:Mapping, ?onLoad:(texture:Texture) -> Void, ?onError:(message:String) -> Void):Texture; 7 | static var crossOrigin : String; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/InstancedBufferGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferGeometry.js|src/core/InstancedBufferGeometry.js} 5 | **/ 6 | @:jsRequire("three", "InstancedBufferGeometry") extern class InstancedBufferGeometry extends BufferGeometry { 7 | function new(); 8 | var isInstancedBufferGeometry : Bool; 9 | var instanceCount : Float; 10 | function addGroup(start:Float, count:Float, instances:Float):Void; 11 | function copy(source:BufferGeometry):InstancedBufferGeometry; 12 | /** 13 | Adds a listener to an event type. 14 | **/ 15 | function addEventListener(type:T, listener:EventListener):Void; 16 | /** 17 | Checks if listener is added to an event type. 18 | **/ 19 | function hasEventListener(type:T, listener:EventListener):Bool; 20 | /** 21 | Removes a listener from an event type. 22 | **/ 23 | function removeEventListener(type:T, listener:EventListener):Void; 24 | static var prototype : InstancedBufferGeometry; 25 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/InstancedInterleavedBuffer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InstancedInterleavedBuffer.js|src/core/InstancedInterleavedBuffer.js} 5 | **/ 6 | @:jsRequire("three", "InstancedInterleavedBuffer") extern class InstancedInterleavedBuffer extends InterleavedBuffer { 7 | function new(array:js.lib.ArrayLike, stride:Float, ?meshPerAttribute:Float); 8 | var meshPerAttribute : Float; 9 | function copy(source:InterleavedBuffer):InstancedInterleavedBuffer; 10 | static var prototype : InstancedInterleavedBuffer; 11 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/InterleavedBuffer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBuffer.js|src/core/InterleavedBuffer.js} 5 | **/ 6 | @:jsRequire("three", "InterleavedBuffer") extern class InterleavedBuffer { 7 | function new(array:js.lib.ArrayLike, stride:Float); 8 | var array : js.lib.ArrayLike; 9 | var stride : Float; 10 | var usage : Usage; 11 | var updateRange : { 12 | var offset : Float; 13 | var count : Float; 14 | }; 15 | var version : Float; 16 | var length : Float; 17 | var count : Float; 18 | var needsUpdate : Bool; 19 | var uuid : String; 20 | function setUsage(usage:Usage):InterleavedBuffer; 21 | function clone(data:Dynamic):InterleavedBuffer; 22 | function copy(source:InterleavedBuffer):InterleavedBuffer; 23 | function copyAt(index1:Float, attribute:InterleavedBufferAttribute, index2:Float):InterleavedBuffer; 24 | function set(value:js.lib.ArrayLike, index:Float):InterleavedBuffer; 25 | function toJSON(data:Dynamic):{ 26 | var uuid : String; 27 | var buffer : String; 28 | var type : String; 29 | var stride : Float; 30 | }; 31 | static var prototype : InterleavedBuffer; 32 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Interpolant.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Interpolant") extern class Interpolant { 4 | function new(parameterPositions:Dynamic, sampleValues:Dynamic, sampleSize:Float, ?resultBuffer:Dynamic); 5 | var parameterPositions : Dynamic; 6 | var sampleValues : Dynamic; 7 | var valueSize : Float; 8 | var resultBuffer : Dynamic; 9 | function evaluate(time:Float):Dynamic; 10 | static var prototype : Interpolant; 11 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/InterpolationEndingModes.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract InterpolationEndingModes(Int) from Int to Int { 4 | final ZeroCurvatureEnding : InterpolationEndingModes; 5 | final ZeroSlopeEnding : InterpolationEndingModes; 6 | final WrapAroundEnding : InterpolationEndingModes; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/InterpolationModes.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract InterpolationModes(Int) from Int to Int { 4 | final InterpolateDiscrete : InterpolationModes; 5 | final InterpolateLinear : InterpolationModes; 6 | final InterpolateSmooth : InterpolationModes; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Intersection.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Intersection = { 4 | var distance : Float; 5 | @:optional 6 | var distanceToRay : Float; 7 | var point : Vector3; 8 | @:optional 9 | var index : Float; 10 | @:optional 11 | var face : Face; 12 | @:optional 13 | var faceIndex : Float; 14 | var object : TIntersected; 15 | @:optional 16 | var uv : Vector2; 17 | @:optional 18 | var instanceId : Float; 19 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/KeyframeTrack.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "KeyframeTrack") extern class KeyframeTrack { 4 | function new(name:String, times:js.lib.ArrayLike, values:js.lib.ArrayLike, ?interpolation:InterpolationModes); 5 | var name : String; 6 | var times : js.lib.Float32Array; 7 | var values : js.lib.Float32Array; 8 | var ValueTypeName : String; 9 | var TimeBufferType : js.lib.Float32Array; 10 | var ValueBufferType : js.lib.Float32Array; 11 | var DefaultInterpolation : InterpolationModes; 12 | function InterpolantFactoryMethodDiscrete(result:Dynamic):DiscreteInterpolant; 13 | function InterpolantFactoryMethodLinear(result:Dynamic):LinearInterpolant; 14 | function InterpolantFactoryMethodSmooth(result:Dynamic):CubicInterpolant; 15 | function setInterpolation(interpolation:InterpolationModes):KeyframeTrack; 16 | function getInterpolation():InterpolationModes; 17 | function getValueSize():Float; 18 | function shift(timeOffset:Float):KeyframeTrack; 19 | function scale(timeScale:Float):KeyframeTrack; 20 | function trim(startTime:Float, endTime:Float):KeyframeTrack; 21 | function validate():Bool; 22 | function optimize():KeyframeTrack; 23 | function clone():KeyframeTrack; 24 | static var prototype : KeyframeTrack; 25 | static function toJSON(track:KeyframeTrack):Dynamic; 26 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/LatheGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "LatheGeometry") extern class LatheGeometry extends BufferGeometry { 4 | function new(?points:Array, ?segments:Float, ?phiStart:Float, ?phiLength:Float); 5 | var parameters : { 6 | var points : Array; 7 | var segments : Float; 8 | var phiStart : Float; 9 | var phiLength : Float; 10 | }; 11 | function copy(source:BufferGeometry):LatheGeometry; 12 | /** 13 | Adds a listener to an event type. 14 | **/ 15 | function addEventListener(type:T, listener:EventListener):Void; 16 | /** 17 | Checks if listener is added to an event type. 18 | **/ 19 | function hasEventListener(type:T, listener:EventListener):Bool; 20 | /** 21 | Removes a listener from an event type. 22 | **/ 23 | function removeEventListener(type:T, listener:EventListener):Void; 24 | static var prototype : LatheGeometry; 25 | static function fromJSON(data:Dynamic):LatheGeometry; 26 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Layers.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Layers") extern class Layers { 4 | function new(); 5 | var mask : Float; 6 | function set(channel:Float):Void; 7 | function enable(channel:Float):Void; 8 | function enableAll():Void; 9 | function toggle(channel:Float):Void; 10 | function disable(channel:Float):Void; 11 | function disableAll():Void; 12 | function test(layers:Layers):Bool; 13 | function isEnabled(channel:Float):Bool; 14 | static var prototype : Layers; 15 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/LightShadow.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "LightShadow") extern class LightShadow { 4 | function new(camera:Camera); 5 | var camera : Camera; 6 | var bias : Float; 7 | var normalBias : Float; 8 | var radius : Float; 9 | var blurSamples : Float; 10 | var mapSize : Vector2; 11 | var map : WebGLRenderTarget; 12 | var mapPass : WebGLRenderTarget; 13 | var matrix : Matrix4; 14 | var autoUpdate : Bool; 15 | var needsUpdate : Bool; 16 | function copy(source:LightShadow):LightShadow; 17 | function clone(?recursive:Bool):LightShadow; 18 | function toJSON():Dynamic; 19 | function getFrustum():Float; 20 | function updateMatrices(light:Light, ?viewportIndex:Float):Void; 21 | function getViewport(viewportIndex:Float):Vector4; 22 | function getFrameExtents():Vector2; 23 | function dispose():Void; 24 | static var prototype : LightShadow; 25 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Line3.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Line3") extern class Line3 { 4 | function new(?start:Vector3, ?end:Vector3); 5 | var start : Vector3; 6 | var end : Vector3; 7 | function set(?start:Vector3, ?end:Vector3):Line3; 8 | function clone():Line3; 9 | function copy(line:Line3):Line3; 10 | function getCenter(target:Vector3):Vector3; 11 | function delta(target:Vector3):Vector3; 12 | function distanceSq():Float; 13 | function distance():Float; 14 | function at(t:Float, target:Vector3):Vector3; 15 | function closestPointToPointParameter(point:Vector3, ?clampToLine:Bool):Float; 16 | function closestPointToPoint(point:Vector3, clampToLine:Bool, target:Vector3):Vector3; 17 | function applyMatrix4(matrix:Matrix4):Line3; 18 | function equals(line:Line3):Bool; 19 | static var prototype : Line3; 20 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/LineBasicMaterial.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "LineBasicMaterial") extern class LineBasicMaterial extends Material { 4 | function new(?parameters:LineBasicMaterialParameters); 5 | var color : Color; 6 | var linewidth : Float; 7 | var linecap : String; 8 | var linejoin : String; 9 | /** 10 | Sets the properties based on the values. 11 | **/ 12 | function setValues(parameters:LineBasicMaterialParameters):Void; 13 | /** 14 | Return a new material with the same parameters as this material. 15 | **/ 16 | function clone():LineBasicMaterial; 17 | /** 18 | Copy the parameters from the passed material into this material. 19 | **/ 20 | function copy(material:Material):LineBasicMaterial; 21 | /** 22 | Adds a listener to an event type. 23 | **/ 24 | function addEventListener(type:T, listener:EventListener):Void; 25 | /** 26 | Checks if listener is added to an event type. 27 | **/ 28 | function hasEventListener(type:T, listener:EventListener):Bool; 29 | /** 30 | Removes a listener from an event type. 31 | **/ 32 | function removeEventListener(type:T, listener:EventListener):Void; 33 | static var prototype : LineBasicMaterial; 34 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/LineCurve.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "LineCurve") extern class LineCurve extends Curve { 4 | function new(v1:Vector2, v2:Vector2); 5 | var v1 : Vector2; 6 | var v2 : Vector2; 7 | function clone():LineCurve; 8 | function copy(source:Curve):LineCurve; 9 | function fromJSON(json:Dynamic):LineCurve; 10 | static var prototype : LineCurve; 11 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/LineCurve3.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "LineCurve3") extern class LineCurve3 extends Curve { 4 | function new(v1:Vector3, v2:Vector3); 5 | var v1 : Vector3; 6 | var v2 : Vector3; 7 | function clone():LineCurve3; 8 | function copy(source:Curve):LineCurve3; 9 | function fromJSON(json:Dynamic):LineCurve3; 10 | static var prototype : LineCurve3; 11 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/LineDashedMaterial.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "LineDashedMaterial") extern class LineDashedMaterial extends LineBasicMaterial { 4 | function new(?parameters:LineDashedMaterialParameters); 5 | var scale : Float; 6 | var dashSize : Float; 7 | var gapSize : Float; 8 | final isLineDashedMaterial : Bool; 9 | /** 10 | Sets the properties based on the values. 11 | **/ 12 | function setValues(parameters:LineDashedMaterialParameters):Void; 13 | /** 14 | Return a new material with the same parameters as this material. 15 | **/ 16 | function clone():LineDashedMaterial; 17 | /** 18 | Copy the parameters from the passed material into this material. 19 | **/ 20 | function copy(material:Material):LineDashedMaterial; 21 | /** 22 | Adds a listener to an event type. 23 | **/ 24 | function addEventListener(type:T, listener:EventListener):Void; 25 | /** 26 | Checks if listener is added to an event type. 27 | **/ 28 | function hasEventListener(type:T, listener:EventListener):Bool; 29 | /** 30 | Removes a listener from an event type. 31 | **/ 32 | function removeEventListener(type:T, listener:EventListener):Void; 33 | static var prototype : LineDashedMaterial; 34 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/LinearInterpolant.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "LinearInterpolant") extern class LinearInterpolant extends Interpolant { 4 | function new(parameterPositions:Dynamic, samplesValues:Dynamic, sampleSize:Float, ?resultBuffer:Dynamic); 5 | function interpolate_(i1:Float, t0:Float, t:Float, t1:Float):Dynamic; 6 | static var prototype : LinearInterpolant; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Loader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | Base class for implementing loaders. 5 | **/ 6 | @:jsRequire("three", "Loader") extern class Loader { 7 | function new(?manager:LoadingManager); 8 | var crossOrigin : String; 9 | var withCredentials : Bool; 10 | var path : String; 11 | var resourcePath : String; 12 | var manager : LoadingManager; 13 | var requestHeader : { }; 14 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 15 | function setCrossOrigin(crossOrigin:String):Loader; 16 | function setWithCredentials(value:Bool):Loader; 17 | function setPath(path:String):Loader; 18 | function setResourcePath(resourcePath:String):Loader; 19 | function setRequestHeader(requestHeader:{ }):Loader; 20 | static var prototype : Loader; 21 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/LoaderUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "LoaderUtils") extern class LoaderUtils { 4 | function decodeText(array:js.lib.BufferSource):String; 5 | function extractUrlBase(url:String):String; 6 | function resolveURL(url:String, path:String):String; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/MOUSE.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "MOUSE") @:enum extern abstract MOUSE(Int) from Int to Int { 4 | var LEFT; 5 | var MIDDLE; 6 | var RIGHT; 7 | var ROTATE; 8 | var DOLLY; 9 | var PAN; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Mapping.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract Mapping(Int) from Int to Int { 4 | final UVMapping : Mapping; 5 | final CubeReflectionMapping : Mapping; 6 | final CubeRefractionMapping : Mapping; 7 | final EquirectangularReflectionMapping : Mapping; 8 | final EquirectangularRefractionMapping : Mapping; 9 | final CubeUVReflectionMapping : Mapping; 10 | final CubeUVRefractionMapping : Mapping; 11 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/MaterialLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "MaterialLoader") extern class MaterialLoader extends Loader { 4 | function new(?manager:LoadingManager); 5 | var textures : { }; 6 | function load(url:String, onLoad:(material:Material) -> Void, ?onProgress:(event:js.html.ProgressEvent_) -> Void, ?onError:(event:ts.AnyOf2) -> Void):Void; 7 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 8 | function setTextures(textures:{ }):MaterialLoader; 9 | function parse(json:Dynamic):Material; 10 | function setCrossOrigin(crossOrigin:String):MaterialLoader; 11 | function setWithCredentials(value:Bool):MaterialLoader; 12 | function setPath(path:String):MaterialLoader; 13 | function setResourcePath(resourcePath:String):MaterialLoader; 14 | function setRequestHeader(requestHeader:{ }):MaterialLoader; 15 | static var prototype : MaterialLoader; 16 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Matrix.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | ( interface Matrix ) 5 | **/ 6 | typedef Matrix = { 7 | /** 8 | Array with matrix values. 9 | **/ 10 | var elements : Array; 11 | /** 12 | identity():T; 13 | **/ 14 | function identity():Matrix; 15 | /** 16 | copy(m:T):T; 17 | **/ 18 | function copy(m:Matrix):Matrix; 19 | /** 20 | multiplyScalar(s:number):T; 21 | **/ 22 | function multiplyScalar(s:Float):Matrix; 23 | function determinant():Float; 24 | /** 25 | transpose():T; 26 | **/ 27 | function transpose():Matrix; 28 | /** 29 | invert():T; 30 | **/ 31 | function invert():Matrix; 32 | /** 33 | clone():T; 34 | **/ 35 | function clone():Matrix; 36 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Matrix3Tuple.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Matrix3Tuple = ts.Tuple9; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Matrix4Tuple.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Matrix4Tuple = ts.Tuple16; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/MorphTarget.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef MorphTarget = { 4 | var name : String; 5 | var vertices : Array; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Navigator.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Navigator = { 4 | @:optional 5 | var xr : XR; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/NormalMapTypes.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract NormalMapTypes(Int) from Int to Int { 4 | final TangentSpaceNormalMap : NormalMapTypes; 5 | final ObjectSpaceNormalMap : NormalMapTypes; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/NumberKeyframeTrack.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "NumberKeyframeTrack") extern class NumberKeyframeTrack extends KeyframeTrack { 4 | function new(name:String, times:Array, values:Array, ?interpolation:InterpolationModes); 5 | function clone():NumberKeyframeTrack; 6 | static var prototype : NumberKeyframeTrack; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/OctahedronGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "OctahedronGeometry") extern class OctahedronGeometry extends PolyhedronGeometry { 4 | function new(?radius:Float, ?detail:Float); 5 | function copy(source:BufferGeometry):OctahedronGeometry; 6 | /** 7 | Adds a listener to an event type. 8 | **/ 9 | function addEventListener(type:T, listener:EventListener):Void; 10 | /** 11 | Checks if listener is added to an event type. 12 | **/ 13 | function hasEventListener(type:T, listener:EventListener):Bool; 14 | /** 15 | Removes a listener from an event type. 16 | **/ 17 | function removeEventListener(type:T, listener:EventListener):Void; 18 | static var prototype : OctahedronGeometry; 19 | static function fromJSON(data:Dynamic):OctahedronGeometry; 20 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PMREMGenerator.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "PMREMGenerator") extern class PMREMGenerator { 4 | function new(renderer:WebGLRenderer); 5 | function fromScene(scene:Scene, ?sigma:Float, ?near:Float, ?far:Float):WebGLRenderTarget; 6 | function fromEquirectangular(equirectangular:Texture):WebGLRenderTarget; 7 | function fromCubemap(cubemap:CubeTexture):WebGLRenderTarget; 8 | function compileCubemapShader():Void; 9 | function compileEquirectangularShader():Void; 10 | function dispose():Void; 11 | static var prototype : PMREMGenerator; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ParseTrackNameResults.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef ParseTrackNameResults = { 4 | var nodeName : String; 5 | var objectName : String; 6 | var objectIndex : String; 7 | var propertyName : String; 8 | var propertyIndex : String; 9 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PixelFormat.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract PixelFormat(Int) from Int to Int { 4 | final AlphaFormat : PixelFormat; 5 | final RGBFormat : PixelFormat; 6 | final RGBAFormat : PixelFormat; 7 | final LuminanceFormat : PixelFormat; 8 | final LuminanceAlphaFormat : PixelFormat; 9 | final RGBEFormat : PixelFormat; 10 | final DepthFormat : PixelFormat; 11 | final DepthStencilFormat : PixelFormat; 12 | final RedFormat : PixelFormat; 13 | final RedIntegerFormat : PixelFormat; 14 | final RGFormat : PixelFormat; 15 | final RGIntegerFormat : PixelFormat; 16 | final RGBIntegerFormat : PixelFormat; 17 | final RGBAIntegerFormat : PixelFormat; 18 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PixelFormatGPU.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef PixelFormatGPU = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Plane.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Plane") extern class Plane { 4 | function new(?normal:Vector3, ?constant:Float); 5 | var normal : Vector3; 6 | var constant : Float; 7 | final isPlane : Bool; 8 | function set(normal:Vector3, constant:Float):Plane; 9 | function setComponents(x:Float, y:Float, z:Float, w:Float):Plane; 10 | function setFromNormalAndCoplanarPoint(normal:Vector3, point:Vector3):Plane; 11 | function setFromCoplanarPoints(a:Vector3, b:Vector3, c:Vector3):Plane; 12 | function clone():Plane; 13 | function copy(plane:Plane):Plane; 14 | function normalize():Plane; 15 | function negate():Plane; 16 | function distanceToPoint(point:Vector3):Float; 17 | function distanceToSphere(sphere:Sphere):Float; 18 | function projectPoint(point:Vector3, target:Vector3):Vector3; 19 | function orthoPoint(point:Vector3, target:Vector3):Vector3; 20 | function intersectLine(line:Line3, target:Vector3):Null; 21 | function intersectsLine(line:Line3):Bool; 22 | function intersectsBox(box:Box3):Bool; 23 | function intersectsSphere(sphere:Sphere):Bool; 24 | function coplanarPoint(target:Vector3):Vector3; 25 | function applyMatrix4(matrix:Matrix4, ?optionalNormalMatrix:Matrix3):Plane; 26 | function translate(offset:Vector3):Plane; 27 | function equals(plane:Plane):Bool; 28 | function isIntersectionLine(l:Dynamic):Dynamic; 29 | static var prototype : Plane; 30 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PlaneGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "PlaneGeometry") extern class PlaneGeometry extends BufferGeometry { 4 | function new(?width:Float, ?height:Float, ?widthSegments:Float, ?heightSegments:Float); 5 | var parameters : { 6 | var width : Float; 7 | var height : Float; 8 | var widthSegments : Float; 9 | var heightSegments : Float; 10 | }; 11 | function copy(source:BufferGeometry):PlaneGeometry; 12 | /** 13 | Adds a listener to an event type. 14 | **/ 15 | function addEventListener(type:T, listener:EventListener):Void; 16 | /** 17 | Checks if listener is added to an event type. 18 | **/ 19 | function hasEventListener(type:T, listener:EventListener):Bool; 20 | /** 21 | Removes a listener from an event type. 22 | **/ 23 | function removeEventListener(type:T, listener:EventListener):Void; 24 | static var prototype : PlaneGeometry; 25 | static function fromJSON(data:Dynamic):PlaneGeometry; 26 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PointLightShadow.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "PointLightShadow") extern class PointLightShadow extends LightShadow { 4 | function new(); 5 | function copy(source:LightShadow):PointLightShadow; 6 | function clone(?recursive:Bool):PointLightShadow; 7 | static var prototype : PointLightShadow; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PointsMaterial.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "PointsMaterial") extern class PointsMaterial extends Material { 4 | function new(?parameters:PointsMaterialParameters); 5 | var color : Color; 6 | var map : Null; 7 | var alphaMap : Null; 8 | var size : Float; 9 | var sizeAttenuation : Bool; 10 | /** 11 | Sets the properties based on the values. 12 | **/ 13 | function setValues(parameters:PointsMaterialParameters):Void; 14 | /** 15 | Return a new material with the same parameters as this material. 16 | **/ 17 | function clone():PointsMaterial; 18 | /** 19 | Copy the parameters from the passed material into this material. 20 | **/ 21 | function copy(material:Material):PointsMaterial; 22 | /** 23 | Adds a listener to an event type. 24 | **/ 25 | function addEventListener(type:T, listener:EventListener):Void; 26 | /** 27 | Checks if listener is added to an event type. 28 | **/ 29 | function hasEventListener(type:T, listener:EventListener):Bool; 30 | /** 31 | Removes a listener from an event type. 32 | **/ 33 | function removeEventListener(type:T, listener:EventListener):Void; 34 | static var prototype : PointsMaterial; 35 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PolyhedronGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "PolyhedronGeometry") extern class PolyhedronGeometry extends BufferGeometry { 4 | function new(?vertices:Array, ?indices:Array, ?radius:Float, ?detail:Float); 5 | var parameters : { 6 | var vertices : Array; 7 | var indices : Array; 8 | var radius : Float; 9 | var detail : Float; 10 | }; 11 | function copy(source:BufferGeometry):PolyhedronGeometry; 12 | /** 13 | Adds a listener to an event type. 14 | **/ 15 | function addEventListener(type:T, listener:EventListener):Void; 16 | /** 17 | Checks if listener is added to an event type. 18 | **/ 19 | function hasEventListener(type:T, listener:EventListener):Bool; 20 | /** 21 | Removes a listener from an event type. 22 | **/ 23 | function removeEventListener(type:T, listener:EventListener):Void; 24 | static var prototype : PolyhedronGeometry; 25 | static function fromJSON(data:Dynamic):PolyhedronGeometry; 26 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PropertyBinding.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "PropertyBinding") extern class PropertyBinding { 4 | function new(rootNode:Dynamic, path:String, ?parsedPath:Dynamic); 5 | var path : String; 6 | var parsedPath : Dynamic; 7 | var node : Dynamic; 8 | var rootNode : Dynamic; 9 | function getValue(targetArray:Dynamic, offset:Float):Dynamic; 10 | function setValue(sourceArray:Dynamic, offset:Float):Void; 11 | function bind():Void; 12 | function unbind():Void; 13 | var BindingType : { }; 14 | var Versioning : { }; 15 | var GetterByBindingType : Array<() -> Void>; 16 | var SetterByBindingTypeAndVersioning : Array Void>>; 17 | static var prototype : PropertyBinding; 18 | static function create(root:Dynamic, path:Dynamic, ?parsedPath:Dynamic):ts.AnyOf2; 19 | static function sanitizeNodeName(name:String):String; 20 | static function parseTrackName(trackName:String):ParseTrackNameResults; 21 | static function findNode(root:Dynamic, nodeName:String):Dynamic; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/PropertyMixer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "PropertyMixer") extern class PropertyMixer { 4 | function new(binding:Dynamic, typeName:String, valueSize:Float); 5 | var binding : Dynamic; 6 | var valueSize : Float; 7 | var buffer : Dynamic; 8 | var cumulativeWeight : Float; 9 | var cumulativeWeightAdditive : Float; 10 | var useCount : Float; 11 | var referenceCount : Float; 12 | function accumulate(accuIndex:Float, weight:Float):Void; 13 | function accumulateAdditive(weight:Float):Void; 14 | function apply(accuIndex:Float):Void; 15 | function saveOriginalState():Void; 16 | function restoreOriginalState():Void; 17 | static var prototype : PropertyMixer; 18 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/QuadraticBezierCurve.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "QuadraticBezierCurve") extern class QuadraticBezierCurve extends Curve { 4 | function new(v0:Vector2, v1:Vector2, v2:Vector2); 5 | var v0 : Vector2; 6 | var v1 : Vector2; 7 | var v2 : Vector2; 8 | function clone():QuadraticBezierCurve; 9 | function copy(source:Curve):QuadraticBezierCurve; 10 | function fromJSON(json:Dynamic):QuadraticBezierCurve; 11 | static var prototype : QuadraticBezierCurve; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/QuadraticBezierCurve3.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "QuadraticBezierCurve3") extern class QuadraticBezierCurve3 extends Curve { 4 | function new(v0:Vector3, v1:Vector3, v2:Vector3); 5 | var v0 : Vector3; 6 | var v1 : Vector3; 7 | var v2 : Vector3; 8 | function clone():QuadraticBezierCurve3; 9 | function copy(source:Curve):QuadraticBezierCurve3; 10 | function fromJSON(json:Dynamic):QuadraticBezierCurve3; 11 | static var prototype : QuadraticBezierCurve3; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/QuaternionKeyframeTrack.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "QuaternionKeyframeTrack") extern class QuaternionKeyframeTrack extends KeyframeTrack { 4 | function new(name:String, times:Array, values:Array, ?interpolation:InterpolationModes); 5 | function clone():QuaternionKeyframeTrack; 6 | static var prototype : QuaternionKeyframeTrack; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/QuaternionLinearInterpolant.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "QuaternionLinearInterpolant") extern class QuaternionLinearInterpolant extends Interpolant { 4 | function new(parameterPositions:Dynamic, samplesValues:Dynamic, sampleSize:Float, ?resultBuffer:Dynamic); 5 | function interpolate_(i1:Float, t0:Float, t:Float, t1:Float):Dynamic; 6 | static var prototype : QuaternionLinearInterpolant; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/RawShaderMaterial.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "RawShaderMaterial") extern class RawShaderMaterial extends ShaderMaterial { 4 | function new(?parameters:ShaderMaterialParameters); 5 | /** 6 | Return a new material with the same parameters as this material. 7 | **/ 8 | function clone():RawShaderMaterial; 9 | /** 10 | Copy the parameters from the passed material into this material. 11 | **/ 12 | function copy(material:Material):RawShaderMaterial; 13 | /** 14 | Adds a listener to an event type. 15 | **/ 16 | function addEventListener(type:T, listener:EventListener):Void; 17 | /** 18 | Checks if listener is added to an event type. 19 | **/ 20 | function hasEventListener(type:T, listener:EventListener):Bool; 21 | /** 22 | Removes a listener from an event type. 23 | **/ 24 | function removeEventListener(type:T, listener:EventListener):Void; 25 | static var prototype : RawShaderMaterial; 26 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/RaycasterParameters.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef RaycasterParameters = { 4 | @:optional 5 | var Mesh : Dynamic; 6 | @:optional 7 | var Line : { 8 | var threshold : Float; 9 | }; 10 | @:optional 11 | var LOD : Dynamic; 12 | @:optional 13 | var Points : { 14 | var threshold : Float; 15 | }; 16 | @:optional 17 | var Sprite : Dynamic; 18 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/RenderItem.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef RenderItem = { 4 | var id : Float; 5 | var object : Object3D; 6 | var geometry : Null; 7 | var material : Material; 8 | var program : WebGLProgram; 9 | var groupOrder : Float; 10 | var renderOrder : Float; 11 | var z : Float; 12 | var group : Null; 13 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Renderer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Renderer = { 4 | var domElement : js.html.CanvasElement; 5 | function render(scene:Object3D, camera:Camera):Void; 6 | function setSize(width:Float, height:Float, ?updateStyle:Bool):Void; 7 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/RingGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "RingGeometry") extern class RingGeometry extends BufferGeometry { 4 | function new(?innerRadius:Float, ?outerRadius:Float, ?thetaSegments:Float, ?phiSegments:Float, ?thetaStart:Float, ?thetaLength:Float); 5 | var parameters : { 6 | var innerRadius : Float; 7 | var outerRadius : Float; 8 | var thetaSegments : Float; 9 | var phiSegments : Float; 10 | var thetaStart : Float; 11 | var thetaLength : Float; 12 | }; 13 | function copy(source:BufferGeometry):RingGeometry; 14 | /** 15 | Adds a listener to an event type. 16 | **/ 17 | function addEventListener(type:T, listener:EventListener):Void; 18 | /** 19 | Checks if listener is added to an event type. 20 | **/ 21 | function hasEventListener(type:T, listener:EventListener):Bool; 22 | /** 23 | Removes a listener from an event type. 24 | **/ 25 | function removeEventListener(type:T, listener:EventListener):Void; 26 | static var prototype : RingGeometry; 27 | static function fromJSON(data:Dynamic):RingGeometry; 28 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Shader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Shader = { 4 | var uniforms : { }; 5 | var vertexShader : String; 6 | var fragmentShader : String; 7 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Shading.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract Shading(Int) from Int to Int { 4 | final FlatShading : Shading; 5 | final SmoothShading : Shading; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ShadowMapType.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract ShadowMapType(Int) from Int to Int { 4 | final BasicShadowMap : ShadowMapType; 5 | final PCFShadowMap : ShadowMapType; 6 | final PCFSoftShadowMap : ShadowMapType; 7 | final VSMShadowMap : ShadowMapType; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ShadowMaterial.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ShadowMaterial") extern class ShadowMaterial extends Material { 4 | function new(?parameters:ShadowMaterialParameters); 5 | var color : Color; 6 | /** 7 | Return a new material with the same parameters as this material. 8 | **/ 9 | function clone():ShadowMaterial; 10 | /** 11 | Copy the parameters from the passed material into this material. 12 | **/ 13 | function copy(material:Material):ShadowMaterial; 14 | /** 15 | Adds a listener to an event type. 16 | **/ 17 | function addEventListener(type:T, listener:EventListener):Void; 18 | /** 19 | Checks if listener is added to an event type. 20 | **/ 21 | function hasEventListener(type:T, listener:EventListener):Bool; 22 | /** 23 | Removes a listener from an event type. 24 | **/ 25 | function removeEventListener(type:T, listener:EventListener):Void; 26 | static var prototype : ShadowMaterial; 27 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ShapeGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ShapeGeometry") extern class ShapeGeometry extends BufferGeometry { 4 | function new(?shapes:ts.AnyOf2>, ?curveSegments:Float); 5 | function copy(source:BufferGeometry):ShapeGeometry; 6 | /** 7 | Adds a listener to an event type. 8 | **/ 9 | function addEventListener(type:T, listener:EventListener):Void; 10 | /** 11 | Checks if listener is added to an event type. 12 | **/ 13 | function hasEventListener(type:T, listener:EventListener):Bool; 14 | /** 15 | Removes a listener from an event type. 16 | **/ 17 | function removeEventListener(type:T, listener:EventListener):Void; 18 | static var prototype : ShapeGeometry; 19 | static function fromJSON(data:Dynamic):ShapeGeometry; 20 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ShapePath.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ShapePath") extern class ShapePath { 4 | function new(); 5 | var type : String; 6 | var color : Color; 7 | var subPaths : Array; 8 | var currentPath : Dynamic; 9 | function moveTo(x:Float, y:Float):ShapePath; 10 | function lineTo(x:Float, y:Float):ShapePath; 11 | function quadraticCurveTo(aCPx:Float, aCPy:Float, aX:Float, aY:Float):ShapePath; 12 | function bezierCurveTo(aCP1x:Float, aCP1y:Float, aCP2x:Float, aCP2y:Float, aX:Float, aY:Float):ShapePath; 13 | function splineThru(pts:Array):ShapePath; 14 | function toShapes(isCCW:Bool, ?noHoles:Bool):Array; 15 | static var prototype : ShapePath; 16 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ShapeUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "ShapeUtils") @valueModuleOnly extern class ShapeUtils { 4 | static function area(contour:Array):Float; 5 | static function triangulateShape(contour:Array, holes:Array>):Array>; 6 | static function isClockWise(pts:Array):Bool; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Side.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract Side(Int) from Int to Int { 4 | final FrontSide : Side; 5 | final BackSide : Side; 6 | final DoubleSide : Side; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Skeleton.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Skeleton") extern class Skeleton { 4 | function new(bones:Array, ?boneInverses:Array); 5 | var uuid : String; 6 | var bones : Array; 7 | var boneInverses : Array; 8 | var boneMatrices : js.lib.Float32Array; 9 | var boneTexture : Null; 10 | var boneTextureSize : Float; 11 | var frame : Float; 12 | function init():Void; 13 | function calculateInverses():Void; 14 | function computeBoneTexture():Skeleton; 15 | function pose():Void; 16 | function update():Void; 17 | function clone():Skeleton; 18 | function getBoneByName(name:String):Null; 19 | function dispose():Void; 20 | var useVertexTexture : Bool; 21 | static var prototype : Skeleton; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Sphere.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Sphere") extern class Sphere { 4 | function new(?center:Vector3, ?radius:Float); 5 | var center : Vector3; 6 | var radius : Float; 7 | function set(center:Vector3, radius:Float):Sphere; 8 | function setFromPoints(points:Array, ?optionalCenter:Vector3):Sphere; 9 | function clone():Sphere; 10 | function copy(sphere:Sphere):Sphere; 11 | function expandByPoint(point:Vector3):Sphere; 12 | function isEmpty():Bool; 13 | function makeEmpty():Sphere; 14 | function containsPoint(point:Vector3):Bool; 15 | function distanceToPoint(point:Vector3):Float; 16 | function intersectsSphere(sphere:Sphere):Bool; 17 | function intersectsBox(box:Box3):Bool; 18 | function intersectsPlane(plane:Plane):Bool; 19 | function clampPoint(point:Vector3, target:Vector3):Vector3; 20 | function getBoundingBox(target:Box3):Box3; 21 | function applyMatrix4(matrix:Matrix4):Sphere; 22 | function translate(offset:Vector3):Sphere; 23 | function equals(sphere:Sphere):Bool; 24 | function union(sphere:Sphere):Sphere; 25 | function empty():Dynamic; 26 | static var prototype : Sphere; 27 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/SphereGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "SphereGeometry") extern class SphereGeometry extends BufferGeometry { 4 | function new(?radius:Float, ?widthSegments:Float, ?heightSegments:Float, ?phiStart:Float, ?phiLength:Float, ?thetaStart:Float, ?thetaLength:Float); 5 | var parameters : { 6 | var radius : Float; 7 | var widthSegments : Float; 8 | var heightSegments : Float; 9 | var phiStart : Float; 10 | var phiLength : Float; 11 | var thetaStart : Float; 12 | var thetaLength : Float; 13 | }; 14 | function copy(source:BufferGeometry):SphereGeometry; 15 | /** 16 | Adds a listener to an event type. 17 | **/ 18 | function addEventListener(type:T, listener:EventListener):Void; 19 | /** 20 | Checks if listener is added to an event type. 21 | **/ 22 | function hasEventListener(type:T, listener:EventListener):Bool; 23 | /** 24 | Removes a listener from an event type. 25 | **/ 26 | function removeEventListener(type:T, listener:EventListener):Void; 27 | static var prototype : SphereGeometry; 28 | static function fromJSON(data:Dynamic):SphereGeometry; 29 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Spherical.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Spherical") extern class Spherical { 4 | function new(?radius:Float, ?phi:Float, ?theta:Float); 5 | var radius : Float; 6 | var phi : Float; 7 | var theta : Float; 8 | function set(radius:Float, phi:Float, theta:Float):Spherical; 9 | function clone():Spherical; 10 | function copy(other:Spherical):Spherical; 11 | function makeSafe():Spherical; 12 | function setFromVector3(v:Vector3):Spherical; 13 | function setFromCartesianCoords(x:Float, y:Float, z:Float):Spherical; 14 | static var prototype : Spherical; 15 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/SplineCurve.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "SplineCurve") extern class SplineCurve extends Curve { 4 | function new(?points:Array); 5 | var points : Array; 6 | function clone():SplineCurve; 7 | function copy(source:Curve):SplineCurve; 8 | function fromJSON(json:Dynamic):SplineCurve; 9 | static var prototype : SplineCurve; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/SpotLightShadow.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "SpotLightShadow") extern class SpotLightShadow extends LightShadow { 4 | function new(); 5 | final isSpotLightShadow : Bool; 6 | var focus : Float; 7 | function copy(source:LightShadow):SpotLightShadow; 8 | function clone(?recursive:Bool):SpotLightShadow; 9 | static var prototype : SpotLightShadow; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/SpriteMaterial.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "SpriteMaterial") extern class SpriteMaterial extends Material { 4 | function new(?parameters:SpriteMaterialParameters); 5 | var color : Color; 6 | var map : Null; 7 | var alphaMap : Null; 8 | var rotation : Float; 9 | var sizeAttenuation : Bool; 10 | final isSpriteMaterial : Bool; 11 | /** 12 | Sets the properties based on the values. 13 | **/ 14 | function setValues(parameters:SpriteMaterialParameters):Void; 15 | /** 16 | Copy the parameters from the passed material into this material. 17 | **/ 18 | function copy(source:SpriteMaterial):SpriteMaterial; 19 | /** 20 | Return a new material with the same parameters as this material. 21 | **/ 22 | function clone():SpriteMaterial; 23 | /** 24 | Adds a listener to an event type. 25 | **/ 26 | function addEventListener(type:T, listener:EventListener):Void; 27 | /** 28 | Checks if listener is added to an event type. 29 | **/ 30 | function hasEventListener(type:T, listener:EventListener):Bool; 31 | /** 32 | Removes a listener from an event type. 33 | **/ 34 | function removeEventListener(type:T, listener:EventListener):Void; 35 | static var prototype : SpriteMaterial; 36 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/StencilFunc.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract StencilFunc(Int) from Int to Int { 4 | final NeverStencilFunc : StencilFunc; 5 | final LessStencilFunc : StencilFunc; 6 | final EqualStencilFunc : StencilFunc; 7 | final LessEqualStencilFunc : StencilFunc; 8 | final GreaterStencilFunc : StencilFunc; 9 | final NotEqualStencilFunc : StencilFunc; 10 | final GreaterEqualStencilFunc : StencilFunc; 11 | final AlwaysStencilFunc : StencilFunc; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/StencilOp.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract StencilOp(Int) from Int to Int { 4 | final ZeroStencilOp : StencilOp; 5 | final KeepStencilOp : StencilOp; 6 | final ReplaceStencilOp : StencilOp; 7 | final IncrementStencilOp : StencilOp; 8 | final DecrementStencilOp : StencilOp; 9 | final IncrementWrapStencilOp : StencilOp; 10 | final DecrementWrapStencilOp : StencilOp; 11 | final InvertStencilOp : StencilOp; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/StringKeyframeTrack.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "StringKeyframeTrack") extern class StringKeyframeTrack extends KeyframeTrack { 4 | function new(name:String, times:Array, values:Array, ?interpolation:InterpolationModes); 5 | function clone():StringKeyframeTrack; 6 | static var prototype : StringKeyframeTrack; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TOUCH.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "TOUCH") @:enum extern abstract TOUCH(Int) from Int to Int { 4 | var ROTATE; 5 | var PAN; 6 | var DOLLY_PAN; 7 | var DOLLY_ROTATE; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TetrahedronGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "TetrahedronGeometry") extern class TetrahedronGeometry extends PolyhedronGeometry { 4 | function new(?radius:Float, ?detail:Float); 5 | function copy(source:BufferGeometry):TetrahedronGeometry; 6 | /** 7 | Adds a listener to an event type. 8 | **/ 9 | function addEventListener(type:T, listener:EventListener):Void; 10 | /** 11 | Checks if listener is added to an event type. 12 | **/ 13 | function hasEventListener(type:T, listener:EventListener):Bool; 14 | /** 15 | Removes a listener from an event type. 16 | **/ 17 | function removeEventListener(type:T, listener:EventListener):Void; 18 | static var prototype : TetrahedronGeometry; 19 | static function fromJSON(data:Dynamic):TetrahedronGeometry; 20 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TextureDataType.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract TextureDataType(Int) from Int to Int { 4 | final UnsignedByteType : TextureDataType; 5 | final ByteType : TextureDataType; 6 | final ShortType : TextureDataType; 7 | final UnsignedShortType : TextureDataType; 8 | final IntType : TextureDataType; 9 | final UnsignedIntType : TextureDataType; 10 | final FloatType : TextureDataType; 11 | final HalfFloatType : TextureDataType; 12 | final UnsignedShort4444Type : TextureDataType; 13 | final UnsignedShort5551Type : TextureDataType; 14 | final UnsignedShort565Type : TextureDataType; 15 | final UnsignedInt248Type : TextureDataType; 16 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TextureEncoding.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract TextureEncoding(Int) from Int to Int { 4 | final LinearEncoding : TextureEncoding; 5 | final sRGBEncoding : TextureEncoding; 6 | final GammaEncoding : TextureEncoding; 7 | final RGBEEncoding : TextureEncoding; 8 | final LogLuvEncoding : TextureEncoding; 9 | final RGBM7Encoding : TextureEncoding; 10 | final RGBM16Encoding : TextureEncoding; 11 | final RGBDEncoding : TextureEncoding; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TextureFilter.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract TextureFilter(Int) from Int to Int { 4 | final NearestFilter : TextureFilter; 5 | final NearestMipmapNearestFilter : TextureFilter; 6 | final NearestMipMapNearestFilter : TextureFilter; 7 | final NearestMipmapLinearFilter : TextureFilter; 8 | final NearestMipMapLinearFilter : TextureFilter; 9 | final LinearFilter : TextureFilter; 10 | final LinearMipmapNearestFilter : TextureFilter; 11 | final LinearMipMapNearestFilter : TextureFilter; 12 | final LinearMipmapLinearFilter : TextureFilter; 13 | final LinearMipMapLinearFilter : TextureFilter; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TextureLoader.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | Class for loading a texture. 5 | Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object. 6 | **/ 7 | @:jsRequire("three", "TextureLoader") extern class TextureLoader extends Loader { 8 | function new(?manager:LoadingManager); 9 | function load(url:String, ?onLoad:(texture:Texture) -> Void, ?onProgress:(event:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):Texture; 10 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 11 | function setCrossOrigin(crossOrigin:String):TextureLoader; 12 | function setWithCredentials(value:Bool):TextureLoader; 13 | function setPath(path:String):TextureLoader; 14 | function setResourcePath(resourcePath:String):TextureLoader; 15 | function setRequestHeader(requestHeader:{ }):TextureLoader; 16 | static var prototype : TextureLoader; 17 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/ToneMapping.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract ToneMapping(Int) from Int to Int { 4 | final NoToneMapping : ToneMapping; 5 | final LinearToneMapping : ToneMapping; 6 | final ReinhardToneMapping : ToneMapping; 7 | final CineonToneMapping : ToneMapping; 8 | final ACESFilmicToneMapping : ToneMapping; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TorusGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "TorusGeometry") extern class TorusGeometry extends BufferGeometry { 4 | function new(?radius:Float, ?tube:Float, ?radialSegments:Float, ?tubularSegments:Float, ?arc:Float); 5 | var parameters : { 6 | var radius : Float; 7 | var tube : Float; 8 | var radialSegments : Float; 9 | var tubularSegments : Float; 10 | var arc : Float; 11 | }; 12 | function copy(source:BufferGeometry):TorusGeometry; 13 | /** 14 | Adds a listener to an event type. 15 | **/ 16 | function addEventListener(type:T, listener:EventListener):Void; 17 | /** 18 | Checks if listener is added to an event type. 19 | **/ 20 | function hasEventListener(type:T, listener:EventListener):Bool; 21 | /** 22 | Removes a listener from an event type. 23 | **/ 24 | function removeEventListener(type:T, listener:EventListener):Void; 25 | static var prototype : TorusGeometry; 26 | static function fromJSON(data:Dynamic):TorusGeometry; 27 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TorusKnotGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "TorusKnotGeometry") extern class TorusKnotGeometry extends BufferGeometry { 4 | function new(?radius:Float, ?tube:Float, ?tubularSegments:Float, ?radialSegments:Float, ?p:Float, ?q:Float); 5 | var parameters : { 6 | var radius : Float; 7 | var tube : Float; 8 | var tubularSegments : Float; 9 | var radialSegments : Float; 10 | var p : Float; 11 | var q : Float; 12 | }; 13 | function copy(source:BufferGeometry):TorusKnotGeometry; 14 | /** 15 | Adds a listener to an event type. 16 | **/ 17 | function addEventListener(type:T, listener:EventListener):Void; 18 | /** 19 | Checks if listener is added to an event type. 20 | **/ 21 | function hasEventListener(type:T, listener:EventListener):Bool; 22 | /** 23 | Removes a listener from an event type. 24 | **/ 25 | function removeEventListener(type:T, listener:EventListener):Void; 26 | static var prototype : TorusKnotGeometry; 27 | static function fromJSON(data:Dynamic):TorusKnotGeometry; 28 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TrianglesDrawModes.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract TrianglesDrawModes(Int) from Int to Int { 4 | final TrianglesDrawMode : TrianglesDrawModes; 5 | final TriangleStripDrawMode : TrianglesDrawModes; 6 | final TriangleFanDrawMode : TrianglesDrawModes; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/TubeGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "TubeGeometry") extern class TubeGeometry extends BufferGeometry { 4 | function new(?path:Curve, ?tubularSegments:Float, ?radius:Float, ?radiusSegments:Float, ?closed:Bool); 5 | var parameters : { 6 | var path : Curve; 7 | var tubularSegments : Float; 8 | var radius : Float; 9 | var radialSegments : Float; 10 | var closed : Bool; 11 | }; 12 | var tangents : Array; 13 | var normals : Array; 14 | var binormals : Array; 15 | function copy(source:BufferGeometry):TubeGeometry; 16 | /** 17 | Adds a listener to an event type. 18 | **/ 19 | function addEventListener(type:T, listener:EventListener):Void; 20 | /** 21 | Checks if listener is added to an event type. 22 | **/ 23 | function hasEventListener(type:T, listener:EventListener):Bool; 24 | /** 25 | Removes a listener from an event type. 26 | **/ 27 | function removeEventListener(type:T, listener:EventListener):Void; 28 | static var prototype : TubeGeometry; 29 | static function fromJSON(data:Dynamic):TubeGeometry; 30 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/UVGenerator.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef UVGenerator = { 4 | function generateTopUV(geometry:ExtrudeGeometry, vertices:Array, indexA:Float, indexB:Float, indexC:Float):Array; 5 | function generateSideWallUV(geometry:ExtrudeGeometry, vertices:Array, indexA:Float, indexB:Float, indexC:Float, indexD:Float):Array; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Uniform.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "Uniform") extern class Uniform { 4 | @:overload(function(type:String, value:Dynamic):Uniform { }) 5 | function new(value:Dynamic); 6 | var type : String; 7 | var value : Dynamic; 8 | @:native("dynamic") 9 | var dynamic_ : Bool; 10 | dynamic function onUpdateCallback():Void; 11 | function onUpdate(callback:() -> Void):Uniform; 12 | static var prototype : Uniform; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/UniformsUtils.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "UniformsUtils") @valueModuleOnly extern class UniformsUtils { 4 | static function merge(uniforms:Array):Dynamic; 5 | static function clone(uniforms_src:Dynamic):Dynamic; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Usage.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract Usage(Int) from Int to Int { 4 | final StaticDrawUsage : Usage; 5 | final DynamicDrawUsage : Usage; 6 | final StreamDrawUsage : Usage; 7 | final StaticReadUsage : Usage; 8 | final DynamicReadUsage : Usage; 9 | final StreamReadUsage : Usage; 10 | final StaticCopyUsage : Usage; 11 | final DynamicCopyUsage : Usage; 12 | final StreamCopyUsage : Usage; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Vec2.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Vec2 = { 4 | var x : Float; 5 | var y : Float; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Vector2Tuple.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Vector2Tuple = ts.Tuple2; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Vector3Tuple.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Vector3Tuple = ts.Tuple3; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Vector4Tuple.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Vector4Tuple = ts.Tuple4; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/VectorKeyframeTrack.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "VectorKeyframeTrack") extern class VectorKeyframeTrack extends KeyframeTrack { 4 | function new(name:String, times:Array, values:Array, ?interpolation:InterpolationModes); 5 | function clone():VectorKeyframeTrack; 6 | static var prototype : VectorKeyframeTrack; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/VideoTexture.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "VideoTexture") extern class VideoTexture extends Texture { 4 | function new(video:js.html.VideoElement, ?mapping:Mapping, ?wrapS:Wrapping, ?wrapT:Wrapping, ?magFilter:TextureFilter, ?minFilter:TextureFilter, ?format:PixelFormat, ?type:TextureDataType, ?anisotropy:Float); 5 | final isVideoTexture : Bool; 6 | function clone():VideoTexture; 7 | function copy(source:Texture):VideoTexture; 8 | /** 9 | Adds a listener to an event type. 10 | **/ 11 | function addEventListener(type:T, listener:EventListener):Void; 12 | /** 13 | Checks if listener is added to an event type. 14 | **/ 15 | function hasEventListener(type:T, listener:EventListener):Bool; 16 | /** 17 | Removes a listener from an event type. 18 | **/ 19 | function removeEventListener(type:T, listener:EventListener):Void; 20 | static var prototype : VideoTexture; 21 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGL1Renderer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGL1Renderer") extern class WebGL1Renderer extends WebGLRenderer { 4 | function new(?parameters:WebGLRendererParameters); 5 | final isWebGL1Renderer : Bool; 6 | static var prototype : WebGL1Renderer; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLBufferRenderer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLBufferRenderer") extern class WebGLBufferRenderer { 4 | function new(gl:js.html.webgl.RenderingContext, extensions:WebGLExtensions, info:WebGLInfo, capabilities:WebGLCapabilities); 5 | function setMode(value:Dynamic):Void; 6 | function render(start:Dynamic, count:Float):Void; 7 | function renderInstances(start:Dynamic, count:Float, primcount:Float):Void; 8 | static var prototype : WebGLBufferRenderer; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLCapabilities.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLCapabilities") extern class WebGLCapabilities { 4 | function new(gl:js.html.webgl.RenderingContext, extensions:Dynamic, parameters:WebGLCapabilitiesParameters); 5 | final isWebGL2 : Bool; 6 | var precision : String; 7 | var logarithmicDepthBuffer : Bool; 8 | var maxTextures : Float; 9 | var maxVertexTextures : Float; 10 | var maxTextureSize : Float; 11 | var maxCubemapSize : Float; 12 | var maxAttributes : Float; 13 | var maxVertexUniforms : Float; 14 | var maxVaryings : Float; 15 | var maxFragmentUniforms : Float; 16 | var vertexTextures : Bool; 17 | var floatFragmentTextures : Bool; 18 | var floatVertexTextures : Bool; 19 | function getMaxAnisotropy():Float; 20 | function getMaxPrecision(precision:String):String; 21 | static var prototype : WebGLCapabilities; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLCapabilitiesParameters.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef WebGLCapabilitiesParameters = { 4 | @:optional 5 | var precision : String; 6 | @:optional 7 | var logarithmicDepthBuffer : Bool; 8 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLClipping.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLClipping") extern class WebGLClipping { 4 | function new(properties:WebGLProperties); 5 | var uniform : { 6 | var value : Dynamic; 7 | var needsUpdate : Bool; 8 | }; 9 | var numPlanes : Float; 10 | var numIntersection : Float; 11 | function init(planes:Array, enableLocalClipping:Bool, camera:Camera):Bool; 12 | function beginShadows():Void; 13 | function endShadows():Void; 14 | function setState(material:Material, camera:Camera, useCache:Bool):Void; 15 | static var prototype : WebGLClipping; 16 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLColorBuffer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLColorBuffer") extern class WebGLColorBuffer { 4 | function new(); 5 | function setMask(colorMask:Bool):Void; 6 | function setLocked(lock:Bool):Void; 7 | function setClear(r:Float, g:Float, b:Float, a:Float, premultipliedAlpha:Bool):Void; 8 | function reset():Void; 9 | static var prototype : WebGLColorBuffer; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLCubeRenderTarget.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLCubeRenderTarget") extern class WebGLCubeRenderTarget extends WebGLRenderTarget { 4 | function new(size:Float, ?options:WebGLRenderTargetOptions); 5 | function fromEquirectangularTexture(renderer:WebGLRenderer, texture:Texture):WebGLCubeRenderTarget; 6 | function clear(renderer:WebGLRenderer, color:Bool, depth:Bool, stencil:Bool):Void; 7 | function clone():WebGLCubeRenderTarget; 8 | function copy(source:WebGLRenderTarget):WebGLCubeRenderTarget; 9 | /** 10 | Adds a listener to an event type. 11 | **/ 12 | function addEventListener(type:T, listener:EventListener):Void; 13 | /** 14 | Checks if listener is added to an event type. 15 | **/ 16 | function hasEventListener(type:T, listener:EventListener):Bool; 17 | /** 18 | Removes a listener from an event type. 19 | **/ 20 | function removeEventListener(type:T, listener:EventListener):Void; 21 | static var prototype : WebGLCubeRenderTarget; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLCubeUVMaps.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLCubeUVMaps") extern class WebGLCubeUVMaps { 4 | function new(renderer:WebGLRenderer); 5 | function get(texture:T):Dynamic; 6 | function dispose():Void; 7 | static var prototype : WebGLCubeUVMaps; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLDebug.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef WebGLDebug = { 4 | /** 5 | Enables error checking and reporting when shader programs are being compiled. 6 | **/ 7 | var checkShaderErrors : Bool; 8 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLDepthBuffer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLDepthBuffer") extern class WebGLDepthBuffer { 4 | function new(); 5 | function setTest(depthTest:Bool):Void; 6 | function setMask(depthMask:Bool):Void; 7 | function setFunc(depthFunc:DepthModes):Void; 8 | function setLocked(lock:Bool):Void; 9 | function setClear(depth:Float):Void; 10 | function reset():Void; 11 | static var prototype : WebGLDepthBuffer; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLExtensions.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLExtensions") extern class WebGLExtensions { 4 | function new(gl:js.html.webgl.RenderingContext); 5 | function has(name:String):Bool; 6 | function init(capabilities:WebGLCapabilities):Void; 7 | function get(name:String):Dynamic; 8 | static var prototype : WebGLExtensions; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLGeometries.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLGeometries") extern class WebGLGeometries { 4 | function new(gl:js.html.webgl.RenderingContext, attributes:three.src.renderers.webgl.webglattributes.WebGLAttributes, info:WebGLInfo); 5 | function get(object:Object3D, geometry:BufferGeometry):BufferGeometry; 6 | function update(geometry:BufferGeometry):Void; 7 | function getWireframeAttribute(geometry:BufferGeometry):BufferAttribute; 8 | static var prototype : WebGLGeometries; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLIndexedBufferRenderer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLIndexedBufferRenderer") extern class WebGLIndexedBufferRenderer { 4 | function new(gl:js.html.webgl.RenderingContext, extensions:Dynamic, info:Dynamic, capabilities:Dynamic); 5 | function setMode(value:Dynamic):Void; 6 | function setIndex(index:Dynamic):Void; 7 | function render(start:Dynamic, count:Float):Void; 8 | function renderInstances(start:Dynamic, count:Float, primcount:Float):Void; 9 | static var prototype : WebGLIndexedBufferRenderer; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLInfo.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | An object with a series of statistical information about the graphics board memory and the rendering process. 5 | **/ 6 | @:jsRequire("three", "WebGLInfo") extern class WebGLInfo { 7 | function new(gl:js.html.webgl.RenderingContext); 8 | var autoReset : Bool; 9 | var memory : { 10 | var geometries : Float; 11 | var textures : Float; 12 | }; 13 | var programs : Null>; 14 | var render : { 15 | var calls : Float; 16 | var frame : Float; 17 | var lines : Float; 18 | var points : Float; 19 | var triangles : Float; 20 | }; 21 | function update(count:Float, mode:Float, instanceCount:Float):Void; 22 | function reset():Void; 23 | static var prototype : WebGLInfo; 24 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLLights.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLLights") extern class WebGLLights { 4 | function new(extensions:WebGLExtensions, capabilities:WebGLCapabilities); 5 | var state : { 6 | var version : Float; 7 | var hash : { 8 | var directionalLength : Float; 9 | var pointLength : Float; 10 | var spotLength : Float; 11 | var rectAreaLength : Float; 12 | var hemiLength : Float; 13 | var numDirectionalShadows : Float; 14 | var numPointShadows : Float; 15 | var numSpotShadows : Float; 16 | }; 17 | var ambient : Array; 18 | var probe : Array; 19 | var directional : Array; 20 | var directionalShadow : Array; 21 | var directionalShadowMap : Array; 22 | var directionalShadowMatrix : Array; 23 | var spot : Array; 24 | var spotShadow : Array; 25 | var spotShadowMap : Array; 26 | var spotShadowMatrix : Array; 27 | var rectArea : Array; 28 | var point : Array; 29 | var pointShadow : Array; 30 | var pointShadowMap : Array; 31 | var pointShadowMatrix : Array; 32 | var hemi : Array; 33 | }; 34 | function get(light:Dynamic):Dynamic; 35 | function setup(lights:Dynamic):Void; 36 | function setupView(lights:Dynamic, camera:Dynamic):Void; 37 | static var prototype : WebGLLights; 38 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLMultipleRenderTargets.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | /** 4 | This class originall extended WebGLMultipleRenderTarget 5 | However, there are some issues with this method as documented below 6 | **/ 7 | @:jsRequire("three", "WebGLMultipleRenderTargets") extern class WebGLMultipleRenderTargets extends EventDispatcher { 8 | function new(width:Float, height:Float, count:Float); 9 | var texture : Array; 10 | final isWebGLMultipleRenderTargets : Bool; 11 | function setSize(width:Float, height:Float, ?depth:Float):WebGLMultipleRenderTargets; 12 | function copy(source:WebGLMultipleRenderTargets):WebGLMultipleRenderTargets; 13 | function clone():WebGLMultipleRenderTargets; 14 | function dispose():Void; 15 | function setTexture(texture:Texture):Void; 16 | /** 17 | Adds a listener to an event type. 18 | **/ 19 | function addEventListener(type:T, listener:EventListener):Void; 20 | /** 21 | Checks if listener is added to an event type. 22 | **/ 23 | function hasEventListener(type:T, listener:EventListener):Bool; 24 | /** 25 | Removes a listener from an event type. 26 | **/ 27 | function removeEventListener(type:T, listener:EventListener):Void; 28 | static var prototype : WebGLMultipleRenderTargets; 29 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLMultisampleRenderTarget.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLMultisampleRenderTarget") extern class WebGLMultisampleRenderTarget extends WebGLRenderTarget { 4 | function new(width:Float, height:Float, ?options:WebGLRenderTargetOptions); 5 | final isWebGLMultisampleRenderTarget : Bool; 6 | /** 7 | Specifies the number of samples to be used for the renderbuffer storage.However, the maximum supported size for multisampling is platform dependent and defined via gl.MAX_SAMPLES. 8 | **/ 9 | var samples : Float; 10 | function clone():WebGLMultisampleRenderTarget; 11 | function copy(source:WebGLRenderTarget):WebGLMultisampleRenderTarget; 12 | /** 13 | Adds a listener to an event type. 14 | **/ 15 | function addEventListener(type:T, listener:EventListener):Void; 16 | /** 17 | Checks if listener is added to an event type. 18 | **/ 19 | function hasEventListener(type:T, listener:EventListener):Bool; 20 | /** 21 | Removes a listener from an event type. 22 | **/ 23 | function removeEventListener(type:T, listener:EventListener):Void; 24 | static var prototype : WebGLMultisampleRenderTarget; 25 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLObjects.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLObjects") extern class WebGLObjects { 4 | function new(gl:js.html.webgl.RenderingContext, geometries:Dynamic, attributes:Dynamic, info:Dynamic); 5 | function update(object:Dynamic):Dynamic; 6 | function dispose():Void; 7 | static var prototype : WebGLObjects; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLProgram.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLProgram") extern class WebGLProgram { 4 | function new(renderer:WebGLRenderer, cacheKey:String, parameters:Dynamic); 5 | var name : String; 6 | var id : Float; 7 | var cacheKey : String; 8 | var usedTimes : Float; 9 | var program : Dynamic; 10 | var vertexShader : js.html.webgl.Shader; 11 | var fragmentShader : js.html.webgl.Shader; 12 | var uniforms : Dynamic; 13 | var attributes : Dynamic; 14 | function getUniforms():WebGLUniforms; 15 | function getAttributes():Dynamic; 16 | function destroy():Void; 17 | static var prototype : WebGLProgram; 18 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLPrograms.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLPrograms") extern class WebGLPrograms { 4 | function new(renderer:WebGLRenderer, cubemaps:three.src.renderers.webgl.webglcubemaps.WebGLCubeMaps, extensions:WebGLExtensions, capabilities:WebGLCapabilities, bindingStates:three.src.renderers.webgl.webglbindingstates.WebGLBindingStates, clipping:WebGLClipping); 5 | var programs : Array; 6 | function getParameters(material:Material, lights:Dynamic, shadows:Array, scene:Scene, object:Dynamic):Dynamic; 7 | function getProgramCacheKey(parameters:Dynamic):String; 8 | function getUniforms(material:Material):Dynamic; 9 | function acquireProgram(parameters:Dynamic, cacheKey:String):WebGLProgram; 10 | function releaseProgram(program:WebGLProgram):Void; 11 | static var prototype : WebGLPrograms; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLProperties.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLProperties") extern class WebGLProperties { 4 | function new(); 5 | function get(object:Dynamic):Dynamic; 6 | function remove(object:Dynamic):Void; 7 | function update(object:Dynamic, key:Dynamic, value:Dynamic):Dynamic; 8 | function dispose():Void; 9 | static var prototype : WebGLProperties; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLRenderList.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLRenderList") extern class WebGLRenderList { 4 | function new(properties:WebGLProperties); 5 | var opaque : Array; 6 | var transparent : Array; 7 | var transmissive : Array; 8 | function init():Void; 9 | function push(object:Object3D, geometry:Null, material:Material, groupOrder:Float, z:Float, group:Null):Void; 10 | function unshift(object:Object3D, geometry:Null, material:Material, groupOrder:Float, z:Float, group:Null):Void; 11 | function sort(opaqueSort:(a:Dynamic, b:Dynamic) -> Float, transparentSort:(a:Dynamic, b:Dynamic) -> Float):Void; 12 | function finish():Void; 13 | static var prototype : WebGLRenderList; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLRenderLists.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLRenderLists") extern class WebGLRenderLists { 4 | function new(properties:WebGLProperties); 5 | function dispose():Void; 6 | function get(scene:Scene, renderCallDepth:Float):WebGLRenderList; 7 | static var prototype : WebGLRenderLists; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLRenderTargetOptions.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef WebGLRenderTargetOptions = { 4 | @:optional 5 | var wrapS : Wrapping; 6 | @:optional 7 | var wrapT : Wrapping; 8 | @:optional 9 | var magFilter : TextureFilter; 10 | @:optional 11 | var minFilter : TextureFilter; 12 | @:optional 13 | var format : Float; 14 | @:optional 15 | var type : TextureDataType; 16 | @:optional 17 | var anisotropy : Float; 18 | @:optional 19 | var depthBuffer : Bool; 20 | @:optional 21 | var stencilBuffer : Bool; 22 | @:optional 23 | var generateMipmaps : Bool; 24 | @:optional 25 | var depthTexture : DepthTexture; 26 | @:optional 27 | var encoding : TextureEncoding; 28 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLRenderingContext.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef WebGLRenderingContext = { 4 | function makeXRCompatible():js.lib.Promise; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLShadowMap.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLShadowMap") extern class WebGLShadowMap { 4 | function new(_renderer:WebGLRenderer, _objects:WebGLObjects, _capabilities:WebGLCapabilities); 5 | var enabled : Bool; 6 | var autoUpdate : Bool; 7 | var needsUpdate : Bool; 8 | var type : ShadowMapType; 9 | function render(shadowsArray:Array, scene:Scene, camera:Camera):Void; 10 | var cullFace : Dynamic; 11 | static var prototype : WebGLShadowMap; 12 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLStencilBuffer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLStencilBuffer") extern class WebGLStencilBuffer { 4 | function new(); 5 | function setTest(stencilTest:Bool):Void; 6 | function setMask(stencilMask:Float):Void; 7 | function setFunc(stencilFunc:Float, stencilRef:Float, stencilMask:Float):Void; 8 | function setOp(stencilFail:Float, stencilZFail:Float, stencilZPass:Float):Void; 9 | function setLocked(lock:Bool):Void; 10 | function setClear(stencil:Float):Void; 11 | function reset():Void; 12 | static var prototype : WebGLStencilBuffer; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLTextures.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLTextures") extern class WebGLTextures { 4 | function new(gl:js.html.webgl.RenderingContext, extensions:WebGLExtensions, state:WebGLState, properties:WebGLProperties, capabilities:WebGLCapabilities, utils:three.src.renderers.webgl.webglutils.WebGLUtils, info:WebGLInfo); 5 | function allocateTextureUnit():Void; 6 | function resetTextureUnits():Void; 7 | function setTexture2D(texture:Dynamic, slot:Float):Void; 8 | function setTexture2DArray(texture:Dynamic, slot:Float):Void; 9 | function setTexture3D(texture:Dynamic, slot:Float):Void; 10 | function setTextureCube(texture:Dynamic, slot:Float):Void; 11 | function setupRenderTarget(renderTarget:Dynamic):Void; 12 | function updateRenderTargetMipmap(renderTarget:Dynamic):Void; 13 | function updateMultisampleRenderTarget(renderTarget:Dynamic):Void; 14 | function safeSetTexture2D(texture:Dynamic, slot:Float):Void; 15 | function safeSetTextureCube(texture:Dynamic, slot:Float):Void; 16 | static var prototype : WebGLTextures; 17 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebGLUniforms.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebGLUniforms") extern class WebGLUniforms { 4 | function new(gl:js.html.webgl.RenderingContext, program:WebGLProgram); 5 | function setValue(gl:js.html.webgl.RenderingContext, name:String, value:Dynamic, textures:WebGLTextures):Void; 6 | function setOptional(gl:js.html.webgl.RenderingContext, object:Dynamic, name:String):Void; 7 | static var prototype : WebGLUniforms; 8 | static function upload(gl:js.html.webgl.RenderingContext, seq:Dynamic, values:Array, textures:WebGLTextures):Void; 9 | static function seqWithValue(seq:Dynamic, values:Array):Array; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WebXRController.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WebXRController") extern class WebXRController { 4 | function new(); 5 | function getTargetRaySpace():Group; 6 | function getGripSpace():Group; 7 | function dispatchEvent(event:{ var type : XRControllerEventType; @:optional var data : XRInputSource; }):WebXRController; 8 | function disconnect(inputSource:XRInputSource):WebXRController; 9 | function update(inputSource:XRInputSource, frame:XRFrame, referenceSpace:XRReferenceSpace):WebXRController; 10 | static var prototype : WebXRController; 11 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Window.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef Window = { 4 | @:optional 5 | var XRSession : Constructor; 6 | @:optional 7 | var XR : Constructor; 8 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/WireframeGeometry.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "WireframeGeometry") extern class WireframeGeometry extends BufferGeometry { 4 | function new(?geometry:TBufferGeometry); 5 | var parameters : { 6 | var geometry : TBufferGeometry; 7 | }; 8 | function copy(source:BufferGeometry):WireframeGeometry; 9 | /** 10 | Adds a listener to an event type. 11 | **/ 12 | function addEventListener(type:T, listener:EventListener>):Void; 13 | /** 14 | Checks if listener is added to an event type. 15 | **/ 16 | function hasEventListener(type:T, listener:EventListener>):Bool; 17 | /** 18 | Removes a listener from an event type. 19 | **/ 20 | function removeEventListener(type:T, listener:EventListener>):Void; 21 | static var prototype : WireframeGeometry; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/Wrapping.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:enum @:jsRequire("three") extern abstract Wrapping(Int) from Int to Int { 4 | final RepeatWrapping : Wrapping; 5 | final ClampToEdgeWrapping : Wrapping; 6 | final MirroredRepeatWrapping : Wrapping; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRAnchor.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRAnchor = { 4 | var anchorSpace : js.html.EventTarget; 5 | function delete():Void; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRAnchorSet.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRAnchorSet = js.lib.Set; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRAnimationLoopCallback.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRAnimationLoopCallback = ts.AnyOf2<(time:Float) -> Void, (time:Float, frame:XRFrame) -> Void>; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRControllerEventType.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRControllerEventType = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XREnvironmentBlendMode.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XREnvironmentBlendMode = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XREventType.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XREventType = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XREye.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XREye = XRHandedness; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRFrame.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRFrame = { 4 | final session : XRSession; 5 | function getViewerPose(referenceSpace:XRReferenceSpace):Null; 6 | function getPose(space:js.html.EventTarget, baseSpace:js.html.EventTarget):Null; 7 | function getHitTestResults(hitTestSource:XRHitTestSource):Array; 8 | function getHitTestResultsForTransientInput(hitTestSource:XRTransientInputHitTestSource):Array; 9 | @:optional 10 | var trackedAnchors : XRAnchorSet; 11 | function createAnchor(pose:XRRigidTransform, space:js.html.EventTarget):js.lib.Promise; 12 | var worldInformation : { 13 | @:optional 14 | var detectedPlanes : XRPlaneSet; 15 | }; 16 | function getJointPose(joint:XRJointSpace, baseSpace:js.html.EventTarget):XRJointPose; 17 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRFrameRequestCallback.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRFrameRequestCallback = (time:Float, frame:XRFrame) -> Void; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRGamepad.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRGamepad = { 4 | final id : String; 5 | final index : Float; 6 | final connected : Bool; 7 | final timestamp : Float; 8 | final mapping : js.html.GamepadMappingType; 9 | final axes : js.lib.Float32Array; 10 | final buttons : Array; 11 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRHand.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRHand = { 4 | final size : Float; 5 | function clear():Void; 6 | function delete(key:XRHandJoint):Bool; 7 | function forEach(callbackfn:(value:XRJointSpace, key:XRHandJoint, map:js.lib.Map) -> Void, ?thisArg:Dynamic):Void; 8 | function get(key:XRHandJoint):Null; 9 | function has(key:XRHandJoint):Bool; 10 | function set(key:XRHandJoint, value:XRJointSpace):XRHand; 11 | /** 12 | Returns an iterable of key, value pairs for every entry in the map. 13 | **/ 14 | function entries():js.lib.IterableIterator>; 15 | /** 16 | Returns an iterable of keys in the map 17 | **/ 18 | function keys():js.lib.IterableIterator; 19 | /** 20 | Returns an iterable of values in the map 21 | **/ 22 | function values():js.lib.IterableIterator; 23 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRHandedness.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRHandedness = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRHitResult.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRHitResult = { 4 | var hitMatrix : js.lib.Float32Array; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRHitTestOptionsInit.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRHitTestOptionsInit = { 4 | var space : js.html.EventTarget; 5 | @:optional 6 | var offsetRay : XRRay; 7 | @:optional 8 | var entityTypes : Array; 9 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRHitTestResult.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRHitTestResult = { 4 | function getPose(baseSpace:js.html.EventTarget):Null; 5 | @:optional 6 | function createAnchor(pose:XRRigidTransform):js.lib.Promise; 7 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRHitTestSource.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRHitTestSource = { 4 | function cancel():Void; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRHitTestTrackableType.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "XRHitTestTrackableType") @:enum extern abstract XRHitTestTrackableType(Int) from Int to Int { 4 | var point; 5 | var plane; 6 | var mesh; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRInputSource.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRInputSource = { 4 | final handedness : XRHandedness; 5 | final targetRayMode : XRTargetRayMode; 6 | final targetRaySpace : js.html.EventTarget; 7 | @:optional 8 | final gripSpace : js.html.EventTarget; 9 | final profiles : Array; 10 | final gamepad : XRGamepad; 11 | @:optional 12 | final hand : XRHand; 13 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRInputSourceChangeEvent.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRInputSourceChangeEvent = { 4 | var session : XRSession; 5 | var removed : Array; 6 | var added : Array; 7 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRJointPose.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRJointPose = { 4 | final radius : Null; 5 | final emulatedPosition : Bool; 6 | final transform : XRRigidTransform; 7 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRPlane.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRPlane = { 4 | var orientation : String; 5 | var planeSpace : js.html.EventTarget; 6 | var polygon : Array; 7 | var lastChangedTime : Float; 8 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRPlaneSet.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRPlaneSet = js.lib.Set; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRPose.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRPose = { 4 | final emulatedPosition : Bool; 5 | final transform : XRRigidTransform; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRRay.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "XRRay") extern class XRRay { 4 | function new(transformOrOrigin:ts.AnyOf2, ?direction:XRRayDirectionInit); 5 | final origin : js.html.DOMPointReadOnly; 6 | final direction : XRRayDirectionInit; 7 | var matrix : js.lib.Float32Array; 8 | static var prototype : XRRay; 9 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRRayDirectionInit.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRRayDirectionInit = { 4 | @:optional 5 | var x : Float; 6 | @:optional 7 | var y : Float; 8 | @:optional 9 | var z : Float; 10 | @:optional 11 | var w : Float; 12 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRReferenceSpaceType.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRReferenceSpaceType = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRRenderState.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRRenderState = { 4 | final depthNear : Float; 5 | final depthFar : Float; 6 | @:optional 7 | final inlineVerticalFieldOfView : Float; 8 | @:optional 9 | final baseLayer : XRWebGLLayer; 10 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRRenderStateInit.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRRenderStateInit = { 4 | @:optional 5 | var depthNear : Float; 6 | @:optional 7 | var depthFar : Float; 8 | @:optional 9 | var inlineVerticalFieldOfView : Float; 10 | @:optional 11 | var baseLayer : XRWebGLLayer; 12 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRRigidTransform.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "XRRigidTransform") extern class XRRigidTransform { 4 | function new(matrix:ts.AnyOf2, ?direction:DOMPointInit); 5 | var position : js.html.DOMPointReadOnly; 6 | var orientation : js.html.DOMPointReadOnly; 7 | var matrix : js.lib.Float32Array; 8 | var inverse : XRRigidTransform; 9 | static var prototype : XRRigidTransform; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRSessionInit.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRSessionInit = { 4 | @:optional 5 | var optionalFeatures : Array; 6 | @:optional 7 | var requiredFeatures : Array; 8 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRSessionMode.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRSessionMode = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRTargetRayMode.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRTargetRayMode = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRTransientInputHitTestOptionsInit.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRTransientInputHitTestOptionsInit = { 4 | var profile : String; 5 | @:optional 6 | var offsetRay : XRRay; 7 | @:optional 8 | var entityTypes : Array; 9 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRTransientInputHitTestResult.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRTransientInputHitTestResult = { 4 | final inputSource : XRInputSource; 5 | final results : Array; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRTransientInputHitTestSource.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRTransientInputHitTestSource = { 4 | function cancel():Void; 5 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRView.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRView = { 4 | final eye : XRHandedness; 5 | final projectionMatrix : js.lib.Float32Array; 6 | final viewMatrix : js.lib.Float32Array; 7 | final transform : XRRigidTransform; 8 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRViewerPose.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRViewerPose = { 4 | final transform : XRRigidTransform; 5 | final views : Array; 6 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRViewport.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRViewport = { 4 | final x : Float; 5 | final y : Float; 6 | final width : Float; 7 | final height : Float; 8 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRVisibilityState.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRVisibilityState = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRWebGLLayer.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | @:jsRequire("three", "XRWebGLLayer") extern class XRWebGLLayer { 4 | function new(session:XRSession, gl:Null, ?options:XRWebGLLayerInit); 5 | var framebuffer : js.html.webgl.Framebuffer; 6 | var framebufferWidth : Float; 7 | var framebufferHeight : Float; 8 | function getViewport(view:XRView):XRViewport; 9 | static var prototype : XRWebGLLayer; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/XRWebGLLayerInit.hx: -------------------------------------------------------------------------------- 1 | package three; 2 | 3 | typedef XRWebGLLayerInit = { 4 | @:optional 5 | var antialias : Bool; 6 | @:optional 7 | var depth : Bool; 8 | @:optional 9 | var stencil : Bool; 10 | @:optional 11 | var alpha : Bool; 12 | @:optional 13 | var ignoreDepthValues : Bool; 14 | @:optional 15 | var framebufferScaleFactor : Float; 16 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/examples/jsm/loaders/dracoloader/DRACOLoader.hx: -------------------------------------------------------------------------------- 1 | package three.examples.jsm.loaders.dracoloader; 2 | 3 | @:jsRequire("three/examples/jsm/loaders/DRACOLoader", "DRACOLoader") extern class DRACOLoader extends three.Loader { 4 | function new(?manager:three.LoadingManager); 5 | function load(url:String, onLoad:(geometry:three.BufferGeometry) -> Void, ?onProgress:(event:js.html.ProgressEvent_) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):Void; 6 | function loadAsync(url:String, ?onProgress:(event:js.html.ProgressEvent_) -> Void):js.lib.Promise; 7 | function setDecoderPath(path:String):DRACOLoader; 8 | function setDecoderConfig(config:Dynamic):DRACOLoader; 9 | function setWorkerLimit(workerLimit:Float):DRACOLoader; 10 | function preload():DRACOLoader; 11 | function dispose():DRACOLoader; 12 | function setCrossOrigin(crossOrigin:String):DRACOLoader; 13 | function setWithCredentials(value:Bool):DRACOLoader; 14 | function setPath(path:String):DRACOLoader; 15 | function setResourcePath(resourcePath:String):DRACOLoader; 16 | function setRequestHeader(requestHeader:{ }):DRACOLoader; 17 | static var prototype : DRACOLoader; 18 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/examples/jsm/loaders/gltfloader/GLTF.hx: -------------------------------------------------------------------------------- 1 | package three.examples.jsm.loaders.gltfloader; 2 | 3 | typedef GLTF = { 4 | var animations : Array; 5 | var scene : three.Group; 6 | var scenes : Array; 7 | var cameras : Array; 8 | var asset : { 9 | @:optional 10 | var copyright : String; 11 | @:optional 12 | var generator : String; 13 | @:optional 14 | var version : String; 15 | @:optional 16 | var minVersion : String; 17 | @:optional 18 | var extensions : Dynamic; 19 | @:optional 20 | var extras : Dynamic; 21 | }; 22 | var parser : GLTFParser; 23 | var userData : Dynamic; 24 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/examples/jsm/loaders/gltfloader/GLTFReference.hx: -------------------------------------------------------------------------------- 1 | package three.examples.jsm.loaders.gltfloader; 2 | 3 | typedef GLTFReference = { 4 | @:optional 5 | var materials : Float; 6 | @:optional 7 | var nodes : Float; 8 | @:optional 9 | var textures : Float; 10 | @:optional 11 | var meshes : Float; 12 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/examples/jsm/loaders/gltfloader/GLTFReferenceType.hx: -------------------------------------------------------------------------------- 1 | package three.examples.jsm.loaders.gltfloader; 2 | 3 | typedef GLTFReferenceType = String; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/examples/jsm/loaders/ktx2loader/KTX2Loader.hx: -------------------------------------------------------------------------------- 1 | package three.examples.jsm.loaders.ktx2loader; 2 | 3 | @:jsRequire("three/examples/jsm/loaders/KTX2Loader", "KTX2Loader") extern class KTX2Loader extends three.CompressedTextureLoader { 4 | function new(?manager:three.LoadingManager); 5 | function setTranscoderPath(path:String):KTX2Loader; 6 | function setWorkerLimit(limit:Float):KTX2Loader; 7 | function detectSupport(renderer:three.WebGLRenderer):KTX2Loader; 8 | function dispose():KTX2Loader; 9 | function parse(buffer:js.lib.ArrayBuffer, onLoad:(texture:three.CompressedTexture) -> Void, ?onError:(event:js.html.ErrorEvent) -> Void):KTX2Loader; 10 | function setCrossOrigin(crossOrigin:String):KTX2Loader; 11 | function setWithCredentials(value:Bool):KTX2Loader; 12 | function setPath(path:String):KTX2Loader; 13 | function setResourcePath(resourcePath:String):KTX2Loader; 14 | function setRequestHeader(requestHeader:{ }):KTX2Loader; 15 | static var prototype : KTX2Loader; 16 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/examples/jsm/loaders/rgbeloader/RGBE.hx: -------------------------------------------------------------------------------- 1 | package three.examples.jsm.loaders.rgbeloader; 2 | 3 | typedef RGBE = { 4 | var width : Float; 5 | var height : Float; 6 | var data : ts.AnyOf2; 7 | var header : String; 8 | var gamma : Float; 9 | var exposure : Float; 10 | var format : three.PixelFormat; 11 | var type : three.TextureDataType; 12 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/examples/jsm/loaders/rgbeloader/RGBELoader.hx: -------------------------------------------------------------------------------- 1 | package three.examples.jsm.loaders.rgbeloader; 2 | 3 | @:jsRequire("three/examples/jsm/loaders/RGBELoader", "RGBELoader") extern class RGBELoader extends three.DataTextureLoader { 4 | function new(?manager:three.LoadingManager); 5 | var type : three.TextureDataType; 6 | function parse(buffer:js.lib.ArrayBuffer):RGBE; 7 | function setDataType(type:three.TextureDataType):RGBELoader; 8 | function setCrossOrigin(crossOrigin:String):RGBELoader; 9 | function setWithCredentials(value:Bool):RGBELoader; 10 | function setPath(path:String):RGBELoader; 11 | function setResourcePath(resourcePath:String):RGBELoader; 12 | function setRequestHeader(requestHeader:{ }):RGBELoader; 13 | static var prototype : RGBELoader; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/examples/jsm/objects/reflector/ReflectorOptions.hx: -------------------------------------------------------------------------------- 1 | package three.examples.jsm.objects.reflector; 2 | 3 | typedef ReflectorOptions = { 4 | @:optional 5 | var color : three.ColorRepresentation; 6 | @:optional 7 | var textureWidth : Float; 8 | @:optional 9 | var textureHeight : Float; 10 | @:optional 11 | var clipBias : Float; 12 | @:optional 13 | var shader : Dynamic; 14 | @:optional 15 | var encoding : three.TextureEncoding; 16 | }; -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/propertybinding/Composite.hx: -------------------------------------------------------------------------------- 1 | package three.propertybinding; 2 | 3 | @:jsRequire("three", "PropertyBinding.Composite") extern class Composite { 4 | function new(targetGroup:Dynamic, path:Dynamic, ?parsedPath:Dynamic); 5 | function getValue(array:Dynamic, offset:Float):Dynamic; 6 | function setValue(array:Dynamic, offset:Float):Void; 7 | function bind():Void; 8 | function unbind():Void; 9 | static var prototype : Composite; 10 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/loaders/LoaderUtils.hx: -------------------------------------------------------------------------------- 1 | package three.src.loaders; 2 | 3 | @:jsRequire("three/src/loaders/LoaderUtils") @valueModuleOnly extern class LoaderUtils { 4 | static final LoaderUtils : three.LoaderUtils; 5 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/loaders/LoadingManager.hx: -------------------------------------------------------------------------------- 1 | package three.src.loaders; 2 | 3 | @:jsRequire("three/src/loaders/LoadingManager") @valueModuleOnly extern class LoadingManager { 4 | static final DefaultLoadingManager : three.LoadingManager; 5 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/objects/LineSegments.hx: -------------------------------------------------------------------------------- 1 | package three.src.objects; 2 | 3 | @:jsRequire("three/src/objects/LineSegments") @valueModuleOnly extern class LineSegments { 4 | static final LineStrip : Float; 5 | static final LinePieces : Float; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/renderers/shaders/ShaderLib.hx: -------------------------------------------------------------------------------- 1 | package three.src.renderers.shaders; 2 | 3 | @:jsRequire("three/src/renderers/shaders/ShaderLib") @valueModuleOnly extern class ShaderLib { 4 | static var ShaderLib : { 5 | var basic : three.Shader; 6 | var lambert : three.Shader; 7 | var phong : three.Shader; 8 | var standard : three.Shader; 9 | var matcap : three.Shader; 10 | var points : three.Shader; 11 | var dashed : three.Shader; 12 | var depth : three.Shader; 13 | var normal : three.Shader; 14 | var sprite : three.Shader; 15 | var background : three.Shader; 16 | var cube : three.Shader; 17 | var equirect : three.Shader; 18 | var distanceRGBA : three.Shader; 19 | var shadow : three.Shader; 20 | var physical : three.Shader; 21 | }; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/renderers/shaders/UniformsUtils.hx: -------------------------------------------------------------------------------- 1 | package three.src.renderers.shaders; 2 | 3 | @:jsRequire("three/src/renderers/shaders/UniformsUtils") @valueModuleOnly extern class UniformsUtils { 4 | static function cloneUniforms(uniforms_src:Dynamic):Dynamic; 5 | static function mergeUniforms(uniforms:Array):Dynamic; 6 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/renderers/webgl/WebGLShader.hx: -------------------------------------------------------------------------------- 1 | package three.src.renderers.webgl; 2 | 3 | @:jsRequire("three/src/renderers/webgl/WebGLShader") @valueModuleOnly extern class WebGLShader { 4 | static function WebGLShader(gl:js.html.webgl.RenderingContext, type:String, string:String):js.html.webgl.Shader; 5 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/renderers/webgl/webglattributes/WebGLAttributes.hx: -------------------------------------------------------------------------------- 1 | package three.src.renderers.webgl.webglattributes; 2 | 3 | @:jsRequire("three/src/renderers/webgl/WebGLAttributes", "WebGLAttributes") extern class WebGLAttributes { 4 | function new(gl:ts.AnyOf2, capabilities:three.WebGLCapabilities); 5 | function get(attribute:ts.AnyOf2):{ 6 | var buffer : js.html.webgl.Buffer; 7 | var type : Float; 8 | var bytesPerElement : Float; 9 | var version : Float; 10 | }; 11 | function remove(attribute:ts.AnyOf2):Void; 12 | function update(attribute:ts.AnyOf2, bufferType:Float):Void; 13 | static var prototype : WebGLAttributes; 14 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/renderers/webgl/webglbindingstates/WebGLBindingStates.hx: -------------------------------------------------------------------------------- 1 | package three.src.renderers.webgl.webglbindingstates; 2 | 3 | @:jsRequire("three/src/renderers/webgl/WebGLBindingStates", "WebGLBindingStates") extern class WebGLBindingStates { 4 | function new(gl:js.html.webgl.RenderingContext, extensions:three.WebGLExtensions, attributes:three.src.renderers.webgl.webglattributes.WebGLAttributes, capabilities:three.WebGLCapabilities); 5 | function setup(object:three.Object3D, material:three.Material, program:three.WebGLProgram, geometry:three.BufferGeometry, index:three.BufferAttribute):Void; 6 | function reset():Void; 7 | function resetDefaultState():Void; 8 | function dispose():Void; 9 | function releaseStatesOfGeometry():Void; 10 | function releaseStatesOfProgram():Void; 11 | function initAttributes():Void; 12 | function enableAttribute(attribute:Float):Void; 13 | function disableUnusedAttributes():Void; 14 | static var prototype : WebGLBindingStates; 15 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/renderers/webgl/webglcubemaps/WebGLCubeMaps.hx: -------------------------------------------------------------------------------- 1 | package three.src.renderers.webgl.webglcubemaps; 2 | 3 | @:jsRequire("three/src/renderers/webgl/WebGLCubeMaps", "WebGLCubeMaps") extern class WebGLCubeMaps { 4 | function new(renderer:three.WebGLRenderer); 5 | function get(texture:Dynamic):Dynamic; 6 | function dispose():Void; 7 | static var prototype : WebGLCubeMaps; 8 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/three/src/renderers/webgl/webglutils/WebGLUtils.hx: -------------------------------------------------------------------------------- 1 | package three.src.renderers.webgl.webglutils; 2 | 3 | @:jsRequire("three/src/renderers/webgl/WebGLUtils", "WebGLUtils") extern class WebGLUtils { 4 | function new(gl:ts.AnyOf2, extensions:Dynamic, capabilities:Dynamic); 5 | function convert(p:Dynamic):Void; 6 | static var prototype : WebGLUtils; 7 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/ts/AnyOf2.hx: -------------------------------------------------------------------------------- 1 | package ts; 2 | 3 | /** 4 | AnyOf implementation generated by dts2hx 5 | **/ 6 | @:transitive extern abstract AnyOf2(Dynamic) from T0 from T1 to T0 to T1 { 7 | var asType0(get, never) : T0; 8 | private inline function get_asType0():T0 return this; 9 | var asType1(get, never) : T1; 10 | private inline function get_asType1():T1 return this; 11 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/ts/AnyOf3.hx: -------------------------------------------------------------------------------- 1 | package ts; 2 | 3 | /** 4 | AnyOf implementation generated by dts2hx 5 | **/ 6 | @:transitive extern abstract AnyOf3(Dynamic) from T0 from T1 from T2 to T0 to T1 to T2 { 7 | var asType0(get, never) : T0; 8 | private inline function get_asType0():T0 return this; 9 | var asType1(get, never) : T1; 10 | private inline function get_asType1():T1 return this; 11 | var asType2(get, never) : T2; 12 | private inline function get_asType2():T2 return this; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/ts/AnyOf4.hx: -------------------------------------------------------------------------------- 1 | package ts; 2 | 3 | /** 4 | AnyOf implementation generated by dts2hx 5 | **/ 6 | @:transitive extern abstract AnyOf4(Dynamic) from T0 from T1 from T2 from T3 to T0 to T1 to T2 to T3 { 7 | var asType0(get, never) : T0; 8 | private inline function get_asType0():T0 return this; 9 | var asType1(get, never) : T1; 10 | private inline function get_asType1():T1 return this; 11 | var asType2(get, never) : T2; 12 | private inline function get_asType2():T2 return this; 13 | var asType3(get, never) : T3; 14 | private inline function get_asType3():T3 return this; 15 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/ts/Tuple1.hx: -------------------------------------------------------------------------------- 1 | package ts; 2 | 3 | /** 4 | Tuple type implementation generated by dts2hx 5 | **/ 6 | @:forward @:forwardStatics extern abstract Tuple1(std.Array) from std.Array to std.Array { 7 | public inline function new(element0:T0) { 8 | this = [element0]; 9 | } 10 | public var element0(get, set) : T0; 11 | inline function get_element0():T0 return cast this[0]; 12 | inline function set_element0(v:T0):T0 return cast this[0] = cast v; 13 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/ts/Tuple2.hx: -------------------------------------------------------------------------------- 1 | package ts; 2 | 3 | /** 4 | Tuple type implementation generated by dts2hx 5 | **/ 6 | @:forward @:forwardStatics extern abstract Tuple2(std.Array) from std.Array to std.Array { 7 | public inline function new(element0:T0, element1:T1) { 8 | this = [element0, element1]; 9 | } 10 | public var element0(get, set) : T0; 11 | inline function get_element0():T0 return cast this[0]; 12 | inline function set_element0(v:T0):T0 return cast this[0] = cast v; 13 | public var element1(get, set) : T1; 14 | inline function get_element1():T1 return cast this[1]; 15 | inline function set_element1(v:T1):T1 return cast this[1] = cast v; 16 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/ts/Tuple3.hx: -------------------------------------------------------------------------------- 1 | package ts; 2 | 3 | /** 4 | Tuple type implementation generated by dts2hx 5 | **/ 6 | @:forward @:forwardStatics extern abstract Tuple3(std.Array) from std.Array to std.Array { 7 | public inline function new(element0:T0, element1:T1, element2:T2) { 8 | this = [element0, element1, element2]; 9 | } 10 | public var element0(get, set) : T0; 11 | inline function get_element0():T0 return cast this[0]; 12 | inline function set_element0(v:T0):T0 return cast this[0] = cast v; 13 | public var element1(get, set) : T1; 14 | inline function get_element1():T1 return cast this[1]; 15 | inline function set_element1(v:T1):T1 return cast this[1] = cast v; 16 | public var element2(get, set) : T2; 17 | inline function get_element2():T2 return cast this[2]; 18 | inline function set_element2(v:T2):T2 return cast this[2] = cast v; 19 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/ts/Tuple4.hx: -------------------------------------------------------------------------------- 1 | package ts; 2 | 3 | /** 4 | Tuple type implementation generated by dts2hx 5 | **/ 6 | @:forward @:forwardStatics extern abstract Tuple4(std.Array) from std.Array to std.Array { 7 | public inline function new(element0:T0, element1:T1, element2:T2, element3:T3) { 8 | this = [element0, element1, element2, element3]; 9 | } 10 | public var element0(get, set) : T0; 11 | inline function get_element0():T0 return cast this[0]; 12 | inline function set_element0(v:T0):T0 return cast this[0] = cast v; 13 | public var element1(get, set) : T1; 14 | inline function get_element1():T1 return cast this[1]; 15 | inline function set_element1(v:T1):T1 return cast this[1] = cast v; 16 | public var element2(get, set) : T2; 17 | inline function get_element2():T2 return cast this[2]; 18 | inline function set_element2(v:T2):T2 return cast this[2] = cast v; 19 | public var element3(get, set) : T3; 20 | inline function get_element3():T3 return cast this[3]; 21 | inline function set_element3(v:T3):T3 return cast this[3] = cast v; 22 | } -------------------------------------------------------------------------------- /.haxelib/three/0,135,0/ts/Undefined.hx: -------------------------------------------------------------------------------- 1 | package ts; 2 | 3 | /** 4 | `Undefined` corresponds to `void` in TypeScript; in haxe `Void` cannot be used as a field type (only function return) so we must use `Any` instead. This alias serves as documentation that the type is `void` and therefore value is `undefined` 5 | **/ 6 | typedef Undefined = Any; -------------------------------------------------------------------------------- /.haxelib/vector-math/.current: -------------------------------------------------------------------------------- 1 | 2.4.0 -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 George Corney 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "vector-math", 3 | "description": "vector math implementation that enables GLSL vector and matrix operations to compile in haxe. Usage: `import VectorMath;`", 4 | "license": "MIT", 5 | "tags": ["vector", "math", "linear-algebra", "linear", "algebra", "matrix", "opengl", "glsl", "shader"], 6 | "contributors": ["haxiomic"], 7 | "url": "https://github.com/haxiomic/vector-math", 8 | "version": "2.4.0", 9 | "releasenote": " No longer clone() when accessing array columns and add fromArray functions to matrix types" 10 | } -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/test/.gitignore: -------------------------------------------------------------------------------- 1 | dist -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/test/each.hxml: -------------------------------------------------------------------------------- 1 | --class-path ../ 2 | --main Main 3 | 4 | -D vector_math_f32 5 | --dce full 6 | 7 | # this is too good – most tests run at compiletime! 8 | # -D analyzer-optimize -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/test/test-all.hxml: -------------------------------------------------------------------------------- 1 | # Eval 2 | test-eval.hxml 3 | 4 | # JavaScript 5 | --next 6 | test-js.hxml 7 | 8 | # C++ 9 | --next 10 | test-cpp.hxml 11 | 12 | # HashLink (requires hl jit installed on system to run) 13 | --next 14 | test-hl.hxml 15 | 16 | --next 17 | test-hlc.hxml -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/test/test-cpp.hxml: -------------------------------------------------------------------------------- 1 | each.hxml 2 | 3 | --cpp dist/cpp 4 | --cmd dist/cpp/Main -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/test/test-eval.hxml: -------------------------------------------------------------------------------- 1 | each.hxml 2 | 3 | --interp -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/test/test-hl.hxml: -------------------------------------------------------------------------------- 1 | each.hxml 2 | 3 | --hl dist/main.hl 4 | --cmd hl dist/main.hl -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/test/test-hlc.hxml: -------------------------------------------------------------------------------- 1 | each.hxml 2 | 3 | --hl dist/hlc/main.c 4 | --cmd gcc -O3 -o dist/main-hlc -std=c11 -I dist/hlc dist/hlc/main.c -lhl 5 | --cmd dist/main-hlc -------------------------------------------------------------------------------- /.haxelib/vector-math/2,4,0/test/test-js.hxml: -------------------------------------------------------------------------------- 1 | each.hxml 2 | 3 | -D nodejs 4 | --js dist/main.js 5 | --cmd node dist/main.js -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "triggerTaskOnSave.tasks": { 3 | "haxe": [ 4 | "*.glsl", 5 | "*.hx", 6 | "*.hxml", 7 | ] 8 | }, 9 | "triggerTaskOnSave.selectedTask": "haxe: active configuration", 10 | } -------------------------------------------------------------------------------- /.vscode/tasks.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "2.0.0", 3 | "tasks": [ 4 | { 5 | "type": "haxe", 6 | "args": "active configuration", 7 | "problemMatcher": [ 8 | "$haxe-absolute", 9 | "$haxe", 10 | "$haxe-error", 11 | "$haxe-trace" 12 | ], 13 | "group": { 14 | "kind": "build", 15 | "isDefault": true 16 | }, 17 | "label": "haxe: active configuration" 18 | } 19 | ] 20 | } -------------------------------------------------------------------------------- /assets/env/README.md: -------------------------------------------------------------------------------- 1 | # HDR Environment Maps 2 | source: [polyhaven.com/hdris](https://polyhaven.com/hdris) 3 | 4 | ## What are rgbd.png files? 5 | When three.js loads a .hdr file, it first processes it for efficient rendering – it creates a mipchain of smaller resolutions and converts the 32-bit float data into 8-bit rgb and a scale factor in the alpha channel: [rgbd explained](https://lousodrome.net/blog/light/tag/rgbd/). 6 | 7 | The resulting data is much smaller than the original hdr file. For faster load times I extract this data into pngs and load those instead, this saves load-time and processing-time without quality loss 8 | 9 | You can see how to use these pngs here: [EnvironmentManager.hx](https://github.com/haxiomic/three-toolkit/blob/30a6b941beb033e28db800a0fd5a564bf1bcaa45/environment/EnvironmentManager.hx#L76) -------------------------------------------------------------------------------- /assets/env/birchwood_2k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/birchwood_2k.rgbd.png -------------------------------------------------------------------------------- /assets/env/blouberg_sunrise_1_2k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/blouberg_sunrise_1_2k.rgbd.png -------------------------------------------------------------------------------- /assets/env/hilly_terrain_01_1k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/hilly_terrain_01_1k.rgbd.png -------------------------------------------------------------------------------- /assets/env/kiara_1_dawn_2k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/kiara_1_dawn_2k.rgbd.png -------------------------------------------------------------------------------- /assets/env/night_bridge_2k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/night_bridge_2k.rgbd.png -------------------------------------------------------------------------------- /assets/env/snowy_forest_path_01_1k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/snowy_forest_path_01_1k.rgbd.png -------------------------------------------------------------------------------- /assets/env/snowy_park_01_1k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/snowy_park_01_1k.rgbd.png -------------------------------------------------------------------------------- /assets/env/the_sky_is_on_fire_2k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/the_sky_is_on_fire_2k.rgbd.png -------------------------------------------------------------------------------- /assets/env/venice_sunset_2k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/venice_sunset_2k.rgbd.png -------------------------------------------------------------------------------- /assets/env/winter_lake_01_1k.rgbd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/assets/env/winter_lake_01_1k.rgbd.png -------------------------------------------------------------------------------- /build.hxml: -------------------------------------------------------------------------------- 1 | --main Main 2 | 3 | --class-path src 4 | --library three 5 | --library three-toolkit 6 | 7 | --js bin/app.js 8 | 9 | # optimization settings 10 | --dce full 11 | -D analyzer-optimize 12 | 13 | # generate ES6 output 14 | -D js-es=6 15 | 16 | # this bundles three.js into the output (only required because we are using three.js) 17 | --cmd npx esbuild bin/app.js --bundle --outfile=bin/bundle.js --minify --sourcemap -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 16 | 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "haxe-three-template", 3 | "version": "1.0.0", 4 | "description": "", 5 | "main": "index.js", 6 | "scripts": { 7 | "start": "haxe build.hxml && dead-server --watch=\"*.html,bin/bundle.js,assets\" .", 8 | "externs": "dts2hx three three/examples/jsm/loaders/RGBELoader three/examples/jsm/loaders/GLTFLoader three/examples/jsm/objects/Reflector -m" 9 | }, 10 | "keywords": [], 11 | "author": "", 12 | "license": "ISC", 13 | "dependencies": { 14 | "dat.gui": "^0.7.7", 15 | "esbuild": "^0.14.2", 16 | "three": "^0.135.0" 17 | }, 18 | "devDependencies": { 19 | "dead-server": "^1.0.4", 20 | "@types/dat.gui": "^0.7.7", 21 | "@types/three": "^0.135.0", 22 | "dts2hx": "^0.18.1" 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/haxe-logo.glb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haxiomic/haxe-threejs-template/df323cebe49baa9886747bdca79536f0550f9166/src/haxe-logo.glb -------------------------------------------------------------------------------- /src/import.hx: -------------------------------------------------------------------------------- 1 | // importing modules in import.hx enables these modules in all files 2 | 3 | #if js 4 | // import browser externs so we can use `window` and `document` everywhere 5 | import js.Browser.*; 6 | // import vector math so we can use vector expressions like `vec2()` `mat4()` 7 | import VectorMath; 8 | #end --------------------------------------------------------------------------------