├── LICENSE ├── README.md ├── analyze.txt ├── osu-Replay-Analyzer.VC.db ├── osu-Replay-Analyzer.sln └── osu-Replay-Analyzer ├── circle tmp ├── Circle.cpp ├── Circle.h └── area.c ├── irrlicht ├── include │ ├── CDynamicMeshBuffer.h │ ├── CIndexBuffer.h │ ├── CMeshBuffer.h │ ├── CVertexBuffer.h │ ├── EAttributes.h │ ├── ECullingTypes.h │ ├── EDebugSceneTypes.h │ ├── EDeviceTypes.h │ ├── EDriverFeatures.h │ ├── EDriverTypes.h │ ├── EGUIAlignment.h │ ├── EGUIElementTypes.h │ ├── EHardwareBufferFlags.h │ ├── EMaterialFlags.h │ ├── EMaterialTypes.h │ ├── EMeshWriterEnums.h │ ├── EMessageBoxFlags.h │ ├── EPrimitiveTypes.h │ ├── ESceneNodeAnimatorTypes.h │ ├── ESceneNodeTypes.h │ ├── EShaderTypes.h │ ├── ETerrainElements.h │ ├── IAnimatedMesh.h │ ├── IAnimatedMeshMD2.h │ ├── IAnimatedMeshMD3.h │ ├── IAnimatedMeshSceneNode.h │ ├── IAttributeExchangingObject.h │ ├── IAttributes.h │ ├── IBillboardSceneNode.h │ ├── IBillboardTextSceneNode.h │ ├── IBoneSceneNode.h │ ├── ICameraSceneNode.h │ ├── IColladaMeshWriter.h │ ├── ICursorControl.h │ ├── IDummyTransformationSceneNode.h │ ├── IDynamicMeshBuffer.h │ ├── IEventReceiver.h │ ├── IFileArchive.h │ ├── IFileList.h │ ├── IFileSystem.h │ ├── IGPUProgrammingServices.h │ ├── IGUIButton.h │ ├── IGUICheckBox.h │ ├── IGUIColorSelectDialog.h │ ├── IGUIComboBox.h │ ├── IGUIContextMenu.h │ ├── IGUIEditBox.h │ ├── IGUIElement.h │ ├── IGUIElementFactory.h │ ├── IGUIEnvironment.h │ ├── IGUIFileOpenDialog.h │ ├── IGUIFont.h │ ├── IGUIFontBitmap.h │ ├── IGUIImage.h │ ├── IGUIImageList.h │ ├── IGUIInOutFader.h │ ├── IGUIListBox.h │ ├── IGUIMeshViewer.h │ ├── IGUIScrollBar.h │ ├── IGUISkin.h │ ├── IGUISpinBox.h │ ├── IGUISpriteBank.h │ ├── IGUIStaticText.h │ ├── IGUITabControl.h │ ├── IGUITable.h │ ├── IGUIToolbar.h │ ├── IGUITreeView.h │ ├── IGUIWindow.h │ ├── IGeometryCreator.h │ ├── IImage.h │ ├── IImageLoader.h │ ├── IImageWriter.h │ ├── IIndexBuffer.h │ ├── ILightManager.h │ ├── ILightSceneNode.h │ ├── ILogger.h │ ├── IMaterialRenderer.h │ ├── IMaterialRendererServices.h │ ├── IMesh.h │ ├── IMeshBuffer.h │ ├── IMeshCache.h │ ├── IMeshLoader.h │ ├── IMeshManipulator.h │ ├── IMeshSceneNode.h │ ├── IMeshWriter.h │ ├── IMetaTriangleSelector.h │ ├── IOSOperator.h │ ├── IParticleAffector.h │ ├── IParticleAnimatedMeshSceneNodeEmitter.h │ ├── IParticleAttractionAffector.h │ ├── IParticleBoxEmitter.h │ ├── IParticleCylinderEmitter.h │ ├── IParticleEmitter.h │ ├── IParticleFadeOutAffector.h │ ├── IParticleGravityAffector.h │ ├── IParticleMeshEmitter.h │ ├── IParticleRingEmitter.h │ ├── IParticleRotationAffector.h │ ├── IParticleSphereEmitter.h │ ├── IParticleSystemSceneNode.h │ ├── IQ3LevelMesh.h │ ├── IQ3Shader.h │ ├── IRandomizer.h │ ├── IReadFile.h │ ├── IReferenceCounted.h │ ├── ISceneCollisionManager.h │ ├── ISceneLoader.h │ ├── ISceneManager.h │ ├── ISceneNode.h │ ├── ISceneNodeAnimator.h │ ├── ISceneNodeAnimatorCameraFPS.h │ ├── ISceneNodeAnimatorCameraMaya.h │ ├── ISceneNodeAnimatorCollisionResponse.h │ ├── ISceneNodeAnimatorFactory.h │ ├── ISceneNodeFactory.h │ ├── ISceneUserDataSerializer.h │ ├── IShaderConstantSetCallBack.h │ ├── IShadowVolumeSceneNode.h │ ├── ISkinnedMesh.h │ ├── ITerrainSceneNode.h │ ├── ITextSceneNode.h │ ├── ITexture.h │ ├── ITimer.h │ ├── ITriangleSelector.h │ ├── IVertexBuffer.h │ ├── IVideoDriver.h │ ├── IVideoModeList.h │ ├── IVolumeLightSceneNode.h │ ├── IWriteFile.h │ ├── IXMLReader.h │ ├── IXMLWriter.h │ ├── IrrCompileConfig.h │ ├── IrrlichtDevice.h │ ├── Keycodes.h │ ├── S3DVertex.h │ ├── SAnimatedMesh.h │ ├── SColor.h │ ├── SExposedVideoData.h │ ├── SIrrCreationParameters.h │ ├── SKeyMap.h │ ├── SLight.h │ ├── SMaterial.h │ ├── SMaterialLayer.h │ ├── SMesh.h │ ├── SMeshBuffer.h │ ├── SMeshBufferLightMap.h │ ├── SMeshBufferTangents.h │ ├── SParticle.h │ ├── SSharedMeshBuffer.h │ ├── SSkinMeshBuffer.h │ ├── SVertexIndex.h │ ├── SVertexManipulator.h │ ├── SViewFrustum.h │ ├── SceneParameters.h │ ├── aabbox3d.h │ ├── coreutil.h │ ├── dimension2d.h │ ├── driverChoice.h │ ├── fast_atof.h │ ├── heapsort.h │ ├── irrAllocator.h │ ├── irrArray.h │ ├── irrList.h │ ├── irrMap.h │ ├── irrMath.h │ ├── irrString.h │ ├── irrTypes.h │ ├── irrXML.h │ ├── irrlicht.h │ ├── irrpack.h │ ├── irrunpack.h │ ├── line2d.h │ ├── line3d.h │ ├── matrix4.h │ ├── path.h │ ├── plane3d.h │ ├── position2d.h │ ├── quaternion.h │ ├── rect.h │ ├── triangle3d.h │ ├── vector2d.h │ └── vector3d.h └── lib │ ├── Win32-gcc │ ├── libIrrlicht.a │ └── libIrrlicht.def │ └── Win32-visualstudio │ └── Irrlicht.exp ├── main.cpp ├── osu! ├── Analysis │ ├── Analysis.cpp │ ├── Analysis.h │ ├── AnalysisStruct.cpp │ ├── AnalysisStruct.h │ ├── Analyzer.cpp │ ├── Analyzer.h │ ├── Beatmap │ │ ├── Difficulty │ │ │ ├── Reading.cpp │ │ │ └── Reading.h │ │ ├── DistSize.cpp │ │ ├── Distance-size.h │ │ ├── IntensityForHand.cpp │ │ ├── IntensityForHand.h │ │ ├── NoteRate.cpp │ │ ├── NoteRate.h │ │ ├── NoteRatePerKey.cpp │ │ ├── NoteRatePerKey.h │ │ ├── NoteRatePerKeyPrecise.cpp │ │ ├── NoteRatePerKeyPrecise.h │ │ ├── Overlaps.cpp │ │ ├── Overlaps.h │ │ ├── TapEventIntervals.cpp │ │ ├── TapEventIntervals.h │ │ ├── Velocity.cpp │ │ └── Velocity.h │ ├── Replay │ │ ├── aim-deviation.cpp │ │ ├── aim-deviation.h │ │ ├── tap-deviation.cpp │ │ └── tap-deviation.h │ └── Score │ │ ├── AimScore.cpp │ │ ├── AimScore.h │ │ ├── TapScore.cpp │ │ └── TapScore.h ├── Drawable │ ├── GamemodeRenderer.cpp │ ├── GamemodeRenderer.h │ ├── HitNote.cpp │ ├── HitNote.h │ ├── HitTimingGraph.cpp │ ├── HitTimingGraph.h │ ├── HitTimingMarker.cpp │ ├── HitTimingMarker.h │ ├── Hitcircle.cpp │ ├── Hitcircle.h │ ├── OsuManiaRenderer.h │ ├── OsuManiaRenderercpp.cpp │ ├── OsuStdRenderer.cpp │ ├── OsuStdRenderer.h │ ├── StatGraph.cpp │ ├── StatGraph.h │ ├── TimingGraph.cpp │ ├── TimingGraph.h │ ├── TimingObject.cpp │ └── TimingObject.h ├── Filestructure │ ├── Beatmap.cpp │ ├── Beatmap.h │ ├── Bezier.cpp │ ├── Bezier.h │ ├── CircumscribedCircle.cpp │ ├── Hitobject.cpp │ ├── Hitobject.h │ ├── LZMA.cpp │ ├── LZMA.h │ ├── LZMA │ │ └── easylzma │ │ │ ├── common.h │ │ │ ├── common_internal.c │ │ │ ├── common_internal.h │ │ │ ├── compress.c │ │ │ ├── compress.h │ │ │ ├── decompress.c │ │ │ ├── decompress.h │ │ │ ├── lzip_header.c │ │ │ ├── lzip_header.h │ │ │ ├── lzma_header.c │ │ │ ├── lzma_header.h │ │ │ └── pavlov │ │ │ ├── 7zBuf.c │ │ │ ├── 7zBuf.h │ │ │ ├── 7zBuf2.c │ │ │ ├── 7zCrc.c │ │ │ ├── 7zCrc.h │ │ │ ├── 7zFile.c │ │ │ ├── 7zFile.h │ │ │ ├── 7zStream.c │ │ │ ├── 7zVersion.h │ │ │ ├── Alloc.c │ │ │ ├── Alloc.h │ │ │ ├── Bcj2.c │ │ │ ├── Bcj2.h │ │ │ ├── Bra.c │ │ │ ├── Bra.h │ │ │ ├── Bra86.c │ │ │ ├── BraIA64.c │ │ │ ├── CpuArch.h │ │ │ ├── LzFind.c │ │ │ ├── LzFind.h │ │ │ ├── LzHash.h │ │ │ ├── LzmaDec.c │ │ │ ├── LzmaDec.h │ │ │ ├── LzmaEnc.c │ │ │ ├── LzmaEnc.h │ │ │ ├── LzmaLib.c │ │ │ ├── LzmaLib.h │ │ │ └── Types.h │ ├── Mods.cpp │ ├── Mods.h │ ├── Play.cpp │ ├── Play.h │ ├── Replay.cpp │ ├── Replay.h │ ├── SliderHitobject.cpp │ ├── SliderHitobject.h │ ├── TimingPoint.cpp │ ├── TimingPoint.h │ ├── dirent.h │ └── filereader.h ├── Score │ ├── ScoreEngine.cpp │ ├── ScoreEngine.h │ ├── osu-catch │ │ ├── score.cpp │ │ └── score.h │ ├── osu-dodge │ │ ├── score.cpp │ │ └── score.h │ ├── osu-mania │ │ ├── score.cpp │ │ └── score.h │ ├── osu-std │ │ ├── score.cpp │ │ └── score.h │ └── osu-taiko │ │ ├── score.cpp │ │ └── score.h ├── osuCalc.cpp ├── osuCalc.h ├── osuEnums.h ├── osuStructs.cpp ├── osuStructs.h ├── osu_catch.h ├── osu_dodge.h ├── osu_mania.cpp ├── osu_mania.h ├── osu_standard.cpp ├── osu_standard.h └── osu_taiko.h ├── osu-Replay-Analyzer.vcxproj ├── osu-Replay-Analyzer.vcxproj.filters ├── ui ├── Button.cpp ├── Button.h ├── ColorTable.cpp ├── ColorTable.h ├── Dialog.cpp ├── Dialog.h ├── Event.cpp ├── Event.h ├── Graph.cpp ├── Graph.h ├── GuiObj.cpp ├── GuiObj.h ├── Scrollbar.cpp ├── Scrollbar.h ├── Slider.cpp ├── Slider.h ├── Window.cpp ├── Window.h ├── drawUtils.cpp ├── drawUtils.h ├── pane.cpp └── pane.h └── utils ├── Geometry.cpp ├── Geometry.h ├── Lambert.cpp ├── Lambert.h ├── LambertW.h ├── MD5 ├── hl_exception.h ├── hl_hashwrapper.h ├── hl_md5.cpp ├── hl_md5.h ├── hl_md5wrapper.cpp ├── hl_md5wrapper.h └── hl_types.h └── mathUtils.h /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 abraker95 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 | -------------------------------------------------------------------------------- /analyze.txt: -------------------------------------------------------------------------------- 1 | C:\My Games\Games\osu!\Songs\349208 Camellia as Bang Riot - Blastix Riotz\Camellia as Bang Riot - Blastix Riotz (Fresh Chicken) [Shirou's EXTRA].osu 2 | C:\My Games\Games\osu!\Replays\abraker - Camellia as Bang Riot - Blastix Riotz [Shirou's EXTRA] (2016-06-11) OsuMania.osr -------------------------------------------------------------------------------- /osu-Replay-Analyzer.VC.db: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer.VC.db -------------------------------------------------------------------------------- /osu-Replay-Analyzer.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 14 4 | VisualStudioVersion = 14.0.25123.0 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "osu-Replay-Analyzer", "osu-Replay-Analyzer\osu-Replay-Analyzer.vcxproj", "{9E1BA188-D9C0-4193-B287-0FC63FE05011}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|Win32 = Debug|Win32 11 | Release|Win32 = Release|Win32 12 | EndGlobalSection 13 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 14 | {9E1BA188-D9C0-4193-B287-0FC63FE05011}.Debug|Win32.ActiveCfg = Debug|Win32 15 | {9E1BA188-D9C0-4193-B287-0FC63FE05011}.Debug|Win32.Build.0 = Debug|Win32 16 | {9E1BA188-D9C0-4193-B287-0FC63FE05011}.Release|Win32.ActiveCfg = Release|Win32 17 | {9E1BA188-D9C0-4193-B287-0FC63FE05011}.Release|Win32.Build.0 = Release|Win32 18 | EndGlobalSection 19 | GlobalSection(SolutionProperties) = preSolution 20 | HideSolutionNode = FALSE 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/circle tmp/Circle.h: -------------------------------------------------------------------------------- 1 | // Circle.h: interface for the Circle class. 2 | // Circle class. 3 | // Purpose : Represent the circle object 4 | // Input : 3 different points 5 | // Process : Calcuate the radius and center 6 | // Output : Circle 7 | // 8 | // This class originally designed for representation of discretized curvature information 9 | // of sequential pointlist 10 | // KJIST CAD/CAM Ryu, Jae Hun ( ryu@geguri.kjist.ac.kr) 11 | // Last update : 1999. 7. 4 12 | #if !defined(AFX_CIRCLE_H__1EC15131_4038_11D3_8404_00C04FCC7989__INCLUDED_) 13 | #define AFX_CIRCLE_H__1EC15131_4038_11D3_8404_00C04FCC7989__INCLUDED_ 14 | 15 | #include "Point.h" // Added by ClassView 16 | #if _MSC_VER > 1000 17 | #pragma once 18 | #endif // _MSC_VER > 1000 19 | 20 | class Circle 21 | { 22 | public: 23 | double GetRadius(); 24 | Point* GetCenter(); 25 | Circle(Point *p1, Point *p2, Point *p3); // p1, p2, p3 are co-planar 26 | Circle(); 27 | virtual ~Circle(); 28 | 29 | private: 30 | double CalcCircle(Point *pt1, Point *pt2, Point *pt3); 31 | bool IsPerpendicular(Point *pt1, Point *pt2, Point *pt3); 32 | double m_dRadius; 33 | Point m_Center; 34 | }; 35 | 36 | #endif // !defined(AFX_CIRCLE_H__1EC15131_4038_11D3_8404_00C04FCC7989__INCLUDED_) 37 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/EAttributes.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_ATTRIBUTES_H_INCLUDED__ 6 | #define __E_ATTRIBUTES_H_INCLUDED__ 7 | 8 | namespace irr 9 | { 10 | namespace io 11 | { 12 | 13 | //! Types of attributes available for IAttributes 14 | enum E_ATTRIBUTE_TYPE 15 | { 16 | // integer attribute 17 | EAT_INT = 0, 18 | 19 | // float attribute 20 | EAT_FLOAT, 21 | 22 | // string attribute 23 | EAT_STRING, 24 | 25 | // boolean attribute 26 | EAT_BOOL, 27 | 28 | // enumeration attribute 29 | EAT_ENUM, 30 | 31 | // color attribute 32 | EAT_COLOR, 33 | 34 | // floating point color attribute 35 | EAT_COLORF, 36 | 37 | // 3d vector attribute 38 | EAT_VECTOR3D, 39 | 40 | // 2d position attribute 41 | EAT_POSITION2D, 42 | 43 | // vector 2d attribute 44 | EAT_VECTOR2D, 45 | 46 | // rectangle attribute 47 | EAT_RECT, 48 | 49 | // matrix attribute 50 | EAT_MATRIX, 51 | 52 | // quaternion attribute 53 | EAT_QUATERNION, 54 | 55 | // 3d bounding box 56 | EAT_BBOX, 57 | 58 | // plane 59 | EAT_PLANE, 60 | 61 | // 3d triangle 62 | EAT_TRIANGLE3D, 63 | 64 | // line 2d 65 | EAT_LINE2D, 66 | 67 | // line 3d 68 | EAT_LINE3D, 69 | 70 | // array of stringws attribute 71 | EAT_STRINGWARRAY, 72 | 73 | // array of float 74 | EAT_FLOATARRAY, 75 | 76 | // array of int 77 | EAT_INTARRAY, 78 | 79 | // binary data attribute 80 | EAT_BINARY, 81 | 82 | // texture reference attribute 83 | EAT_TEXTURE, 84 | 85 | // user pointer void* 86 | EAT_USER_POINTER, 87 | 88 | // dimension attribute 89 | EAT_DIMENSION2D, 90 | 91 | // known attribute type count 92 | EAT_COUNT, 93 | 94 | // unknown attribute 95 | EAT_UNKNOWN 96 | }; 97 | 98 | } // end namespace io 99 | } // end namespace irr 100 | 101 | #endif 102 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/ECullingTypes.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_CULLING_TYPES_H_INCLUDED__ 6 | #define __E_CULLING_TYPES_H_INCLUDED__ 7 | 8 | #include "irrTypes.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! An enumeration for all types of automatic culling for built-in scene nodes 16 | enum E_CULLING_TYPE 17 | { 18 | EAC_OFF = 0, 19 | EAC_BOX = 1, 20 | EAC_FRUSTUM_BOX = 2, 21 | EAC_FRUSTUM_SPHERE = 4, 22 | EAC_OCC_QUERY = 8 23 | }; 24 | 25 | //! Names for culling type 26 | const c8* const AutomaticCullingNames[] = 27 | { 28 | "false", 29 | "box", // camera box against node box 30 | "frustum_box", // camera frustum against node box 31 | "frustum_sphere", // camera frustum against node sphere 32 | "occ_query", // occlusion query 33 | 0 34 | }; 35 | 36 | } // end namespace scene 37 | } // end namespace irr 38 | 39 | 40 | #endif // __E_CULLING_TYPES_H_INCLUDED__ 41 | 42 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/EDebugSceneTypes.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_DEBUG_SCENE_TYPES_H_INCLUDED__ 6 | #define __E_DEBUG_SCENE_TYPES_H_INCLUDED__ 7 | 8 | namespace irr 9 | { 10 | namespace scene 11 | { 12 | 13 | //! An enumeration for all types of debug data for built-in scene nodes (flags) 14 | enum E_DEBUG_SCENE_TYPE 15 | { 16 | //! No Debug Data ( Default ) 17 | EDS_OFF = 0, 18 | 19 | //! Show Bounding Boxes of SceneNode 20 | EDS_BBOX = 1, 21 | 22 | //! Show Vertex Normals 23 | EDS_NORMALS = 2, 24 | 25 | //! Shows Skeleton/Tags 26 | EDS_SKELETON = 4, 27 | 28 | //! Overlays Mesh Wireframe 29 | EDS_MESH_WIRE_OVERLAY = 8, 30 | 31 | //! Temporary use transparency Material Type 32 | EDS_HALF_TRANSPARENCY = 16, 33 | 34 | //! Show Bounding Boxes of all MeshBuffers 35 | EDS_BBOX_BUFFERS = 32, 36 | 37 | //! EDS_BBOX | EDS_BBOX_BUFFERS 38 | EDS_BBOX_ALL = EDS_BBOX | EDS_BBOX_BUFFERS, 39 | 40 | //! Show all debug infos 41 | EDS_FULL = 0xffffffff 42 | }; 43 | 44 | 45 | } // end namespace scene 46 | } // end namespace irr 47 | 48 | 49 | #endif // __E_DEBUG_SCENE_TYPES_H_INCLUDED__ 50 | 51 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/EGUIAlignment.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_GUI_ALIGNMENT_H_INCLUDED__ 6 | #define __E_GUI_ALIGNMENT_H_INCLUDED__ 7 | 8 | namespace irr 9 | { 10 | namespace gui 11 | { 12 | enum EGUI_ALIGNMENT 13 | { 14 | //! Aligned to parent's top or left side (default) 15 | EGUIA_UPPERLEFT=0, 16 | //! Aligned to parent's bottom or right side 17 | EGUIA_LOWERRIGHT, 18 | //! Aligned to the center of parent 19 | EGUIA_CENTER, 20 | //! Stretched to fit parent 21 | EGUIA_SCALE 22 | }; 23 | 24 | //! Names for alignments 25 | const c8* const GUIAlignmentNames[] = 26 | { 27 | "upperLeft", 28 | "lowerRight", 29 | "center", 30 | "scale", 31 | 0 32 | }; 33 | 34 | } // namespace gui 35 | } // namespace irr 36 | 37 | #endif // __E_GUI_ALIGNMENT_H_INCLUDED__ 38 | 39 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/EHardwareBufferFlags.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_HARDWARE_BUFFER_FLAGS_INCLUDED__ 6 | #define __E_HARDWARE_BUFFER_FLAGS_INCLUDED__ 7 | 8 | namespace irr 9 | { 10 | namespace scene 11 | { 12 | 13 | enum E_HARDWARE_MAPPING 14 | { 15 | //! Don't store on the hardware 16 | EHM_NEVER=0, 17 | 18 | //! Rarely changed, usually stored completely on the hardware 19 | EHM_STATIC, 20 | 21 | //! Sometimes changed, driver optimized placement 22 | EHM_DYNAMIC, 23 | 24 | //! Always changed, cache optimizing on the GPU 25 | EHM_STREAM 26 | }; 27 | 28 | enum E_BUFFER_TYPE 29 | { 30 | //! Does not change anything 31 | EBT_NONE=0, 32 | //! Change the vertex mapping 33 | EBT_VERTEX, 34 | //! Change the index mapping 35 | EBT_INDEX, 36 | //! Change both vertex and index mapping to the same value 37 | EBT_VERTEX_AND_INDEX 38 | }; 39 | 40 | } // end namespace scene 41 | } // end namespace irr 42 | 43 | #endif 44 | 45 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/EMeshWriterEnums.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_MESH_WRITER_ENUMS_H_INCLUDED__ 6 | #define __E_MESH_WRITER_ENUMS_H_INCLUDED__ 7 | 8 | #include "irrTypes.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! An enumeration for all supported types of built-in mesh writers 16 | /** A scene mesh writers is represented by a four character code 17 | such as 'irrm' or 'coll' instead of simple numbers, to avoid 18 | name clashes with external mesh writers.*/ 19 | enum EMESH_WRITER_TYPE 20 | { 21 | //! Irrlicht native mesh writer, for static .irrmesh files. 22 | EMWT_IRR_MESH = MAKE_IRR_ID('i','r','r','m'), 23 | 24 | //! COLLADA mesh writer for .dae and .xml files 25 | EMWT_COLLADA = MAKE_IRR_ID('c','o','l','l'), 26 | 27 | //! STL mesh writer for .stl files 28 | EMWT_STL = MAKE_IRR_ID('s','t','l',0), 29 | 30 | //! OBJ mesh writer for .obj files 31 | EMWT_OBJ = MAKE_IRR_ID('o','b','j',0), 32 | 33 | //! PLY mesh writer for .ply files 34 | EMWT_PLY = MAKE_IRR_ID('p','l','y',0) 35 | }; 36 | 37 | 38 | //! flags configuring mesh writing 39 | enum E_MESH_WRITER_FLAGS 40 | { 41 | //! no writer flags 42 | EMWF_NONE = 0, 43 | 44 | //! write lightmap textures out if possible 45 | EMWF_WRITE_LIGHTMAPS = 0x1, 46 | 47 | //! write in a way that consumes less disk space 48 | EMWF_WRITE_COMPRESSED = 0x2, 49 | 50 | //! write in binary format rather than text 51 | EMWF_WRITE_BINARY = 0x4 52 | }; 53 | 54 | } // end namespace scene 55 | } // end namespace irr 56 | 57 | 58 | #endif // __E_MESH_WRITER_ENUMS_H_INCLUDED__ 59 | 60 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/EMessageBoxFlags.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_MESSAGE_BOX_FLAGS_H_INCLUDED__ 6 | #define __E_MESSAGE_BOX_FLAGS_H_INCLUDED__ 7 | 8 | namespace irr 9 | { 10 | namespace gui 11 | { 12 | 13 | //! enumeration for message box layout flags 14 | enum EMESSAGE_BOX_FLAG 15 | { 16 | //! Flag for the ok button 17 | EMBF_OK = 0x1, 18 | 19 | //! Flag for the cancel button 20 | EMBF_CANCEL = 0x2, 21 | 22 | //! Flag for the yes button 23 | EMBF_YES = 0x4, 24 | 25 | //! Flag for the no button 26 | EMBF_NO = 0x8, 27 | 28 | //! This value is not used. It only forces this enumeration to compile in 32 bit. 29 | EMBF_FORCE_32BIT = 0x7fffffff 30 | }; 31 | 32 | } // namespace gui 33 | } // namespace irr 34 | 35 | #endif 36 | 37 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/EPrimitiveTypes.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_PRIMITIVE_TYPES_H_INCLUDED__ 6 | #define __E_PRIMITIVE_TYPES_H_INCLUDED__ 7 | 8 | namespace irr 9 | { 10 | namespace scene 11 | { 12 | 13 | //! Enumeration for all primitive types there are. 14 | enum E_PRIMITIVE_TYPE 15 | { 16 | //! All vertices are non-connected points. 17 | EPT_POINTS=0, 18 | 19 | //! All vertices form a single connected line. 20 | EPT_LINE_STRIP, 21 | 22 | //! Just as LINE_STRIP, but the last and the first vertex is also connected. 23 | EPT_LINE_LOOP, 24 | 25 | //! Every two vertices are connected creating n/2 lines. 26 | EPT_LINES, 27 | 28 | //! After the first two vertices each vertex defines a new triangle. 29 | //! Always the two last and the new one form a new triangle. 30 | EPT_TRIANGLE_STRIP, 31 | 32 | //! After the first two vertices each vertex defines a new triangle. 33 | //! All around the common first vertex. 34 | EPT_TRIANGLE_FAN, 35 | 36 | //! Explicitly set all vertices for each triangle. 37 | EPT_TRIANGLES, 38 | 39 | //! After the first two vertices each further tw vetices create a quad with the preceding two. 40 | EPT_QUAD_STRIP, 41 | 42 | //! Every four vertices create a quad. 43 | EPT_QUADS, 44 | 45 | //! Just as LINE_LOOP, but filled. 46 | EPT_POLYGON, 47 | 48 | //! The single vertices are expanded to quad billboards on the GPU. 49 | EPT_POINT_SPRITES 50 | }; 51 | 52 | } // end namespace scene 53 | } // end namespace irr 54 | 55 | #endif 56 | 57 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/ESceneNodeAnimatorTypes.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_SCENE_NODE_ANIMATOR_TYPES_H_INCLUDED__ 6 | #define __E_SCENE_NODE_ANIMATOR_TYPES_H_INCLUDED__ 7 | 8 | namespace irr 9 | { 10 | namespace scene 11 | { 12 | 13 | //! An enumeration for all types of built-in scene node animators 14 | enum ESCENE_NODE_ANIMATOR_TYPE 15 | { 16 | //! Fly circle scene node animator 17 | ESNAT_FLY_CIRCLE = 0, 18 | 19 | //! Fly straight scene node animator 20 | ESNAT_FLY_STRAIGHT, 21 | 22 | //! Follow spline scene node animator 23 | ESNAT_FOLLOW_SPLINE, 24 | 25 | //! Rotation scene node animator 26 | ESNAT_ROTATION, 27 | 28 | //! Texture scene node animator 29 | ESNAT_TEXTURE, 30 | 31 | //! Deletion scene node animator 32 | ESNAT_DELETION, 33 | 34 | //! Collision respose scene node animator 35 | ESNAT_COLLISION_RESPONSE, 36 | 37 | //! FPS camera animator 38 | ESNAT_CAMERA_FPS, 39 | 40 | //! Maya camera animator 41 | ESNAT_CAMERA_MAYA, 42 | 43 | //! Amount of built-in scene node animators 44 | ESNAT_COUNT, 45 | 46 | //! Unknown scene node animator 47 | ESNAT_UNKNOWN, 48 | 49 | //! This enum is never used, it only forces the compiler to compile this enumeration to 32 bit. 50 | ESNAT_FORCE_32_BIT = 0x7fffffff 51 | }; 52 | 53 | } // end namespace scene 54 | } // end namespace irr 55 | 56 | 57 | #endif 58 | 59 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/EShaderTypes.h: -------------------------------------------------------------------------------- 1 | #ifndef __E_SHADER_TYPES_H_INCLUDED__ 2 | #define __E_SHADER_TYPES_H_INCLUDED__ 3 | 4 | #include "irrTypes.h" 5 | 6 | namespace irr 7 | { 8 | namespace video 9 | { 10 | 11 | //! Compile target enumeration for the addHighLevelShaderMaterial() method. 12 | enum E_VERTEX_SHADER_TYPE 13 | { 14 | EVST_VS_1_1 = 0, 15 | EVST_VS_2_0, 16 | EVST_VS_2_a, 17 | EVST_VS_3_0, 18 | EVST_VS_4_0, 19 | EVST_VS_4_1, 20 | EVST_VS_5_0, 21 | 22 | //! This is not a type, but a value indicating how much types there are. 23 | EVST_COUNT 24 | }; 25 | 26 | //! Names for all vertex shader types, each entry corresponds to a E_VERTEX_SHADER_TYPE entry. 27 | const c8* const VERTEX_SHADER_TYPE_NAMES[] = { 28 | "vs_1_1", 29 | "vs_2_0", 30 | "vs_2_a", 31 | "vs_3_0", 32 | "vs_4_0", 33 | "vs_4_1", 34 | "vs_5_0", 35 | 0 }; 36 | 37 | //! Compile target enumeration for the addHighLevelShaderMaterial() method. 38 | enum E_PIXEL_SHADER_TYPE 39 | { 40 | EPST_PS_1_1 = 0, 41 | EPST_PS_1_2, 42 | EPST_PS_1_3, 43 | EPST_PS_1_4, 44 | EPST_PS_2_0, 45 | EPST_PS_2_a, 46 | EPST_PS_2_b, 47 | EPST_PS_3_0, 48 | EPST_PS_4_0, 49 | EPST_PS_4_1, 50 | EPST_PS_5_0, 51 | 52 | //! This is not a type, but a value indicating how much types there are. 53 | EPST_COUNT 54 | }; 55 | 56 | //! Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry. 57 | const c8* const PIXEL_SHADER_TYPE_NAMES[] = { 58 | "ps_1_1", 59 | "ps_1_2", 60 | "ps_1_3", 61 | "ps_1_4", 62 | "ps_2_0", 63 | "ps_2_a", 64 | "ps_2_b", 65 | "ps_3_0", 66 | "ps_4_0", 67 | "ps_4_1", 68 | "ps_5_0", 69 | 0 }; 70 | 71 | //! Enum for supported geometry shader types 72 | enum E_GEOMETRY_SHADER_TYPE 73 | { 74 | EGST_GS_4_0 = 0, 75 | 76 | //! This is not a type, but a value indicating how much types there are. 77 | EGST_COUNT 78 | }; 79 | 80 | //! String names for supported geometry shader types 81 | const c8* const GEOMETRY_SHADER_TYPE_NAMES[] = { 82 | "gs_4_0", 83 | 0 }; 84 | 85 | 86 | } // end namespace video 87 | } // end namespace irr 88 | 89 | #endif // __E_SHADER_TYPES_H_INCLUDED__ 90 | 91 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/ETerrainElements.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_TERRAIN_ELEMENTS_H__ 6 | #define __E_TERRAIN_ELEMENTS_H__ 7 | 8 | namespace irr 9 | { 10 | namespace scene 11 | { 12 | 13 | //! enumeration for patch sizes specifying the size of patches in the TerrainSceneNode 14 | enum E_TERRAIN_PATCH_SIZE 15 | { 16 | //! patch size of 9, at most, use 4 levels of detail with this patch size. 17 | ETPS_9 = 9, 18 | 19 | //! patch size of 17, at most, use 5 levels of detail with this patch size. 20 | ETPS_17 = 17, 21 | 22 | //! patch size of 33, at most, use 6 levels of detail with this patch size. 23 | ETPS_33 = 33, 24 | 25 | //! patch size of 65, at most, use 7 levels of detail with this patch size. 26 | ETPS_65 = 65, 27 | 28 | //! patch size of 129, at most, use 8 levels of detail with this patch size. 29 | ETPS_129 = 129 30 | }; 31 | 32 | } // end namespace scene 33 | } // end namespace irr 34 | 35 | #endif 36 | 37 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IAttributeExchangingObject.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_ATTRIBUTE_EXCHANGING_OBJECT_H_INCLUDED__ 6 | #define __I_ATTRIBUTE_EXCHANGING_OBJECT_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | 10 | 11 | namespace irr 12 | { 13 | 14 | namespace io 15 | { 16 | 17 | class IAttributes; 18 | 19 | //! Enumeration flags passed through SAttributeReadWriteOptions to the IAttributeExchangingObject object 20 | enum E_ATTRIBUTE_READ_WRITE_FLAGS 21 | { 22 | //! Serialization/Deserializion is done for an xml file 23 | EARWF_FOR_FILE = 0x00000001, 24 | 25 | //! Serialization/Deserializion is done for an editor property box 26 | EARWF_FOR_EDITOR = 0x00000002, 27 | 28 | //! When writing filenames, relative paths should be used 29 | EARWF_USE_RELATIVE_PATHS = 0x00000004 30 | }; 31 | 32 | 33 | //! struct holding data describing options 34 | struct SAttributeReadWriteOptions 35 | { 36 | //! Constructor 37 | SAttributeReadWriteOptions() 38 | : Flags(0), Filename(0) 39 | { 40 | } 41 | 42 | //! Combination of E_ATTRIBUTE_READ_WRITE_FLAGS or other, custom ones 43 | s32 Flags; 44 | 45 | //! Optional filename 46 | const fschar_t* Filename; 47 | }; 48 | 49 | 50 | //! An object which is able to serialize and deserialize its attributes into an attributes object 51 | class IAttributeExchangingObject : virtual public IReferenceCounted 52 | { 53 | public: 54 | 55 | //! Writes attributes of the object. 56 | /** Implement this to expose the attributes of your scene node animator for 57 | scripting languages, editors, debuggers or xml serialization purposes. */ 58 | virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const {} 59 | 60 | //! Reads attributes of the object. 61 | /** Implement this to set the attributes of your scene node animator for 62 | scripting languages, editors, debuggers or xml deserialization purposes. */ 63 | virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) {} 64 | 65 | }; 66 | 67 | } // end namespace io 68 | } // end namespace irr 69 | 70 | #endif 71 | 72 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IDummyTransformationSceneNode.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_DUMMY_TRANSFORMATION_SCENE_NODE_H_INCLUDED__ 6 | #define __I_DUMMY_TRANSFORMATION_SCENE_NODE_H_INCLUDED__ 7 | 8 | #include "ISceneNode.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! Dummy scene node for adding additional transformations to the scene graph. 16 | /** This scene node does not render itself, and does not respond to set/getPosition, 17 | set/getRotation and set/getScale. Its just a simple scene node that takes a 18 | matrix as relative transformation, making it possible to insert any transformation 19 | anywhere into the scene graph. 20 | This scene node is for example used by the IAnimatedMeshSceneNode for emulating 21 | joint scene nodes when playing skeletal animations. 22 | */ 23 | class IDummyTransformationSceneNode : public ISceneNode 24 | { 25 | public: 26 | 27 | //! Constructor 28 | IDummyTransformationSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id) 29 | : ISceneNode(parent, mgr, id) {} 30 | 31 | //! Returns a reference to the current relative transformation matrix. 32 | /** This is the matrix, this scene node uses instead of scale, translation 33 | and rotation. */ 34 | virtual core::matrix4& getRelativeTransformationMatrix() = 0; 35 | }; 36 | 37 | } // end namespace scene 38 | } // end namespace irr 39 | 40 | 41 | #endif 42 | 43 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUICheckBox.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_GUI_CHECKBOX_H_INCLUDED__ 6 | #define __I_GUI_CHECKBOX_H_INCLUDED__ 7 | 8 | #include "IGUIElement.h" 9 | 10 | namespace irr 11 | { 12 | namespace gui 13 | { 14 | 15 | //! GUI Check box interface. 16 | /** \par This element can create the following events of type EGUI_EVENT_TYPE: 17 | \li EGET_CHECKBOX_CHANGED 18 | */ 19 | class IGUICheckBox : public IGUIElement 20 | { 21 | public: 22 | 23 | //! constructor 24 | IGUICheckBox(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect rectangle) 25 | : IGUIElement(EGUIET_CHECK_BOX, environment, parent, id, rectangle) {} 26 | 27 | //! Set if box is checked. 28 | virtual void setChecked(bool checked) = 0; 29 | 30 | //! Returns true if box is checked. 31 | virtual bool isChecked() const = 0; 32 | }; 33 | 34 | } // end namespace gui 35 | } // end namespace irr 36 | 37 | #endif 38 | 39 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUIColorSelectDialog.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_GUI_COLOR_SELECT_DIALOG_H_INCLUDED__ 6 | #define __I_GUI_COLOR_SELECT_DIALOG_H_INCLUDED__ 7 | 8 | #include "IGUIElement.h" 9 | 10 | namespace irr 11 | { 12 | namespace gui 13 | { 14 | 15 | //! Standard color chooser dialog. 16 | class IGUIColorSelectDialog : public IGUIElement 17 | { 18 | public: 19 | 20 | //! constructor 21 | IGUIColorSelectDialog(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect rectangle) 22 | : IGUIElement(EGUIET_COLOR_SELECT_DIALOG, environment, parent, id, rectangle) {} 23 | }; 24 | 25 | 26 | } // end namespace gui 27 | } // end namespace irr 28 | 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUIFileOpenDialog.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_GUI_FILE_OPEN_DIALOG_H_INCLUDED__ 6 | #define __I_GUI_FILE_OPEN_DIALOG_H_INCLUDED__ 7 | 8 | #include "IGUIElement.h" 9 | #include "path.h" 10 | 11 | namespace irr 12 | { 13 | namespace gui 14 | { 15 | 16 | //! Standard file chooser dialog. 17 | /** \warning When the user selects a folder this does change the current working directory 18 | 19 | \par This element can create the following events of type EGUI_EVENT_TYPE: 20 | \li EGET_DIRECTORY_SELECTED 21 | \li EGET_FILE_SELECTED 22 | \li EGET_FILE_CHOOSE_DIALOG_CANCELLED 23 | */ 24 | class IGUIFileOpenDialog : public IGUIElement 25 | { 26 | public: 27 | 28 | //! constructor 29 | IGUIFileOpenDialog(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect rectangle) 30 | : IGUIElement(EGUIET_FILE_OPEN_DIALOG, environment, parent, id, rectangle) {} 31 | 32 | //! Returns the filename of the selected file. Returns NULL, if no file was selected. 33 | virtual const wchar_t* getFileName() const = 0; 34 | 35 | //! Returns the directory of the selected file. Returns NULL, if no directory was selected. 36 | virtual const io::path& getDirectoryName() = 0; 37 | }; 38 | 39 | 40 | } // end namespace gui 41 | } // end namespace irr 42 | 43 | #endif 44 | 45 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUIFontBitmap.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_GUI_FONT_BITMAP_H_INCLUDED__ 6 | #define __I_GUI_FONT_BITMAP_H_INCLUDED__ 7 | 8 | #include "IGUIFont.h" 9 | 10 | namespace irr 11 | { 12 | namespace gui 13 | { 14 | class IGUISpriteBank; 15 | 16 | //! Font interface. 17 | class IGUIFontBitmap : public IGUIFont 18 | { 19 | public: 20 | 21 | //! Returns the type of this font 22 | virtual EGUI_FONT_TYPE getType() const { return EGFT_BITMAP; } 23 | 24 | //! returns the parsed Symbol Information 25 | virtual IGUISpriteBank* getSpriteBank() const = 0; 26 | 27 | //! returns the sprite number from a given character 28 | virtual u32 getSpriteNoFromChar(const wchar_t *c) const = 0; 29 | 30 | //! Gets kerning values (distance between letters) for the font. If no parameters are provided, 31 | /** the global kerning distance is returned. 32 | \param thisLetter: If this parameter is provided, the left side kerning for this letter is added 33 | to the global kerning value. For example, a space might only be one pixel wide, but it may 34 | be displayed as several pixels. 35 | \param previousLetter: If provided, kerning is calculated for both letters and added to the global 36 | kerning value. For example, EGFT_BITMAP will add the right kerning value of previousLetter to the 37 | left side kerning value of thisLetter, then add the global value. 38 | */ 39 | virtual s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const = 0; 40 | }; 41 | 42 | } // end namespace gui 43 | } // end namespace irr 44 | 45 | #endif 46 | 47 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUIImage.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_GUI_IMAGE_H_INCLUDED__ 6 | #define __I_GUI_IMAGE_H_INCLUDED__ 7 | 8 | #include "IGUIElement.h" 9 | 10 | namespace irr 11 | { 12 | namespace video 13 | { 14 | class ITexture; 15 | } 16 | namespace gui 17 | { 18 | 19 | //! GUI element displaying an image. 20 | class IGUIImage : public IGUIElement 21 | { 22 | public: 23 | 24 | //! constructor 25 | IGUIImage(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect rectangle) 26 | : IGUIElement(EGUIET_IMAGE, environment, parent, id, rectangle) {} 27 | 28 | //! Sets an image texture 29 | virtual void setImage(video::ITexture* image) = 0; 30 | 31 | //! Gets the image texture 32 | virtual video::ITexture* getImage() const = 0; 33 | 34 | //! Sets the color of the image 35 | virtual void setColor(video::SColor color) = 0; 36 | 37 | //! Sets if the image should scale to fit the element 38 | virtual void setScaleImage(bool scale) = 0; 39 | 40 | //! Sets if the image should use its alpha channel to draw itself 41 | virtual void setUseAlphaChannel(bool use) = 0; 42 | 43 | //! Gets the color of the image 44 | virtual video::SColor getColor() const = 0; 45 | 46 | //! Returns true if the image is scaled to fit, false if not 47 | virtual bool isImageScaled() const = 0; 48 | 49 | //! Returns true if the image is using the alpha channel, false if not 50 | virtual bool isAlphaChannelUsed() const = 0; 51 | }; 52 | 53 | 54 | } // end namespace gui 55 | } // end namespace irr 56 | 57 | #endif 58 | 59 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUIImageList.h: -------------------------------------------------------------------------------- 1 | // This file is part of the "Irrlicht Engine". 2 | // written by Reinhard Ostermeier, reinhard@nospam.r-ostermeier.de 3 | 4 | #ifndef __I_GUI_IMAGE_LIST_H_INCLUDED__ 5 | #define __I_GUI_IMAGE_LIST_H_INCLUDED__ 6 | 7 | #include "IGUIElement.h" 8 | #include "rect.h" 9 | #include "irrTypes.h" 10 | 11 | namespace irr 12 | { 13 | namespace gui 14 | { 15 | 16 | //! Font interface. 17 | class IGUIImageList : public virtual IReferenceCounted 18 | { 19 | public: 20 | 21 | //! Destructor 22 | virtual ~IGUIImageList() {}; 23 | 24 | //! Draws an image and clips it to the specified rectangle if wanted 25 | //! \param index: Index of the image 26 | //! \param destPos: Position of the image to draw 27 | //! \param clip: Optional pointer to a rectalgle against which the text will be clipped. 28 | //! If the pointer is null, no clipping will be done. 29 | virtual void draw(s32 index, const core::position2d& destPos, 30 | const core::rect* clip = 0) = 0; 31 | 32 | //! Returns the count of Images in the list. 33 | //! \return Returns the count of Images in the list. 34 | virtual s32 getImageCount() const = 0; 35 | 36 | //! Returns the size of the images in the list. 37 | //! \return Returns the size of the images in the list. 38 | virtual core::dimension2d getImageSize() const = 0; 39 | }; 40 | 41 | } // end namespace gui 42 | } // end namespace irr 43 | 44 | #endif 45 | 46 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUIMeshViewer.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_GUI_MESH_VIEWER_H_INCLUDED__ 6 | #define __I_GUI_MESH_VIEWER_H_INCLUDED__ 7 | 8 | #include "IGUIElement.h" 9 | 10 | namespace irr 11 | { 12 | 13 | namespace video 14 | { 15 | class SMaterial; 16 | } // end namespace video 17 | 18 | namespace scene 19 | { 20 | class IAnimatedMesh; 21 | } // end namespace scene 22 | 23 | namespace gui 24 | { 25 | 26 | //! 3d mesh viewing GUI element. 27 | class IGUIMeshViewer : public IGUIElement 28 | { 29 | public: 30 | 31 | //! constructor 32 | IGUIMeshViewer(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect rectangle) 33 | : IGUIElement(EGUIET_MESH_VIEWER, environment, parent, id, rectangle) {} 34 | 35 | //! Sets the mesh to be shown 36 | virtual void setMesh(scene::IAnimatedMesh* mesh) = 0; 37 | 38 | //! Gets the displayed mesh 39 | virtual scene::IAnimatedMesh* getMesh() const = 0; 40 | 41 | //! Sets the material 42 | virtual void setMaterial(const video::SMaterial& material) = 0; 43 | 44 | //! Gets the material 45 | virtual const video::SMaterial& getMaterial() const = 0; 46 | }; 47 | 48 | 49 | } // end namespace gui 50 | } // end namespace irr 51 | 52 | #endif 53 | 54 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUIScrollBar.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_GUI_SCROLL_BAR_H_INCLUDED__ 6 | #define __I_GUI_SCROLL_BAR_H_INCLUDED__ 7 | 8 | #include "IGUIElement.h" 9 | 10 | namespace irr 11 | { 12 | namespace gui 13 | { 14 | 15 | //! Default scroll bar GUI element. 16 | /** \par This element can create the following events of type EGUI_EVENT_TYPE: 17 | \li EGET_SCROLL_BAR_CHANGED 18 | */ 19 | class IGUIScrollBar : public IGUIElement 20 | { 21 | public: 22 | 23 | //! constructor 24 | IGUIScrollBar(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect rectangle) 25 | : IGUIElement(EGUIET_SCROLL_BAR, environment, parent, id, rectangle) {} 26 | 27 | //! sets the maximum value of the scrollbar. 28 | virtual void setMax(s32 max) = 0; 29 | //! gets the maximum value of the scrollbar. 30 | virtual s32 getMax() const = 0; 31 | 32 | //! sets the minimum value of the scrollbar. 33 | virtual void setMin(s32 min) = 0; 34 | //! gets the minimum value of the scrollbar. 35 | virtual s32 getMin() const = 0; 36 | 37 | //! gets the small step value 38 | virtual s32 getSmallStep() const = 0; 39 | 40 | //! Sets the small step 41 | /** That is the amount that the value changes by when clicking 42 | on the buttons or using the cursor keys. */ 43 | virtual void setSmallStep(s32 step) = 0; 44 | 45 | //! gets the large step value 46 | virtual s32 getLargeStep() const = 0; 47 | 48 | //! Sets the large step 49 | /** That is the amount that the value changes by when clicking 50 | in the tray, or using the page up and page down keys. */ 51 | virtual void setLargeStep(s32 step) = 0; 52 | 53 | //! gets the current position of the scrollbar 54 | virtual s32 getPos() const = 0; 55 | 56 | //! sets the current position of the scrollbar 57 | virtual void setPos(s32 pos) = 0; 58 | }; 59 | 60 | 61 | } // end namespace gui 62 | } // end namespace irr 63 | 64 | #endif 65 | 66 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IGUIToolbar.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_GUI_TOOL_BAR_H_INCLUDED__ 6 | #define __I_GUI_TOOL_BAR_H_INCLUDED__ 7 | 8 | #include "IGUIElement.h" 9 | 10 | namespace irr 11 | { 12 | namespace video 13 | { 14 | class ITexture; 15 | } // end namespace video 16 | namespace gui 17 | { 18 | class IGUIButton; 19 | 20 | //! Stays at the top of its parent like the menu bar and contains tool buttons 21 | class IGUIToolBar : public IGUIElement 22 | { 23 | public: 24 | 25 | //! constructor 26 | IGUIToolBar(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect rectangle) 27 | : IGUIElement(EGUIET_TOOL_BAR, environment, parent, id, rectangle) {} 28 | 29 | //! Adds a button to the tool bar 30 | virtual IGUIButton* addButton(s32 id=-1, const wchar_t* text=0,const wchar_t* tooltiptext=0, 31 | video::ITexture* img=0, video::ITexture* pressedimg=0, 32 | bool isPushButton=false, bool useAlphaChannel=false) = 0; 33 | }; 34 | 35 | 36 | } // end namespace gui 37 | } // end namespace irr 38 | 39 | #endif 40 | 41 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IImageLoader.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_SURFACE_LOADER_H_INCLUDED__ 6 | #define __I_SURFACE_LOADER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "IImage.h" 10 | #include "path.h" 11 | 12 | namespace irr 13 | { 14 | namespace io 15 | { 16 | class IReadFile; 17 | } // end namespace io 18 | namespace video 19 | { 20 | 21 | //! Class which is able to create a image from a file. 22 | /** If you want the Irrlicht Engine be able to load textures of 23 | currently unsupported file formats (e.g .gif), then implement 24 | this and add your new Surface loader with 25 | IVideoDriver::addExternalImageLoader() to the engine. */ 26 | class IImageLoader : public virtual IReferenceCounted 27 | { 28 | public: 29 | 30 | //! Check if the file might be loaded by this class 31 | /** Check is based on the file extension (e.g. ".tga") 32 | \param filename Name of file to check. 33 | \return True if file seems to be loadable. */ 34 | virtual bool isALoadableFileExtension(const io::path& filename) const = 0; 35 | 36 | //! Check if the file might be loaded by this class 37 | /** Check might look into the file. 38 | \param file File handle to check. 39 | \return True if file seems to be loadable. */ 40 | virtual bool isALoadableFileFormat(io::IReadFile* file) const = 0; 41 | 42 | //! Creates a surface from the file 43 | /** \param file File handle to check. 44 | \return Pointer to newly created image, or 0 upon error. */ 45 | virtual IImage* loadImage(io::IReadFile* file) const = 0; 46 | }; 47 | 48 | 49 | } // end namespace video 50 | } // end namespace irr 51 | 52 | #endif 53 | 54 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IImageWriter.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef _I_IMAGE_WRITER_H_INCLUDED__ 6 | #define _I_IMAGE_WRITER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "irrString.h" 10 | #include "coreutil.h" 11 | 12 | namespace irr 13 | { 14 | namespace io 15 | { 16 | class IWriteFile; 17 | } // end namespace io 18 | 19 | namespace video 20 | { 21 | class IImage; 22 | 23 | 24 | //! Interface for writing software image data. 25 | class IImageWriter : public IReferenceCounted 26 | { 27 | public: 28 | //! Check if this writer can write a file with the given extension 29 | /** \param filename Name of the file to check. 30 | \return True if file extension specifies a writable type. */ 31 | virtual bool isAWriteableFileExtension(const io::path& filename) const = 0; 32 | 33 | //! Write image to file 34 | /** \param file File handle to write to. 35 | \param image Image to write into file. 36 | \param param Writer specific parameter, influencing e.g. quality. 37 | \return True if image was successfully written. */ 38 | virtual bool writeImage(io::IWriteFile *file, IImage *image, u32 param = 0) const = 0; 39 | }; 40 | 41 | } // namespace video 42 | } // namespace irr 43 | 44 | #endif // _I_IMAGE_WRITER_H_INCLUDED__ 45 | 46 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IIndexBuffer.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2008-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_INDEX_BUFFER_H_INCLUDED__ 6 | #define __I_INDEX_BUFFER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "irrArray.h" 10 | 11 | #include "SVertexIndex.h" 12 | 13 | namespace irr 14 | { 15 | 16 | namespace video 17 | { 18 | 19 | } 20 | 21 | namespace scene 22 | { 23 | 24 | class IIndexBuffer : public virtual IReferenceCounted 25 | { 26 | public: 27 | 28 | virtual void* getData() =0; 29 | 30 | virtual video::E_INDEX_TYPE getType() const =0; 31 | virtual void setType(video::E_INDEX_TYPE IndexType) =0; 32 | 33 | virtual u32 stride() const =0; 34 | 35 | virtual u32 size() const =0; 36 | virtual void push_back (const u32 &element) =0; 37 | virtual u32 operator [](u32 index) const =0; 38 | virtual u32 getLast() =0; 39 | virtual void setValue(u32 index, u32 value) =0; 40 | virtual void set_used(u32 usedNow) =0; 41 | virtual void reallocate(u32 new_size) =0; 42 | virtual u32 allocated_size() const=0; 43 | 44 | virtual void* pointer() =0; 45 | 46 | //! get the current hardware mapping hint 47 | virtual E_HARDWARE_MAPPING getHardwareMappingHint() const =0; 48 | 49 | //! set the hardware mapping hint, for driver 50 | virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) =0; 51 | 52 | //! flags the meshbuffer as changed, reloads hardware buffers 53 | virtual void setDirty() = 0; 54 | 55 | //! Get the currently used ID for identification of changes. 56 | /** This shouldn't be used for anything outside the VideoDriver. */ 57 | virtual u32 getChangedID() const = 0; 58 | }; 59 | 60 | 61 | } // end namespace scene 62 | } // end namespace irr 63 | 64 | #endif 65 | 66 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IMeshLoader.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_MESH_LOADER_H_INCLUDED__ 6 | #define __I_MESH_LOADER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "path.h" 10 | 11 | namespace irr 12 | { 13 | namespace io 14 | { 15 | class IReadFile; 16 | } // end namespace io 17 | namespace scene 18 | { 19 | class IAnimatedMesh; 20 | 21 | //! Class which is able to load an animated mesh from a file. 22 | /** If you want Irrlicht be able to load meshes of 23 | currently unsupported file formats (e.g. .cob), then implement 24 | this and add your new Meshloader with 25 | ISceneManager::addExternalMeshLoader() to the engine. */ 26 | class IMeshLoader : public virtual IReferenceCounted 27 | { 28 | public: 29 | 30 | //! Destructor 31 | virtual ~IMeshLoader() {} 32 | 33 | //! Returns true if the file might be loaded by this class. 34 | /** This decision should be based on the file extension (e.g. ".cob") 35 | only. 36 | \param filename Name of the file to test. 37 | \return True if the file might be loaded by this class. */ 38 | virtual bool isALoadableFileExtension(const io::path& filename) const = 0; 39 | 40 | //! Creates/loads an animated mesh from the file. 41 | /** \param file File handler to load the file from. 42 | \return Pointer to the created mesh. Returns 0 if loading failed. 43 | If you no longer need the mesh, you should call IAnimatedMesh::drop(). 44 | See IReferenceCounted::drop() for more information. */ 45 | virtual IAnimatedMesh* createMesh(io::IReadFile* file) = 0; 46 | }; 47 | 48 | 49 | } // end namespace scene 50 | } // end namespace irr 51 | 52 | #endif 53 | 54 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IMeshWriter.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __IRR_I_MESH_WRITER_H_INCLUDED__ 6 | #define __IRR_I_MESH_WRITER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "EMeshWriterEnums.h" 10 | 11 | namespace irr 12 | { 13 | namespace io 14 | { 15 | class IWriteFile; 16 | } // end namespace io 17 | 18 | namespace scene 19 | { 20 | class IMesh; 21 | 22 | //! Interface for writing meshes 23 | class IMeshWriter : public virtual IReferenceCounted 24 | { 25 | public: 26 | 27 | //! Destructor 28 | virtual ~IMeshWriter() {} 29 | 30 | //! Get the type of the mesh writer 31 | /** For own implementations, use MAKE_IRR_ID as shown in the 32 | EMESH_WRITER_TYPE enumeration to return your own unique mesh 33 | type id. 34 | \return Type of the mesh writer. */ 35 | virtual EMESH_WRITER_TYPE getType() const = 0; 36 | 37 | //! Write a static mesh. 38 | /** \param file File handle to write the mesh to. 39 | \param mesh Pointer to mesh to be written. 40 | \param flags Optional flags to set properties of the writer. 41 | \return True if sucessful */ 42 | virtual bool writeMesh(io::IWriteFile* file, scene::IMesh* mesh, 43 | s32 flags=EMWF_NONE) = 0; 44 | 45 | // Writes an animated mesh 46 | // for future use, no writer is able to write animated meshes currently 47 | /* \return Returns true if sucessful */ 48 | //virtual bool writeAnimatedMesh(io::IWriteFile* file, 49 | // scene::IAnimatedMesh* mesh, 50 | // s32 flags=EMWF_NONE) = 0; 51 | }; 52 | 53 | 54 | } // end namespace 55 | } // end namespace 56 | 57 | #endif 58 | 59 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IMetaTriangleSelector.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_META_TRIANGLE_SELECTOR_H_INCLUDED__ 6 | #define __I_META_TRIANGLE_SELECTOR_H_INCLUDED__ 7 | 8 | #include "ITriangleSelector.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! Interface for making multiple triangle selectors work as one big selector. 16 | /** This is nothing more than a collection of one or more triangle selectors 17 | providing together the interface of one triangle selector. In this way, 18 | collision tests can be done with different triangle soups in one pass. 19 | */ 20 | class IMetaTriangleSelector : public ITriangleSelector 21 | { 22 | public: 23 | 24 | //! Adds a triangle selector to the collection of triangle selectors. 25 | /** \param toAdd: Pointer to an triangle selector to add to the list. */ 26 | virtual void addTriangleSelector(ITriangleSelector* toAdd) = 0; 27 | 28 | //! Removes a specific triangle selector from the collection. 29 | /** \param toRemove: Pointer to an triangle selector which is in the 30 | list but will be removed. 31 | \return True if successful, false if not. */ 32 | virtual bool removeTriangleSelector(ITriangleSelector* toRemove) = 0; 33 | 34 | //! Removes all triangle selectors from the collection. 35 | virtual void removeAllTriangleSelectors() = 0; 36 | }; 37 | 38 | } // end namespace scene 39 | } // end namespace irr 40 | 41 | 42 | #endif 43 | 44 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IOSOperator.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_OS_OPERATOR_H_INCLUDED__ 6 | #define __I_OS_OPERATOR_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "irrString.h" 10 | 11 | namespace irr 12 | { 13 | 14 | //! The Operating system operator provides operation system specific methods and informations. 15 | class IOSOperator : public virtual IReferenceCounted 16 | { 17 | public: 18 | //! Get the current operation system version as string. 19 | virtual const core::stringc& getOperatingSystemVersion() const = 0; 20 | 21 | //! Get the current operation system version as string. 22 | /** \deprecated Use getOperatingSystemVersion instead. This method will be removed in Irrlicht 1.9. */ 23 | _IRR_DEPRECATED_ const wchar_t* getOperationSystemVersion() const 24 | { 25 | return core::stringw(getOperatingSystemVersion()).c_str(); 26 | } 27 | 28 | //! Copies text to the clipboard 29 | virtual void copyToClipboard(const c8* text) const = 0; 30 | 31 | //! Get text from the clipboard 32 | /** \return Returns 0 if no string is in there. */ 33 | virtual const c8* getTextFromClipboard() const = 0; 34 | 35 | //! Get the processor speed in megahertz 36 | /** \param MHz The integer variable to store the speed in. 37 | \return True if successful, false if not */ 38 | virtual bool getProcessorSpeedMHz(u32* MHz) const = 0; 39 | 40 | //! Get the total and available system RAM 41 | /** \param Total: will contain the total system memory 42 | \param Avail: will contain the available memory 43 | \return True if successful, false if not */ 44 | virtual bool getSystemMemory(u32* Total, u32* Avail) const = 0; 45 | 46 | }; 47 | 48 | } // end namespace 49 | 50 | #endif 51 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleAffector.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_AFFECTOR_H_INCLUDED__ 6 | #define __I_PARTICLE_AFFECTOR_H_INCLUDED__ 7 | 8 | #include "IAttributeExchangingObject.h" 9 | #include "SParticle.h" 10 | 11 | namespace irr 12 | { 13 | namespace scene 14 | { 15 | 16 | //! Types of built in particle affectors 17 | enum E_PARTICLE_AFFECTOR_TYPE 18 | { 19 | EPAT_NONE = 0, 20 | EPAT_ATTRACT, 21 | EPAT_FADE_OUT, 22 | EPAT_GRAVITY, 23 | EPAT_ROTATE, 24 | EPAT_SCALE, 25 | EPAT_COUNT 26 | }; 27 | 28 | //! Names for built in particle affectors 29 | const c8* const ParticleAffectorTypeNames[] = 30 | { 31 | "None", 32 | "Attract", 33 | "FadeOut", 34 | "Gravity", 35 | "Rotate", 36 | "Scale", 37 | 0 38 | }; 39 | 40 | //! A particle affector modifies particles. 41 | class IParticleAffector : public virtual io::IAttributeExchangingObject 42 | { 43 | public: 44 | 45 | //! constructor 46 | IParticleAffector() : Enabled(true) {} 47 | 48 | //! Affects an array of particles. 49 | /** \param now Current time. (Same as ITimer::getTime() would return) 50 | \param particlearray Array of particles. 51 | \param count Amount of particles in array. */ 52 | virtual void affect(u32 now, SParticle* particlearray, u32 count) = 0; 53 | 54 | //! Sets whether or not the affector is currently enabled. 55 | virtual void setEnabled(bool enabled) { Enabled = enabled; } 56 | 57 | //! Gets whether or not the affector is currently enabled. 58 | virtual bool getEnabled() const { return Enabled; } 59 | 60 | //! Get emitter type 61 | virtual E_PARTICLE_AFFECTOR_TYPE getType() const = 0; 62 | 63 | protected: 64 | bool Enabled; 65 | }; 66 | 67 | } // end namespace scene 68 | } // end namespace irr 69 | 70 | 71 | #endif 72 | 73 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleAnimatedMeshSceneNodeEmitter.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_ANIMATED_MESH_SCENE_NODE_EMITTER_H_INCLUDED__ 6 | #define __I_PARTICLE_ANIMATED_MESH_SCENE_NODE_EMITTER_H_INCLUDED__ 7 | 8 | #include "IParticleEmitter.h" 9 | #include "IAnimatedMeshSceneNode.h" 10 | 11 | namespace irr 12 | { 13 | namespace scene 14 | { 15 | 16 | //! A particle emitter which emits particles from mesh vertices. 17 | class IParticleAnimatedMeshSceneNodeEmitter : public IParticleEmitter 18 | { 19 | public: 20 | 21 | //! Set Mesh to emit particles from 22 | virtual void setAnimatedMeshSceneNode( IAnimatedMeshSceneNode* node ) = 0; 23 | 24 | //! Set whether to use vertex normal for direction, or direction specified 25 | virtual void setUseNormalDirection( bool useNormalDirection = true ) = 0; 26 | 27 | //! Set the amount that the normal is divided by for getting a particles direction 28 | virtual void setNormalDirectionModifier( f32 normalDirectionModifier ) = 0; 29 | 30 | //! Sets whether to emit min<->max particles for every vertex or to pick min<->max vertices 31 | virtual void setEveryMeshVertex( bool everyMeshVertex = true ) = 0; 32 | 33 | //! Get mesh we're emitting particles from 34 | virtual const IAnimatedMeshSceneNode* getAnimatedMeshSceneNode() const = 0; 35 | 36 | //! Get whether to use vertex normal for direction, or direction specified 37 | virtual bool isUsingNormalDirection() const = 0; 38 | 39 | //! Get the amount that the normal is divided by for getting a particles direction 40 | virtual f32 getNormalDirectionModifier() const = 0; 41 | 42 | //! Gets whether to emit min<->max particles for every vertex or to pick min<->max vertices 43 | virtual bool getEveryMeshVertex() const = 0; 44 | 45 | //! Get emitter type 46 | virtual E_PARTICLE_EMITTER_TYPE getType() const { return EPET_ANIMATED_MESH; } 47 | }; 48 | 49 | } // end namespace scene 50 | } // end namespace irr 51 | 52 | 53 | #endif // __I_PARTICLE_ANIMATED_MESH_SCENE_NODE_EMITTER_H_INCLUDED__ 54 | 55 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleAttractionAffector.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_ATTRACTION_AFFECTOR_H_INCLUDED__ 6 | #define __I_PARTICLE_ATTRACTION_AFFECTOR_H_INCLUDED__ 7 | 8 | #include "IParticleAffector.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! A particle affector which attracts or detracts particles. 16 | class IParticleAttractionAffector : public IParticleAffector 17 | { 18 | public: 19 | 20 | //! Set the point that particles will attract to 21 | virtual void setPoint( const core::vector3df& point ) = 0; 22 | 23 | //! Set whether or not the particles are attracting or detracting 24 | virtual void setAttract( bool attract ) = 0; 25 | 26 | //! Set whether or not this will affect particles in the X direction 27 | virtual void setAffectX( bool affect ) = 0; 28 | 29 | //! Set whether or not this will affect particles in the Y direction 30 | virtual void setAffectY( bool affect ) = 0; 31 | 32 | //! Set whether or not this will affect particles in the Z direction 33 | virtual void setAffectZ( bool affect ) = 0; 34 | 35 | //! Get the point that particles are attracted to 36 | virtual const core::vector3df& getPoint() const = 0; 37 | 38 | //! Get whether or not the particles are attracting or detracting 39 | virtual bool getAttract() const = 0; 40 | 41 | //! Get whether or not the particles X position are affected 42 | virtual bool getAffectX() const = 0; 43 | 44 | //! Get whether or not the particles Y position are affected 45 | virtual bool getAffectY() const = 0; 46 | 47 | //! Get whether or not the particles Z position are affected 48 | virtual bool getAffectZ() const = 0; 49 | 50 | //! Get emitter type 51 | virtual E_PARTICLE_AFFECTOR_TYPE getType() const { return EPAT_ATTRACT; } 52 | }; 53 | 54 | } // end namespace scene 55 | } // end namespace irr 56 | 57 | 58 | #endif // __I_PARTICLE_ATTRACTION_AFFECTOR_H_INCLUDED__ 59 | 60 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleBoxEmitter.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_BOX_EMITTER_H_INCLUDED__ 6 | #define __I_PARTICLE_BOX_EMITTER_H_INCLUDED__ 7 | 8 | #include "IParticleEmitter.h" 9 | #include "aabbox3d.h" 10 | 11 | namespace irr 12 | { 13 | namespace scene 14 | { 15 | 16 | //! A particle emitter which emits particles from a box shaped space 17 | class IParticleBoxEmitter : public IParticleEmitter 18 | { 19 | public: 20 | 21 | //! Set the box shape 22 | virtual void setBox( const core::aabbox3df& box ) = 0; 23 | 24 | //! Get the box shape set 25 | virtual const core::aabbox3df& getBox() const = 0; 26 | 27 | //! Get emitter type 28 | virtual E_PARTICLE_EMITTER_TYPE getType() const { return EPET_BOX; } 29 | }; 30 | 31 | } // end namespace scene 32 | } // end namespace irr 33 | 34 | 35 | #endif 36 | 37 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleCylinderEmitter.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_CYLINDER_EMITTER_H_INCLUDED__ 6 | #define __I_PARTICLE_CYLINDER_EMITTER_H_INCLUDED__ 7 | 8 | #include "IParticleEmitter.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! A particle emitter which emits from a cylindrically shaped space. 16 | class IParticleCylinderEmitter : public IParticleEmitter 17 | { 18 | public: 19 | 20 | //! Set the center of the radius for the cylinder, at one end of the cylinder 21 | virtual void setCenter( const core::vector3df& center ) = 0; 22 | 23 | //! Set the normal of the cylinder 24 | virtual void setNormal( const core::vector3df& normal ) = 0; 25 | 26 | //! Set the radius of the cylinder 27 | virtual void setRadius( f32 radius ) = 0; 28 | 29 | //! Set the length of the cylinder 30 | virtual void setLength( f32 length ) = 0; 31 | 32 | //! Set whether or not to draw points inside the cylinder 33 | virtual void setOutlineOnly( bool outlineOnly = true ) = 0; 34 | 35 | //! Get the center of the cylinder 36 | virtual const core::vector3df& getCenter() const = 0; 37 | 38 | //! Get the normal of the cylinder 39 | virtual const core::vector3df& getNormal() const = 0; 40 | 41 | //! Get the radius of the cylinder 42 | virtual f32 getRadius() const = 0; 43 | 44 | //! Get the center of the cylinder 45 | virtual f32 getLength() const = 0; 46 | 47 | //! Get whether or not to draw points inside the cylinder 48 | virtual bool getOutlineOnly() const = 0; 49 | 50 | //! Get emitter type 51 | virtual E_PARTICLE_EMITTER_TYPE getType() const { return EPET_CYLINDER; } 52 | }; 53 | 54 | } // end namespace scene 55 | } // end namespace irr 56 | 57 | 58 | #endif 59 | 60 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleFadeOutAffector.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_FADE_OUT_AFFECTOR_H_INCLUDED__ 6 | #define __I_PARTICLE_FADE_OUT_AFFECTOR_H_INCLUDED__ 7 | 8 | #include "IParticleAffector.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! A particle affector which fades out the particles. 16 | class IParticleFadeOutAffector : public IParticleAffector 17 | { 18 | public: 19 | 20 | //! Sets the targetColor, i.e. the color the particles will interpolate to over time. 21 | virtual void setTargetColor( const video::SColor& targetColor ) = 0; 22 | 23 | //! Sets the time in milliseconds it takes for each particle to fade out (minimal 1 ms) 24 | virtual void setFadeOutTime( u32 fadeOutTime ) = 0; 25 | 26 | //! Gets the targetColor, i.e. the color the particles will interpolate to over time. 27 | virtual const video::SColor& getTargetColor() const = 0; 28 | 29 | //! Gets the time in milliseconds it takes for each particle to fade out. 30 | virtual u32 getFadeOutTime() const = 0; 31 | 32 | //! Get emitter type 33 | virtual E_PARTICLE_AFFECTOR_TYPE getType() const { return EPAT_FADE_OUT; } 34 | }; 35 | 36 | } // end namespace scene 37 | } // end namespace irr 38 | 39 | 40 | #endif // __I_PARTICLE_FADE_OUT_AFFECTOR_H_INCLUDED__ 41 | 42 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleGravityAffector.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_GRAVITY_AFFECTOR_H_INCLUDED__ 6 | #define __I_PARTICLE_GRAVITY_AFFECTOR_H_INCLUDED__ 7 | 8 | #include "IParticleAffector.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! A particle affector which applies gravity to particles. 16 | class IParticleGravityAffector : public IParticleAffector 17 | { 18 | public: 19 | 20 | //! Set the time in milliseconds when the gravity force is totally lost 21 | /** At that point the particle does not move any more. */ 22 | virtual void setTimeForceLost( f32 timeForceLost ) = 0; 23 | 24 | //! Set the direction and force of gravity in all 3 dimensions. 25 | virtual void setGravity( const core::vector3df& gravity ) = 0; 26 | 27 | //! Get the time in milliseconds when the gravity force is totally lost 28 | virtual f32 getTimeForceLost() const = 0; 29 | 30 | //! Get the direction and force of gravity. 31 | virtual const core::vector3df& getGravity() const = 0; 32 | 33 | //! Get emitter type 34 | virtual E_PARTICLE_AFFECTOR_TYPE getType() const { return EPAT_GRAVITY; } 35 | }; 36 | 37 | } // end namespace scene 38 | } // end namespace irr 39 | 40 | 41 | #endif // __I_PARTICLE_GRAVITY_AFFECTOR_H_INCLUDED__ 42 | 43 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleMeshEmitter.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_MESH_EMITTER_H_INCLUDED__ 6 | #define __I_PARTICLE_MESH_EMITTER_H_INCLUDED__ 7 | 8 | #include "IParticleEmitter.h" 9 | #include "IMesh.h" 10 | 11 | namespace irr 12 | { 13 | namespace scene 14 | { 15 | 16 | //! A particle emitter which emits from vertices of a mesh 17 | class IParticleMeshEmitter : public IParticleEmitter 18 | { 19 | public: 20 | 21 | //! Set Mesh to emit particles from 22 | virtual void setMesh( IMesh* mesh ) = 0; 23 | 24 | //! Set whether to use vertex normal for direction, or direction specified 25 | virtual void setUseNormalDirection( bool useNormalDirection = true ) = 0; 26 | 27 | //! Set the amount that the normal is divided by for getting a particles direction 28 | virtual void setNormalDirectionModifier( f32 normalDirectionModifier ) = 0; 29 | 30 | //! Sets whether to emit min<->max particles for every vertex or to pick min<->max vertices 31 | virtual void setEveryMeshVertex( bool everyMeshVertex = true ) = 0; 32 | 33 | //! Get Mesh we're emitting particles from 34 | virtual const IMesh* getMesh() const = 0; 35 | 36 | //! Get whether to use vertex normal for direction, or direction specified 37 | virtual bool isUsingNormalDirection() const = 0; 38 | 39 | //! Get the amount that the normal is divided by for getting a particles direction 40 | virtual f32 getNormalDirectionModifier() const = 0; 41 | 42 | //! Gets whether to emit min<->max particles for every vertex or to pick min<->max vertices 43 | virtual bool getEveryMeshVertex() const = 0; 44 | 45 | //! Get emitter type 46 | virtual E_PARTICLE_EMITTER_TYPE getType() const { return EPET_MESH; } 47 | }; 48 | 49 | } // end namespace scene 50 | } // end namespace irr 51 | 52 | 53 | #endif 54 | 55 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleRingEmitter.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_RING_EMITTER_H_INCLUDED__ 6 | #define __I_PARTICLE_RING_EMITTER_H_INCLUDED__ 7 | 8 | #include "IParticleEmitter.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! A particle emitter which emits particles along a ring shaped area. 16 | class IParticleRingEmitter : public IParticleEmitter 17 | { 18 | public: 19 | 20 | //! Set the center of the ring 21 | virtual void setCenter( const core::vector3df& center ) = 0; 22 | 23 | //! Set the radius of the ring 24 | virtual void setRadius( f32 radius ) = 0; 25 | 26 | //! Set the thickness of the ring 27 | virtual void setRingThickness( f32 ringThickness ) = 0; 28 | 29 | //! Get the center of the ring 30 | virtual const core::vector3df& getCenter() const = 0; 31 | 32 | //! Get the radius of the ring 33 | virtual f32 getRadius() const = 0; 34 | 35 | //! Get the thickness of the ring 36 | virtual f32 getRingThickness() const = 0; 37 | 38 | //! Get emitter type 39 | virtual E_PARTICLE_EMITTER_TYPE getType() const { return EPET_RING; } 40 | }; 41 | 42 | } // end namespace scene 43 | } // end namespace irr 44 | 45 | 46 | #endif 47 | 48 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleRotationAffector.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_ROTATION_AFFECTOR_H_INCLUDED__ 6 | #define __I_PARTICLE_ROTATION_AFFECTOR_H_INCLUDED__ 7 | 8 | #include "IParticleAffector.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! A particle affector which rotates the particle system. 16 | class IParticleRotationAffector : public IParticleAffector 17 | { 18 | public: 19 | 20 | //! Set the point that particles will rotate around 21 | virtual void setPivotPoint( const core::vector3df& point ) = 0; 22 | 23 | //! Set the speed in degrees per second in all 3 dimensions 24 | virtual void setSpeed( const core::vector3df& speed ) = 0; 25 | 26 | //! Get the point that particles are attracted to 27 | virtual const core::vector3df& getPivotPoint() const = 0; 28 | 29 | //! Get the speed in degrees per second in all 3 dimensions 30 | virtual const core::vector3df& getSpeed() const = 0; 31 | 32 | //! Get emitter type 33 | virtual E_PARTICLE_AFFECTOR_TYPE getType() const { return EPAT_ROTATE; } 34 | }; 35 | 36 | } // end namespace scene 37 | } // end namespace irr 38 | 39 | 40 | #endif // __I_PARTICLE_ROTATION_AFFECTOR_H_INCLUDED__ 41 | 42 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IParticleSphereEmitter.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_PARTICLE_SPHERE_EMITTER_H_INCLUDED__ 6 | #define __I_PARTICLE_SPHERE_EMITTER_H_INCLUDED__ 7 | 8 | #include "IParticleEmitter.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! A particle emitter which emits from a spherical space. 16 | class IParticleSphereEmitter : public IParticleEmitter 17 | { 18 | public: 19 | 20 | //! Set the center of the sphere for particle emissions 21 | virtual void setCenter( const core::vector3df& center ) = 0; 22 | 23 | //! Set the radius of the sphere for particle emissions 24 | virtual void setRadius( f32 radius ) = 0; 25 | 26 | //! Get the center of the sphere for particle emissions 27 | virtual const core::vector3df& getCenter() const = 0; 28 | 29 | //! Get the radius of the sphere for particle emissions 30 | virtual f32 getRadius() const = 0; 31 | 32 | //! Get emitter type 33 | virtual E_PARTICLE_EMITTER_TYPE getType() const { return EPET_SPHERE; } 34 | }; 35 | 36 | } // end namespace scene 37 | } // end namespace irr 38 | 39 | 40 | #endif 41 | 42 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IQ3LevelMesh.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_Q3_LEVEL_MESH_H_INCLUDED__ 6 | #define __I_Q3_LEVEL_MESH_H_INCLUDED__ 7 | 8 | #include "IAnimatedMesh.h" 9 | #include "IQ3Shader.h" 10 | 11 | namespace irr 12 | { 13 | namespace scene 14 | { 15 | //! Interface for a Mesh which can be loaded directly from a Quake3 .bsp-file. 16 | /** The Mesh tries to load all textures of the map.*/ 17 | class IQ3LevelMesh : public IAnimatedMesh 18 | { 19 | public: 20 | 21 | //! loads the shader definition from file 22 | /** \param filename Name of the shaderfile, defaults to /scripts if fileNameIsValid is false. 23 | \param fileNameIsValid Specifies whether the filename is valid in the current situation. */ 24 | virtual const quake3::IShader* getShader( const c8* filename, bool fileNameIsValid=true ) = 0; 25 | 26 | //! returns a already loaded Shader 27 | virtual const quake3::IShader* getShader(u32 index) const = 0; 28 | 29 | //! get's an interface to the entities 30 | virtual quake3::tQ3EntityList& getEntityList() = 0; 31 | 32 | //! returns the requested brush entity 33 | /** \param num The number from the model key of the entity. 34 | 35 | Use this interface if you parse the entities yourself.*/ 36 | virtual IMesh* getBrushEntityMesh(s32 num) const = 0; 37 | 38 | //! returns the requested brush entity 39 | virtual IMesh* getBrushEntityMesh(quake3::IEntity &ent) const = 0; 40 | }; 41 | 42 | } // end namespace scene 43 | } // end namespace irr 44 | 45 | #endif 46 | 47 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IRandomizer.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_RANDOMIZER_H_INCLUDED__ 6 | #define __I_RANDOMIZER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | 10 | namespace irr 11 | { 12 | 13 | //! Interface for generating random numbers 14 | class IRandomizer : public virtual IReferenceCounted 15 | { 16 | public: 17 | //! resets the randomizer 18 | /** \param value Initialization value (seed) */ 19 | virtual void reset(s32 value=0x0f0f0f0f) =0; 20 | 21 | //! generates a pseudo random number in the range 0..randMax() 22 | virtual s32 rand() const =0; 23 | 24 | //! generates a pseudo random number in the range 0..1 25 | virtual f32 frand() const =0; 26 | 27 | //! get maxmimum number generated by rand() 28 | virtual s32 randMax() const =0; 29 | }; 30 | 31 | } // end namespace irr 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IReadFile.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_READ_FILE_H_INCLUDED__ 6 | #define __I_READ_FILE_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "coreutil.h" 10 | 11 | namespace irr 12 | { 13 | namespace io 14 | { 15 | 16 | //! Interface providing read acess to a file. 17 | class IReadFile : public virtual IReferenceCounted 18 | { 19 | public: 20 | //! Reads an amount of bytes from the file. 21 | /** \param buffer Pointer to buffer where read bytes are written to. 22 | \param sizeToRead Amount of bytes to read from the file. 23 | \return How many bytes were read. */ 24 | virtual s32 read(void* buffer, u32 sizeToRead) = 0; 25 | 26 | //! Changes position in file 27 | /** \param finalPos Destination position in the file. 28 | \param relativeMovement If set to true, the position in the file is 29 | changed relative to current position. Otherwise the position is changed 30 | from beginning of file. 31 | \return True if successful, otherwise false. */ 32 | virtual bool seek(long finalPos, bool relativeMovement = false) = 0; 33 | 34 | //! Get size of file. 35 | /** \return Size of the file in bytes. */ 36 | virtual long getSize() const = 0; 37 | 38 | //! Get the current position in the file. 39 | /** \return Current position in the file in bytes. */ 40 | virtual long getPos() const = 0; 41 | 42 | //! Get name of file. 43 | /** \return File name as zero terminated character string. */ 44 | virtual const io::path& getFileName() const = 0; 45 | }; 46 | 47 | //! Internal function, please do not use. 48 | IReadFile* createReadFile(const io::path& fileName); 49 | //! Internal function, please do not use. 50 | IReadFile* createLimitReadFile(const io::path& fileName, IReadFile* alreadyOpenedFile, long pos, long areaSize); 51 | //! Internal function, please do not use. 52 | IReadFile* createMemoryReadFile(void* memory, long size, const io::path& fileName, bool deleteMemoryWhenDropped); 53 | 54 | } // end namespace io 55 | } // end namespace irr 56 | 57 | #endif 58 | 59 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/ISceneNodeAnimatorCameraMaya.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_SCENE_NODE_ANIMATOR_CAMERA_MAYA_H_INCLUDED__ 6 | #define __I_SCENE_NODE_ANIMATOR_CAMERA_MAYA_H_INCLUDED__ 7 | 8 | #include "ISceneNodeAnimator.h" 9 | 10 | namespace irr 11 | { 12 | 13 | namespace scene 14 | { 15 | 16 | //! Special scene node animator for Maya-style cameras 17 | /** This scene node animator can be attached to a camera to make it act like a 3d 18 | modelling tool. 19 | The camera is moving relative to the target with the mouse, by pressing either 20 | of the three buttons. 21 | In order to move the camera, set a new target for the camera. The distance defines 22 | the current orbit radius the camera moves on. Distance can be changed via the setter 23 | or by mouse events. 24 | */ 25 | class ISceneNodeAnimatorCameraMaya : public ISceneNodeAnimator 26 | { 27 | public: 28 | 29 | //! Returns the speed of movement 30 | virtual f32 getMoveSpeed() const = 0; 31 | 32 | //! Sets the speed of movement 33 | virtual void setMoveSpeed(f32 moveSpeed) = 0; 34 | 35 | //! Returns the rotation speed 36 | virtual f32 getRotateSpeed() const = 0; 37 | 38 | //! Set the rotation speed 39 | virtual void setRotateSpeed(f32 rotateSpeed) = 0; 40 | 41 | //! Returns the zoom speed 42 | virtual f32 getZoomSpeed() const = 0; 43 | 44 | //! Set the zoom speed 45 | virtual void setZoomSpeed(f32 zoomSpeed) = 0; 46 | 47 | //! Returns the current distance, i.e. orbit radius 48 | virtual f32 getDistance() const = 0; 49 | 50 | //! Set the distance 51 | virtual void setDistance(f32 distance) = 0; 52 | }; 53 | 54 | } // end namespace scene 55 | } // end namespace irr 56 | 57 | #endif 58 | 59 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/ISceneUserDataSerializer.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_SCENE_USER_DATA_SERIALIZER_H_INCLUDED__ 6 | #define __I_SCENE_USER_DATA_SERIALIZER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | 10 | namespace irr 11 | { 12 | namespace io 13 | { 14 | class IAttributes; 15 | } // end namespace io 16 | namespace scene 17 | { 18 | class ISceneNode; 19 | 20 | //! Interface to read and write user data to and from .irr files. 21 | /** This interface is to be implemented by the user, to make it possible to read 22 | and write user data when reading or writing .irr files via ISceneManager. 23 | To be used with ISceneManager::loadScene() and ISceneManager::saveScene() */ 24 | class ISceneUserDataSerializer 25 | { 26 | public: 27 | 28 | virtual ~ISceneUserDataSerializer() {} 29 | 30 | //! Called when the scene manager create a scene node while loading a file. 31 | virtual void OnCreateNode(ISceneNode* node) = 0; 32 | 33 | //! Called when the scene manager read a scene node while loading a file. 34 | /** The userData pointer contains a list of attributes with userData which 35 | were attached to the scene node in the read scene file.*/ 36 | virtual void OnReadUserData(ISceneNode* forSceneNode, io::IAttributes* userData) = 0; 37 | 38 | //! Called when the scene manager is writing a scene node to an xml file for example. 39 | /** Implement this method and return a list of attributes containing the user data 40 | you want to be saved together with the scene node. Return 0 if no user data should 41 | be added. Please note that the scene manager will call drop() to the returned pointer 42 | after it no longer needs it, so if you didn't create a new object for the return value 43 | and returning a longer existing IAttributes object, simply call grab() before returning it. */ 44 | virtual io::IAttributes* createUserData(ISceneNode* forSceneNode) = 0; 45 | }; 46 | 47 | } // end namespace scene 48 | } // end namespace irr 49 | 50 | #endif 51 | 52 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IShadowVolumeSceneNode.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_SHADOW_VOLUME_SCENE_NODE_H_INCLUDED__ 6 | #define __I_SHADOW_VOLUME_SCENE_NODE_H_INCLUDED__ 7 | 8 | #include "ISceneNode.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | class IMesh; 15 | 16 | //! Scene node for rendering a shadow volume into a stencil buffer. 17 | class IShadowVolumeSceneNode : public ISceneNode 18 | { 19 | public: 20 | 21 | //! constructor 22 | IShadowVolumeSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id) 23 | : ISceneNode(parent, mgr, id) {} 24 | 25 | //! Sets the mesh from which the shadow volume should be generated. 26 | /** To optimize shadow rendering, use a simpler mesh for shadows. 27 | */ 28 | virtual void setShadowMesh(const IMesh* mesh) = 0; 29 | 30 | //! Updates the shadow volumes for current light positions. 31 | virtual void updateShadowVolumes() = 0; 32 | }; 33 | 34 | } // end namespace scene 35 | } // end namespace irr 36 | 37 | #endif 38 | 39 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/ITextSceneNode.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_TEXT_SCENE_NODE_H_INCLUDED__ 6 | #define __I_TEXT_SCENE_NODE_H_INCLUDED__ 7 | 8 | #include "ISceneNode.h" 9 | 10 | namespace irr 11 | { 12 | namespace scene 13 | { 14 | 15 | //! A scene node for displaying 2d text at a position in three dimensional space 16 | class ITextSceneNode : public ISceneNode 17 | { 18 | public: 19 | 20 | //! constructor 21 | ITextSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id, 22 | const core::vector3df& position = core::vector3df(0,0,0)) 23 | : ISceneNode(parent, mgr, id, position) {} 24 | 25 | //! sets the text string 26 | virtual void setText(const wchar_t* text) = 0; 27 | 28 | //! sets the color of the text 29 | virtual void setTextColor(video::SColor color) = 0; 30 | }; 31 | 32 | } // end namespace scene 33 | } // end namespace irr 34 | 35 | 36 | #endif 37 | 38 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IVertexBuffer.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2008-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_VERTEX_BUFFER_H_INCLUDED__ 6 | #define __I_VERTEX_BUFFER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "irrArray.h" 10 | #include "S3DVertex.h" 11 | 12 | namespace irr 13 | { 14 | namespace scene 15 | { 16 | 17 | class IVertexBuffer : public virtual IReferenceCounted 18 | { 19 | public: 20 | virtual void* getData() =0; 21 | virtual video::E_VERTEX_TYPE getType() const =0; 22 | virtual void setType(video::E_VERTEX_TYPE vertexType) =0; 23 | virtual u32 stride() const =0; 24 | virtual u32 size() const =0; 25 | virtual void push_back(const video::S3DVertex &element) =0; 26 | virtual video::S3DVertex& operator [](const u32 index) const =0; 27 | virtual video::S3DVertex& getLast() =0; 28 | virtual void set_used(u32 usedNow) =0; 29 | virtual void reallocate(u32 new_size) =0; 30 | virtual u32 allocated_size() const =0; 31 | virtual video::S3DVertex* pointer() =0; 32 | 33 | //! get the current hardware mapping hint 34 | virtual E_HARDWARE_MAPPING getHardwareMappingHint() const =0; 35 | 36 | //! set the hardware mapping hint, for driver 37 | virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) =0; 38 | 39 | //! flags the meshbuffer as changed, reloads hardware buffers 40 | virtual void setDirty() =0; 41 | 42 | //! Get the currently used ID for identification of changes. 43 | /** This shouldn't be used for anything outside the VideoDriver. */ 44 | virtual u32 getChangedID() const = 0; 45 | }; 46 | 47 | 48 | } // end namespace scene 49 | } // end namespace irr 50 | 51 | #endif 52 | 53 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IVolumeLightSceneNode.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | // 5 | // created by Dean Wadsworth aka Varmint Dec 31 2007 6 | 7 | #ifndef __I_VOLUME_LIGHT_SCENE_NODE_H_INCLUDED__ 8 | #define __I_VOLUME_LIGHT_SCENE_NODE_H_INCLUDED__ 9 | 10 | #include "ISceneNode.h" 11 | 12 | namespace irr 13 | { 14 | namespace scene 15 | { 16 | class IMeshBuffer; 17 | 18 | class IVolumeLightSceneNode : public ISceneNode 19 | { 20 | public: 21 | 22 | //! constructor 23 | IVolumeLightSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id, 24 | const core::vector3df& position, 25 | const core::vector3df& rotation, 26 | const core::vector3df& scale) 27 | : ISceneNode(parent, mgr, id, position, rotation, scale) {}; 28 | 29 | //! Returns type of the scene node 30 | virtual ESCENE_NODE_TYPE getType() const { return ESNT_VOLUME_LIGHT; } 31 | 32 | //! Sets the number of segments across the U axis 33 | virtual void setSubDivideU(const u32 inU) =0; 34 | 35 | //! Sets the number of segments across the V axis 36 | virtual void setSubDivideV(const u32 inV) =0; 37 | 38 | //! Returns the number of segments across the U axis 39 | virtual u32 getSubDivideU() const =0; 40 | 41 | //! Returns the number of segments across the V axis 42 | virtual u32 getSubDivideV() const =0; 43 | 44 | //! Sets the color of the base of the light 45 | virtual void setFootColor(const video::SColor inColor) =0; 46 | 47 | //! Sets the color of the tip of the light 48 | virtual void setTailColor(const video::SColor inColor) =0; 49 | 50 | //! Returns the color of the base of the light 51 | virtual video::SColor getFootColor() const =0; 52 | 53 | //! Returns the color of the tip of the light 54 | virtual video::SColor getTailColor() const =0; 55 | }; 56 | 57 | } // end namespace scene 58 | } // end namespace irr 59 | 60 | #endif 61 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IWriteFile.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_WRITE_FILE_H_INCLUDED__ 6 | #define __I_WRITE_FILE_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "path.h" 10 | 11 | namespace irr 12 | { 13 | namespace io 14 | { 15 | 16 | //! Interface providing write access to a file. 17 | class IWriteFile : public virtual IReferenceCounted 18 | { 19 | public: 20 | //! Writes an amount of bytes to the file. 21 | /** \param buffer Pointer to buffer of bytes to write. 22 | \param sizeToWrite Amount of bytes to write to the file. 23 | \return How much bytes were written. */ 24 | virtual s32 write(const void* buffer, u32 sizeToWrite) = 0; 25 | 26 | //! Changes position in file 27 | /** \param finalPos Destination position in the file. 28 | \param relativeMovement If set to true, the position in the file is 29 | changed relative to current position. Otherwise the position is changed 30 | from begin of file. 31 | \return True if successful, otherwise false. */ 32 | virtual bool seek(long finalPos, bool relativeMovement = false) = 0; 33 | 34 | //! Get the current position in the file. 35 | /** \return Current position in the file in bytes. */ 36 | virtual long getPos() const = 0; 37 | 38 | //! Get name of file. 39 | /** \return File name as zero terminated character string. */ 40 | virtual const path& getFileName() const = 0; 41 | }; 42 | 43 | //! Internal function, please do not use. 44 | IWriteFile* createWriteFile(const io::path& fileName, bool append); 45 | 46 | } // end namespace io 47 | } // end namespace irr 48 | 49 | #endif 50 | 51 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/IXMLReader.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __I_XML_READER_H_INCLUDED__ 6 | #define __I_XML_READER_H_INCLUDED__ 7 | 8 | #include "IReferenceCounted.h" 9 | #include "irrXML.h" 10 | 11 | namespace irr 12 | { 13 | namespace io 14 | { 15 | //! An xml reader for wide characters, derived from IReferenceCounted. 16 | /** This XML Parser can read any type of text files from any source 17 | Irrlicht can read. Just call IFileSystem::createXMLReader(). For more 18 | informations on how to use the parser, see IIrrXMLReader */ 19 | typedef IIrrXMLReader IXMLReader; 20 | 21 | //! An xml reader for ASCII or UTF-8 characters, derived from IReferenceCounted. 22 | /** This XML Parser can read any type of text files from any source 23 | Irrlicht can read. Just call IFileSystem::createXMLReaderUTF8(). For 24 | more informations on how to use the parser, see IIrrXMLReader */ 25 | typedef IIrrXMLReader IXMLReaderUTF8; 26 | 27 | } // end namespace io 28 | } // end namespace irr 29 | 30 | #endif 31 | 32 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/Keycodes.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/irrlicht/include/Keycodes.h -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/SKeyMap.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __S_KEY_MAP_H_INCLUDED__ 6 | #define __S_KEY_MAP_H_INCLUDED__ 7 | 8 | #include "Keycodes.h" 9 | 10 | namespace irr 11 | { 12 | 13 | //! enumeration for key actions. Used for example in the FPS Camera. 14 | enum EKEY_ACTION 15 | { 16 | EKA_MOVE_FORWARD = 0, 17 | EKA_MOVE_BACKWARD, 18 | EKA_STRAFE_LEFT, 19 | EKA_STRAFE_RIGHT, 20 | EKA_JUMP_UP, 21 | EKA_CROUCH, 22 | EKA_COUNT, 23 | 24 | //! This value is not used. It only forces this enumeration to compile in 32 bit. 25 | EKA_FORCE_32BIT = 0x7fffffff 26 | }; 27 | 28 | //! Struct storing which key belongs to which action. 29 | struct SKeyMap 30 | { 31 | SKeyMap() {} 32 | SKeyMap(EKEY_ACTION action, EKEY_CODE keyCode) : Action(action), KeyCode(keyCode) {} 33 | 34 | EKEY_ACTION Action; 35 | EKEY_CODE KeyCode; 36 | }; 37 | 38 | } // end namespace irr 39 | 40 | #endif 41 | 42 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/SMeshBuffer.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | // replaced by template 6 | #include "CMeshBuffer.h" 7 | 8 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/SMeshBufferLightMap.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | // replaced by template 6 | #include "CMeshBuffer.h" 7 | 8 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/SMeshBufferTangents.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | // replaced by template 6 | #include "CMeshBuffer.h" 7 | 8 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/SParticle.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __S_PARTICLE_H_INCLUDED__ 6 | #define __S_PARTICLE_H_INCLUDED__ 7 | 8 | #include "vector3d.h" 9 | #include "dimension2d.h" 10 | #include "SColor.h" 11 | 12 | namespace irr 13 | { 14 | namespace scene 15 | { 16 | //! Struct for holding particle data 17 | struct SParticle 18 | { 19 | //! Position of the particle 20 | core::vector3df pos; 21 | 22 | //! Direction and speed of the particle 23 | core::vector3df vector; 24 | 25 | //! Start life time of the particle 26 | u32 startTime; 27 | 28 | //! End life time of the particle 29 | u32 endTime; 30 | 31 | //! Current color of the particle 32 | video::SColor color; 33 | 34 | //! Original color of the particle. 35 | /** That's the color of the particle it had when it was emitted. */ 36 | video::SColor startColor; 37 | 38 | //! Original direction and speed of the particle. 39 | /** The direction and speed the particle had when it was emitted. */ 40 | core::vector3df startVector; 41 | 42 | //! Scale of the particle. 43 | /** The current scale of the particle. */ 44 | core::dimension2df size; 45 | 46 | //! Original scale of the particle. 47 | /** The scale of the particle when it was emitted. */ 48 | core::dimension2df startSize; 49 | }; 50 | 51 | 52 | } // end namespace scene 53 | } // end namespace irr 54 | 55 | #endif 56 | 57 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/SVertexIndex.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2008-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __S_VERTEX_INDEX_H_INCLUDED__ 6 | #define __S_VERTEX_INDEX_H_INCLUDED__ 7 | 8 | #include "irrTypes.h" 9 | 10 | 11 | namespace irr 12 | { 13 | namespace video 14 | { 15 | enum E_INDEX_TYPE 16 | { 17 | EIT_16BIT = 0, 18 | EIT_32BIT 19 | }; 20 | 21 | 22 | /* 23 | //! vertex index used by the Irrlicht engine. 24 | template 25 | struct SSpecificVertexIndex 26 | { 27 | T Index; 28 | 29 | //! default constructor 30 | SSpecificVertexIndex() {} 31 | 32 | //! constructor 33 | SSpecificVertexIndex(u32 _index) :Index(_index) {} 34 | 35 | bool operator==(const SSpecificVertexIndex& other) const 36 | { 37 | return (Index == other.Index); 38 | } 39 | 40 | bool operator!=(const SSpecificVertexIndex& other) const 41 | { 42 | return (Index != other.Index); 43 | } 44 | 45 | bool operator<(const SSpecificVertexIndex& other) const 46 | { 47 | return (Index < other.Index); 48 | } 49 | 50 | SSpecificVertexIndex operator+(const u32& other) const 51 | { 52 | return SSpecificVertexIndex(Index + other); 53 | } 54 | 55 | operator const u32() const 56 | { 57 | return (const u32)Index; 58 | } 59 | 60 | E_INDEX_TYPE getType() const 61 | { 62 | if (sizeof(T)==sizeof(u16)) 63 | return video::EIT_16BIT; 64 | return video::EIT_32BIT; 65 | } 66 | 67 | }; 68 | 69 | //typedef SSpecificVertexIndex SVertexIndex; 70 | 71 | typedef u32 SVertexIndex; 72 | */ 73 | 74 | 75 | } // end namespace video 76 | } // end namespace irr 77 | 78 | #endif 79 | 80 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/driverChoice.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2009-2012 Christian Stehno 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __E_DRIVER_CHOICE_H_INCLUDED__ 6 | #define __E_DRIVER_CHOICE_H_INCLUDED__ 7 | 8 | #include 9 | #include 10 | #include "EDriverTypes.h" 11 | #include "irrTypes.h" 12 | #include "IrrlichtDevice.h" 13 | 14 | namespace irr 15 | { 16 | 17 | //! ask user for driver 18 | static irr::video::E_DRIVER_TYPE driverChoiceConsole(bool allDrivers=true) 19 | { 20 | const char* const names[] = {"NullDriver","Software Renderer","Burning's Video","Direct3D 8.1","Direct3D 9.0c","OpenGL 1.x/2.x/3.x"}; 21 | printf("Please select the driver you want:\n"); 22 | irr::u32 i=0; 23 | for (i=irr::video::EDT_COUNT; i>0; --i) 24 | { 25 | if (allDrivers || (irr::IrrlichtDevice::isDriverSupported(irr::video::E_DRIVER_TYPE(i-1)))) 26 | printf(" (%c) %s\n", 'a'+irr::video::EDT_COUNT-i, names[i-1]); 27 | } 28 | 29 | char c; 30 | std::cin >> c; 31 | c = irr::video::EDT_COUNT+'a'-c; 32 | 33 | for (i=irr::video::EDT_COUNT; i>0; --i) 34 | { 35 | if (!(allDrivers || (irr::IrrlichtDevice::isDriverSupported(irr::video::E_DRIVER_TYPE(i-1))))) 36 | --c; 37 | if ((char)i==c) 38 | return irr::video::E_DRIVER_TYPE(i-1); 39 | } 40 | return irr::video::EDT_COUNT; 41 | } 42 | 43 | } // end namespace irr 44 | 45 | #endif 46 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/heapsort.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __IRR_HEAPSORT_H_INCLUDED__ 6 | #define __IRR_HEAPSORT_H_INCLUDED__ 7 | 8 | #include "irrTypes.h" 9 | 10 | namespace irr 11 | { 12 | namespace core 13 | { 14 | 15 | //! Sinks an element into the heap. 16 | template 17 | inline void heapsink(T*array, s32 element, s32 max) 18 | { 19 | while ((element<<1) < max) // there is a left child 20 | { 21 | s32 j = (element<<1); 22 | 23 | if (j+1 < max && array[j] < array[j+1]) 24 | j = j+1; // take right child 25 | 26 | if (array[element] < array[j]) 27 | { 28 | T t = array[j]; // swap elements 29 | array[j] = array[element]; 30 | array[element] = t; 31 | element = j; 32 | } 33 | else 34 | return; 35 | } 36 | } 37 | 38 | 39 | //! Sorts an array with size 'size' using heapsort. 40 | template 41 | inline void heapsort(T* array_, s32 size) 42 | { 43 | // for heapsink we pretent this is not c++, where 44 | // arrays start with index 0. So we decrease the array pointer, 45 | // the maximum always +2 and the element always +1 46 | 47 | T* virtualArray = array_ - 1; 48 | s32 virtualSize = size + 2; 49 | s32 i; 50 | 51 | // build heap 52 | 53 | for (i=((size-1)/2); i>=0; --i) 54 | heapsink(virtualArray, i+1, virtualSize-1); 55 | 56 | // sort array, leave out the last element (0) 57 | for (i=size-1; i>0; --i) 58 | { 59 | T t = array_[0]; 60 | array_[0] = array_[i]; 61 | array_[i] = t; 62 | heapsink(virtualArray, 1, i + 1); 63 | } 64 | } 65 | 66 | } // end namespace core 67 | } // end namespace irr 68 | 69 | #endif 70 | 71 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/irrpack.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2007-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | // include this file right before the data structures to be 1-aligned 6 | // and add to each structure the PACK_STRUCT define just like this: 7 | // struct mystruct 8 | // { 9 | // ... 10 | // } PACK_STRUCT; 11 | // Always include the irrunpack.h file right after the last type declared 12 | // like this, and do not put any other types with different alignment 13 | // in between! 14 | 15 | // byte-align structures 16 | #if defined(_MSC_VER) || defined(__BORLANDC__) || defined (__BCPLUSPLUS__) 17 | # pragma warning(disable: 4103) 18 | # pragma pack( push, packing ) 19 | # pragma pack( 1 ) 20 | # define PACK_STRUCT 21 | #elif defined( __DMC__ ) 22 | # pragma pack( push, 1 ) 23 | # define PACK_STRUCT 24 | #elif defined( __GNUC__ ) 25 | // Using pragma pack might work with earlier gcc versions already, but 26 | // it started to be necessary with gcc 4.7 on mingw unless compiled with -mno-ms-bitfields. 27 | // And I found some hints on the web that older gcc versions on the other hand had sometimes 28 | // trouble with pragma pack while they worked with __attribute__((packed)). 29 | # if (__GNUC__ > 4 ) || ((__GNUC__ == 4 ) && (__GNUC_MINOR__ >= 7)) 30 | # pragma pack( push, packing ) 31 | # pragma pack( 1 ) 32 | # define PACK_STRUCT 33 | # else 34 | # define PACK_STRUCT __attribute__((packed)) 35 | #endif 36 | #else 37 | # error compiler not supported 38 | #endif 39 | 40 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/irrunpack.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2007-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | // include this file to switch back to default alignment 6 | // file belongs to irrpack.h, see there for more info 7 | 8 | // Default alignment 9 | #if defined(_MSC_VER) || defined(__BORLANDC__) || defined (__BCPLUSPLUS__) 10 | # pragma pack( pop, packing ) 11 | #elif defined (__DMC__) 12 | # pragma pack( pop ) 13 | #elif defined( __GNUC__ ) 14 | # if (__GNUC__ > 4 ) || ((__GNUC__ == 4 ) && (__GNUC_MINOR__ >= 7)) 15 | # pragma pack( pop, packing ) 16 | # endif 17 | #endif 18 | 19 | #undef PACK_STRUCT 20 | 21 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/path.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine" and the "irrXML" project. 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | #ifndef __IRR_PATH_H_INCLUDED__ 6 | #define __IRR_PATH_H_INCLUDED__ 7 | 8 | #include "irrString.h" 9 | 10 | namespace irr 11 | { 12 | namespace io 13 | { 14 | 15 | //! Type used for all file system related strings. 16 | /** This type will transparently handle different file system encodings. */ 17 | typedef core::string path; 18 | 19 | //! Used in places where we identify objects by a filename, but don't actually work with the real filename 20 | /** Irrlicht is internally not case-sensitive when it comes to names. 21 | Also this class is a first step towards support for correctly serializing renamed objects. 22 | */ 23 | struct SNamedPath 24 | { 25 | //! Constructor 26 | SNamedPath() {} 27 | 28 | //! Constructor 29 | SNamedPath(const path& p) : Path(p), InternalName( PathToName(p) ) 30 | { 31 | } 32 | 33 | //! Is smaller comparator 34 | bool operator <(const SNamedPath& other) const 35 | { 36 | return InternalName < other.InternalName; 37 | } 38 | 39 | //! Set the path. 40 | void setPath(const path& p) 41 | { 42 | Path = p; 43 | InternalName = PathToName(p); 44 | } 45 | 46 | //! Get the path. 47 | const path& getPath() const 48 | { 49 | return Path; 50 | }; 51 | 52 | //! Get the name which is used to identify the file. 53 | //! This string is similar to the names and filenames used before Irrlicht 1.7 54 | const path& getInternalName() const 55 | { 56 | return InternalName; 57 | } 58 | 59 | //! Implicit cast to io::path 60 | operator core::stringc() const 61 | { 62 | return core::stringc(getPath()); 63 | } 64 | //! Implicit cast to io::path 65 | operator core::stringw() const 66 | { 67 | return core::stringw(getPath()); 68 | } 69 | 70 | protected: 71 | // convert the given path string to a name string. 72 | path PathToName(const path& p) const 73 | { 74 | path name(p); 75 | name.replace( '\\', '/' ); 76 | name.make_lower(); 77 | return name; 78 | } 79 | 80 | private: 81 | path Path; 82 | path InternalName; 83 | }; 84 | 85 | } // io 86 | } // irr 87 | 88 | #endif // __IRR_PATH_H_INCLUDED__ 89 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/include/position2d.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt 2 | // This file is part of the "Irrlicht Engine". 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h 4 | 5 | //! As of Irrlicht 1.6, position2d is a synonym for vector2d. 6 | /** You should consider position2d to be deprecated, and use vector2d by preference. */ 7 | 8 | #ifndef __IRR_POSITION_H_INCLUDED__ 9 | #define __IRR_POSITION_H_INCLUDED__ 10 | 11 | #include "vector2d.h" 12 | 13 | namespace irr 14 | { 15 | namespace core 16 | { 17 | 18 | // Use typedefs where possible as they are more explicit... 19 | 20 | //! \deprecated position2d is now a synonym for vector2d, but vector2d should be used directly. 21 | typedef vector2d position2df; 22 | 23 | //! \deprecated position2d is now a synonym for vector2d, but vector2d should be used directly. 24 | typedef vector2d position2di; 25 | } // namespace core 26 | } // namespace irr 27 | 28 | // ...and use a #define to catch the rest, for (e.g.) position2d 29 | #define position2d vector2d 30 | 31 | #endif // __IRR_POSITION_H_INCLUDED__ 32 | 33 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/lib/Win32-gcc/libIrrlicht.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/irrlicht/lib/Win32-gcc/libIrrlicht.a -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/lib/Win32-gcc/libIrrlicht.def: -------------------------------------------------------------------------------- 1 | EXPORTS 2 | _ZN3irr2io18createIrrXMLReaderEP6_iobuf @1 3 | _ZN3irr2io18createIrrXMLReaderEPKc @2 4 | _ZN3irr2io18createIrrXMLReaderEPNS0_17IFileReadCallBackEb @3 5 | _ZN3irr2io23createIrrXMLReaderUTF16EP6_iobuf @4 6 | _ZN3irr2io23createIrrXMLReaderUTF16EPKc @5 7 | _ZN3irr2io23createIrrXMLReaderUTF16EPNS0_17IFileReadCallBackEb @6 8 | _ZN3irr2io23createIrrXMLReaderUTF32EP6_iobuf @7 9 | _ZN3irr2io23createIrrXMLReaderUTF32EPKc @8 10 | _ZN3irr2io23createIrrXMLReaderUTF32EPNS0_17IFileReadCallBackEb @9 11 | _ZN3irr4core14IdentityMatrixE @10 DATA 12 | _ZN3irr4core21LOCALE_DECIMAL_POINTSE @11 DATA 13 | _ZN3irr5video16IdentityMaterialE @12 DATA 14 | createDevice @13 15 | createDeviceEx @14 16 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/irrlicht/lib/Win32-visualstudio/Irrlicht.exp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/irrlicht/lib/Win32-visualstudio/Irrlicht.exp -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Analysis.cpp: -------------------------------------------------------------------------------- 1 | #include "Analysis.h" 2 | #include 3 | 4 | Analysis::Analysis() 5 | { 6 | 7 | } 8 | 9 | Analysis::~Analysis() 10 | { 11 | for (Analyzer* analyzer : analyzers) 12 | delete analyzer; 13 | } 14 | 15 | 16 | void Analysis::AddAnalyzer(Analyzer* _analyzer) 17 | { 18 | analyzers.push_back(_analyzer); 19 | } 20 | 21 | 22 | void Analysis::StartAnalysis(Play* _play, std::string _analyzer) 23 | { 24 | if (_analyzer == "") 25 | { 26 | for (Analyzer* analyzer : analyzers) 27 | { 28 | std::cout << "\t Starting " << analyzer->getName() << " analysis..." << std::endl; 29 | 30 | analyzer->Clear(); 31 | analyzer->Analyze(_play); 32 | } 33 | } 34 | else 35 | { 36 | Analyzer* analyzer = getAnalyzer(_analyzer); 37 | if (analyzer == nullptr) return; 38 | 39 | std::cout << "\t Starting " << analyzer->getName() << " analysis..." << std::endl; 40 | 41 | analyzer->Clear(); 42 | analyzer->Analyze(_play); 43 | } 44 | } 45 | 46 | 47 | Analyzer* Analysis::getAnalyzer(std::string _analyzer) 48 | { 49 | /// \TODO: Binary search? 50 | for (Analyzer* analyzer : analyzers) 51 | { 52 | if (analyzer->getName() == _analyzer) 53 | return analyzer; 54 | } 55 | 56 | std::cout << "[Warning] Analyzer \"" << _analyzer << "\"not found!" << std::endl; 57 | return nullptr; 58 | } 59 | 60 | std::vector Analysis::getValidAnalyzers() 61 | { 62 | std::vector list; 63 | for (Analyzer* analyzer : analyzers) 64 | { 65 | if (analyzer->getData()->size() != 0) 66 | list.push_back(analyzer->getName()); 67 | } 68 | 69 | return list; 70 | } 71 | 72 | void Analysis::Clear() 73 | { 74 | for (Analyzer* analyzer : analyzers) 75 | analyzer->Clear(); 76 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Analysis.h: -------------------------------------------------------------------------------- 1 | #ifndef ANALYSIS_H 2 | #define ANALYSIS_H 3 | 4 | #include 5 | #include 6 | 7 | #include "Analyzer.h" 8 | #include "../Filestructure/Play.h" 9 | 10 | class Analysis 11 | { 12 | public: 13 | Analysis(); 14 | virtual ~Analysis(); 15 | 16 | void AddAnalyzer(Analyzer* _analyzer); 17 | void StartAnalysis(Play* _play, std::string _analyzer = ""); 18 | 19 | Analyzer* getAnalyzer(std::string _analyzer); 20 | std::vector getValidAnalyzers(); 21 | void Clear(); 22 | 23 | private: 24 | std::vector analyzers; 25 | }; 26 | 27 | #endif // !ANALYSIS_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/AnalysisStruct.cpp: -------------------------------------------------------------------------------- 1 | #include "AnalysisStruct.h" 2 | 3 | Analysis AnalysisStruct::beatmapAnalysis; 4 | Analysis AnalysisStruct::replayAnalysis; 5 | Analysis AnalysisStruct::scorepAnalysis; 6 | 7 | AnalysisStruct::AnalysisStruct() 8 | { 9 | beatmapAnalysis.AddAnalyzer(new Analyzer_Velocity()); 10 | beatmapAnalysis.AddAnalyzer(new Analyzer_DistSize()); 11 | beatmapAnalysis.AddAnalyzer(new Analyzer_NoteRate()); 12 | beatmapAnalysis.AddAnalyzer(new Analyzer_TapEventIntervals()); 13 | ///beatmapAnalysis.AddAnalyzer(new Analyzer_Overlaps()); 14 | //beatmapAnalysis.AddAnalyzer(new Analyzer_NoteRatePerKey()); 15 | beatmapAnalysis.AddAnalyzer(new Analyzer_NoteRatePerKeyPrec()); 16 | 17 | beatmapAnalysis.AddAnalyzer(new Analyzer_TapDeviation()); 18 | beatmapAnalysis.AddAnalyzer(new Analyzer_AimDeviation()); 19 | 20 | ///beatmapAnalysis.AddAnalyzer(new Analyzer_Reading()); 21 | 22 | beatmapAnalysis.AddAnalyzer(new Analyzer_AimScore()); 23 | beatmapAnalysis.AddAnalyzer(new Analyzer_TapScore()); 24 | } 25 | 26 | static AnalysisStruct analysisStruct; -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/AnalysisStruct.h: -------------------------------------------------------------------------------- 1 | #ifndef ANALYSISSTRUCT_H 2 | #define ANALYSISSTRUCT_H 3 | 4 | #include "Analysis.h" 5 | 6 | #include "Beatmap\Velocity.h" 7 | #include "Beatmap\NoteRate.h" 8 | #include "Beatmap\NoteRatePerKey.h" 9 | #include "Beatmap\NoteRatePerKeyPrecise.h" 10 | #include "Beatmap\Overlaps.h" 11 | #include "Beatmap\Distance-size.h" 12 | #include "Beatmap\TapEventIntervals.h" 13 | 14 | #include "Beatmap\Difficulty\Reading.h" 15 | 16 | #include "Replay\aim-deviation.h" 17 | #include "Replay\tap-deviation.h" 18 | 19 | #include "Score\AimScore.h" 20 | #include "Score\TapScore.h" 21 | 22 | struct AnalysisStruct 23 | { 24 | static Analysis beatmapAnalysis; 25 | static Analysis replayAnalysis; 26 | static Analysis scorepAnalysis; 27 | 28 | AnalysisStruct(); 29 | }; 30 | 31 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Analyzer.cpp: -------------------------------------------------------------------------------- 1 | #include "Analyzer.h" 2 | 3 | Analyzer::Analyzer(std::string _name) 4 | { 5 | name = _name; 6 | } 7 | 8 | Analyzer::~Analyzer() 9 | { 10 | Clear(); 11 | } 12 | 13 | void Analyzer::Analyze(Play* _play) 14 | { 15 | if (_play->beatmap == nullptr) return; 16 | switch (_play->beatmap->getGamemode()) 17 | { 18 | case GAMEMODE::OSU_STANDARD: 19 | AnalyzeStd(_play); 20 | break; 21 | 22 | case GAMEMODE::OSU_CATCH: 23 | AnalyzeCatch(_play); 24 | break; 25 | 26 | case GAMEMODE::OSU_TAIKO: 27 | AnalyzeTaiko(_play); 28 | break; 29 | 30 | case GAMEMODE::OSU_MANIA: 31 | AnalyzeMania(_play); 32 | break; 33 | 34 | case GAMEMODE::OSU_DODGE: 35 | AnalyzeDodge(_play); 36 | break; 37 | 38 | default: 39 | break; 40 | } 41 | } 42 | 43 | std::vector* Analyzer::getData() 44 | { 45 | return &data; 46 | } 47 | 48 | std::string Analyzer::getName() const 49 | { 50 | return name; 51 | } 52 | 53 | void Analyzer::Clear() 54 | { 55 | data.clear(); 56 | std::vector().swap(data); 57 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Analyzer.h: -------------------------------------------------------------------------------- 1 | #ifndef ANALYZER_H 2 | #define ANALYZER_H 3 | 4 | #include 5 | #include 6 | 7 | #include "../osuStructs.h" 8 | #include "../Filestructure/Play.h" 9 | 10 | class Analyzer 11 | { 12 | public: 13 | Analyzer(std::string _name); 14 | virtual ~Analyzer(); 15 | 16 | void Analyze(Play* _play); 17 | 18 | std::vector* getData(); 19 | std::string getName() const; 20 | void Clear(); 21 | 22 | protected: 23 | std::string name; 24 | std::vector data; 25 | 26 | virtual void AnalyzeStd(Play* _play) = 0; 27 | virtual void AnalyzeCatch(Play* _play) = 0; 28 | virtual void AnalyzeTaiko(Play* _play) = 0; 29 | virtual void AnalyzeMania(Play* _play) = 0; 30 | virtual void AnalyzeDodge(Play* _play) = 0; 31 | }; 32 | 33 | #endif // !ANALYZER_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/Difficulty/Reading.h: -------------------------------------------------------------------------------- 1 | #ifndef READING_H 2 | #define READING_H 3 | 4 | #include "../../Analyzer.h" 5 | 6 | class Analyzer_Reading : public Analyzer 7 | { 8 | public: 9 | Analyzer_Reading(); 10 | virtual ~Analyzer_Reading(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif // READING_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/DistSize.cpp: -------------------------------------------------------------------------------- 1 | #include "Distance-size.h" 2 | 3 | #include "../../../utils/geometry.h" 4 | #include "../../osuCalc.h" 5 | 6 | #include "../../osu_standard.h" 7 | #include "../../osu_mania.h" 8 | 9 | Analyzer_DistSize::Analyzer_DistSize() : Analyzer("dist/size (osu!px/osu!px)") {} 10 | Analyzer_DistSize::~Analyzer_DistSize() {} 11 | 12 | void Analyzer_DistSize::AnalyzeStd(Play* _play) 13 | { 14 | std::vector& hitobjects = _play->beatmap->getHitobjects(); 15 | osu::TIMING timing; 16 | timing.data = 0; 17 | 18 | long time = 0; 19 | double size = CS2px(_play->getMod()->getCS()); 20 | 21 | osu::TIMING prevTickPoint = OSUSTANDARD::getNextTickPoint(hitobjects, &time); 22 | osu::TIMING currTickPoint = OSUSTANDARD::getNextTickPoint(hitobjects, &time); 23 | 24 | while(true) 25 | { 26 | double dist = getDist(vector2d(prevTickPoint.pos.X, prevTickPoint.pos.Y), 27 | vector2d(currTickPoint.pos.X, currTickPoint.pos.Y)); 28 | if (dist == INFINITY) dist = INT_MAX; // irrlitch has issues displaying infinity 29 | 30 | double dist_size; 31 | if (size == 0) dist_size = INT_MAX; 32 | else dist_size = dist / size; 33 | 34 | timing.data = dist_size; 35 | timing.pos = currTickPoint.pos; 36 | timing.press = currTickPoint.press; // records if it is at mid hold object or not 37 | timing.time = currTickPoint.time; 38 | 39 | data.push_back(timing); 40 | 41 | prevTickPoint = currTickPoint; 42 | currTickPoint = OSUSTANDARD::getNextTickPoint(hitobjects, &time); 43 | 44 | if (currTickPoint.data == -1) break; 45 | } 46 | } 47 | 48 | void Analyzer_DistSize::AnalyzeCatch(Play* _play) 49 | { 50 | 51 | } 52 | 53 | void Analyzer_DistSize::AnalyzeTaiko(Play* _play) 54 | { 55 | 56 | } 57 | 58 | void Analyzer_DistSize::AnalyzeMania(Play* _play) 59 | { 60 | 61 | } 62 | 63 | void Analyzer_DistSize::AnalyzeDodge(Play* _play) 64 | { 65 | 66 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/Distance-size.h: -------------------------------------------------------------------------------- 1 | #ifndef DISTSIZE_H 2 | #define DISTSIZE_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_DistSize : public Analyzer 7 | { 8 | public: 9 | Analyzer_DistSize(); 10 | virtual ~Analyzer_DistSize(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif // -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/IntensityForHand.h: -------------------------------------------------------------------------------- 1 | #ifndef INTESITYFORHAND_H 2 | #define INTESITYFORHAND_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_IntensityForHand : public Analyzer 7 | { 8 | public: 9 | Analyzer_IntensityForHand(); 10 | virtual ~Analyzer_IntensityForHand(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif // !INTESITYFORHAND_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/NoteRate.h: -------------------------------------------------------------------------------- 1 | #ifndef NOTERATE_H 2 | #define NOTERATE_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_NoteRate : public Analyzer 7 | { 8 | public: 9 | Analyzer_NoteRate(); 10 | virtual ~Analyzer_NoteRate(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif // !NOTERATE_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/NoteRatePerKey.h: -------------------------------------------------------------------------------- 1 | #ifndef NOTERATEPERKEY_H 2 | #define NOTERATEPERKEY_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_NoteRatePerKey : public Analyzer 7 | { 8 | public: 9 | Analyzer_NoteRatePerKey(); 10 | virtual ~Analyzer_NoteRatePerKey(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif // !NOTERATEPERKEY_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/NoteRatePerKeyPrecise.h: -------------------------------------------------------------------------------- 1 | #ifndef NOTERATEPEYPRECISE_H 2 | #define NOTERATEPEYPRECISE_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_NoteRatePerKeyPrec : public Analyzer 7 | { 8 | public: 9 | Analyzer_NoteRatePerKeyPrec(); 10 | virtual ~Analyzer_NoteRatePerKeyPrec(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | 20 | #endif // !NOTERATEPEYPRECISE_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/Overlaps.h: -------------------------------------------------------------------------------- 1 | #ifndef OVERLAPS_H 2 | #define OVERLAPS_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_Overlaps : public Analyzer 7 | { 8 | public: 9 | Analyzer_Overlaps(); 10 | virtual ~Analyzer_Overlaps(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif // !OVERLAPS_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/TapEventIntervals.h: -------------------------------------------------------------------------------- 1 | #ifndef TAPEVENINTERVALS_H 2 | #define TAPEVENINTERVALS_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_TapEventIntervals : public Analyzer 7 | { 8 | public: 9 | Analyzer_TapEventIntervals(); 10 | virtual ~Analyzer_TapEventIntervals(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/Velocity.cpp: -------------------------------------------------------------------------------- 1 | #include "Velocity.h" 2 | #include "../../osu_standard.h" 3 | #include "../../../utils/geometry.h" 4 | 5 | Analyzer_Velocity::Analyzer_Velocity() : Analyzer("velocity (px/ms)"){} 6 | Analyzer_Velocity::~Analyzer_Velocity(){} 7 | 8 | void Analyzer_Velocity::AnalyzeStd(Play* _play) 9 | { 10 | std::vector& hitobjects = _play->beatmap->getHitobjects(); 11 | osu::TIMING timing; 12 | timing.data = 0; 13 | 14 | long time = 0; 15 | 16 | osu::TIMING prevTickPoint = OSUSTANDARD::getNextTickPoint(hitobjects, &time); 17 | osu::TIMING currTickPoint = OSUSTANDARD::getNextTickPoint(hitobjects, &time); 18 | 19 | while(true) 20 | { 21 | double velocity = getVelocity(vector2d(prevTickPoint.pos.X, prevTickPoint.pos.Y), 22 | vector2d(currTickPoint.pos.X, currTickPoint.pos.Y), 23 | prevTickPoint.time, currTickPoint.time); 24 | if (velocity == INFINITY) velocity = INT_MAX; // irrlitch has issues displaying infinity 25 | 26 | timing.data = velocity; 27 | timing.pos = currTickPoint.pos; 28 | timing.press = currTickPoint.press; // records if it is at mid hold object or not 29 | timing.time = currTickPoint.time; 30 | 31 | data.push_back(timing); 32 | 33 | prevTickPoint = currTickPoint; 34 | currTickPoint = OSUSTANDARD::getNextTickPoint(hitobjects, &time); 35 | 36 | if (currTickPoint.data == -1) break; 37 | } 38 | } 39 | 40 | void Analyzer_Velocity::AnalyzeCatch(Play* _play) 41 | { 42 | 43 | } 44 | 45 | void Analyzer_Velocity::AnalyzeTaiko(Play* _play) 46 | { 47 | 48 | } 49 | 50 | void Analyzer_Velocity::AnalyzeMania(Play* _play) 51 | { 52 | 53 | } 54 | 55 | void Analyzer_Velocity::AnalyzeDodge(Play* _play) 56 | { 57 | 58 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Beatmap/Velocity.h: -------------------------------------------------------------------------------- 1 | #include "../Analyzer.h" 2 | 3 | class Analyzer_Velocity : public Analyzer 4 | { 5 | public: 6 | Analyzer_Velocity(); 7 | virtual ~Analyzer_Velocity(); 8 | 9 | virtual void AnalyzeStd(Play* _play); 10 | virtual void AnalyzeCatch(Play* _play); 11 | virtual void AnalyzeTaiko(Play* _play); 12 | virtual void AnalyzeMania(Play* _play); 13 | virtual void AnalyzeDodge(Play* _play); 14 | }; -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Replay/aim-deviation.h: -------------------------------------------------------------------------------- 1 | #ifndef AIMDEVIATION_H 2 | #define AIMDEVIATION_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_AimDeviation : public Analyzer 7 | { 8 | public: 9 | Analyzer_AimDeviation(); 10 | virtual ~Analyzer_AimDeviation(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif // !AIMDEVIATION_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Replay/tap-deviation.h: -------------------------------------------------------------------------------- 1 | #ifndef TAPDEVIATION_H 2 | #define TAPDEVIATION_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_TapDeviation : public Analyzer 7 | { 8 | public: 9 | Analyzer_TapDeviation(); 10 | virtual ~Analyzer_TapDeviation(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Score/AimScore.cpp: -------------------------------------------------------------------------------- 1 | #include "AimScore.h" 2 | 3 | #include "../../osu_standard.h" 4 | #include "../../../utils/mathUtils.h" 5 | 6 | #include "../AnalysisStruct.h" 7 | #include "../Replay/aim-deviation.h" 8 | 9 | Analyzer_AimScore::Analyzer_AimScore() : Analyzer("Aim Score (/M)"){} 10 | Analyzer_AimScore::~Analyzer_AimScore(){} 11 | 12 | void Analyzer_AimScore::AnalyzeStd(Play* _play) 13 | { 14 | osu::TIMING timing; 15 | timing.key = 0; 16 | 17 | std::vector& aimDeviations = *AnalysisStruct::beatmapAnalysis.getAnalyzer("aim deviation (px)")->getData(); 18 | int numPoints = aimDeviations.size(); 19 | 20 | for (osu::TIMING aimDeviation : aimDeviations) 21 | { 22 | timing.data = 1000000.0 * (Guassian(aimDeviation.data, 15.0)/(double)numPoints); // inidivual score 23 | timing.key += timing.data; // cumalative score 24 | timing.pos = aimDeviation.pos; 25 | timing.time = aimDeviation.time; 26 | 27 | data.push_back(timing); 28 | } 29 | } 30 | 31 | void Analyzer_AimScore::AnalyzeCatch(Play* _play) 32 | { 33 | 34 | } 35 | 36 | void Analyzer_AimScore::AnalyzeTaiko(Play* _play) 37 | { 38 | 39 | } 40 | 41 | void Analyzer_AimScore::AnalyzeMania(Play* _play) 42 | { 43 | 44 | } 45 | 46 | void Analyzer_AimScore::AnalyzeDodge(Play* _play) 47 | { 48 | 49 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Score/AimScore.h: -------------------------------------------------------------------------------- 1 | #ifndef AIMSCORE_H 2 | #define AIMSCORE_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_AimScore : public Analyzer 7 | { 8 | public: 9 | Analyzer_AimScore(); 10 | virtual ~Analyzer_AimScore(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif // !AIMSCORE_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Score/TapScore.cpp: -------------------------------------------------------------------------------- 1 | #include "TapScore.h" 2 | 3 | #include "../../osu_standard.h" 4 | #include "../../../utils/mathUtils.h" 5 | 6 | #include "../AnalysisStruct.h" 7 | #include "../Replay/tap-deviation.h" 8 | 9 | Analyzer_TapScore::Analyzer_TapScore() : Analyzer("Tap Score (/M)"){} 10 | Analyzer_TapScore::~Analyzer_TapScore(){} 11 | 12 | void Analyzer_TapScore::AnalyzeStd(Play* _play) 13 | { 14 | osu::TIMING timing; 15 | timing.key = 0; 16 | 17 | std::vector* tapDeviations = AnalysisStruct::beatmapAnalysis.getAnalyzer("tap deviation (ms)")->getData(); 18 | if (tapDeviations == nullptr) return; 19 | 20 | int numPoints = tapDeviations->size(); 21 | for (osu::TIMING TapDeviation : *tapDeviations) 22 | { 23 | timing.data = 1000000.0 * (Guassian(TapDeviation.data, 40.0)/(double)numPoints); // inidivual score 24 | timing.key += timing.data; // cumalative score 25 | timing.pos = TapDeviation.pos; 26 | timing.time = TapDeviation.time; 27 | 28 | data.push_back(timing); 29 | } 30 | } 31 | 32 | void Analyzer_TapScore::AnalyzeCatch(Play* _play) 33 | { 34 | 35 | } 36 | 37 | void Analyzer_TapScore::AnalyzeTaiko(Play* _play) 38 | { 39 | 40 | } 41 | 42 | void Analyzer_TapScore::AnalyzeMania(Play* _play) 43 | { 44 | osu::TIMING timing; 45 | timing.key = 0; 46 | 47 | Analyzer* analyzer = AnalysisStruct::beatmapAnalysis.getAnalyzer("Tap Deviation (ms)"); 48 | if (analyzer == nullptr) return; 49 | 50 | std::vector* tapDeviations = analyzer->getData(); 51 | int numPoints = tapDeviations->size(); 52 | 53 | for (osu::TIMING TapDeviation : *tapDeviations) 54 | { 55 | timing.data = 1000000.0 * (Guassian(TapDeviation.data, 40.0) / (double)numPoints); // inidivual score 56 | timing.key += timing.data; // cumalative score 57 | timing.pos = TapDeviation.pos; 58 | timing.time = TapDeviation.time; 59 | 60 | data.push_back(timing); 61 | } 62 | } 63 | 64 | void Analyzer_TapScore::AnalyzeDodge(Play* _play) 65 | { 66 | 67 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Analysis/Score/TapScore.h: -------------------------------------------------------------------------------- 1 | #ifndef TAPSCORE_H 2 | #define TAPSCORE_H 3 | 4 | #include "../Analyzer.h" 5 | 6 | class Analyzer_TapScore : public Analyzer 7 | { 8 | public: 9 | Analyzer_TapScore(); 10 | virtual ~Analyzer_TapScore(); 11 | 12 | virtual void AnalyzeStd(Play* _play); 13 | virtual void AnalyzeCatch(Play* _play); 14 | virtual void AnalyzeTaiko(Play* _play); 15 | virtual void AnalyzeMania(Play* _play); 16 | virtual void AnalyzeDodge(Play* _play); 17 | }; 18 | 19 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/GamemodeRenderer.h: -------------------------------------------------------------------------------- 1 | #ifndef GAMEMODERENDERER 2 | #define GAMEMODERENDERER 3 | 4 | #include "../../ui/Window.h" 5 | #include "../../ui/GuiObj.h" 6 | #include "../osuEnums.h" 7 | #include "../Filestructure/Play.h" 8 | #include "Hitcircle.h" 9 | 10 | #include "OsuStdRenderer.h" 11 | #include "OsuManiaRenderer.h" 12 | //#include "OsuCatchRenderer.h" 13 | //#include "OsuTaikoRenderer.h" 14 | //#include "OsuDodgeRenderer.h" 15 | 16 | extern double _widthRatio_, _heightRatio_; 17 | 18 | class GamemodeRenderer : public GuiObj 19 | { 20 | public: 21 | GamemodeRenderer(int _xpos, int _ypos, int _width, int _hight, Play* _play, int* _viewTime); 22 | void InitRenderer(Play* _play, int* _viewTime); 23 | 24 | virtual ~GamemodeRenderer(); 25 | void setGamemode(GAMEMODE _gamemode); 26 | 27 | private: 28 | virtual void UpdateInternal(Window& _win); 29 | void UpdateRatios(); 30 | 31 | virtual void Draw(Window& _win); 32 | 33 | void RenderOsuStandard(Window& _win); 34 | void RenderOsuCatch(Window& _win); 35 | void RenderOsuTaiko(Window& _win); 36 | void RenderOsuMania(Window& _win); 37 | void RenderOsuDodge(Window& _win); 38 | 39 | void DestroyRenderers(); 40 | 41 | GAMEMODE gamemode; 42 | OsuStdRenderer* stdRenderer; 43 | OsuManiaRenderer* maniaRenderer; 44 | }; 45 | 46 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/HitNote.h: -------------------------------------------------------------------------------- 1 | #ifndef HITNOTE_H 2 | #define HITNOTE_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include "../../ui/GuiObj.h" 9 | #include "../../ui/Window.h" 10 | #include "../Filestructure/Hitobject.h" 11 | #include "../Filestructure/Mods.h" 12 | 13 | class HitNote : public GuiObj 14 | { 15 | public: 16 | HitNote(Mods* _mods, Hitobject* _hitobject, int* _viewTime, double* _zoom); 17 | 18 | private: 19 | Mods *mods; 20 | Hitobject *hitobject; 21 | int *viewTime; 22 | double *zoom; 23 | 24 | SColor edgeCol; 25 | 26 | enum STATE 27 | { 28 | IDLE = 0, 29 | HIGHLIGHTED = 1, 30 | SELECTED = 2 31 | }state; 32 | 33 | const SColor IDLE_COLOR = SColor(255, 150, 150, 150); 34 | const SColor HIGHLIGHTED_COLOR = SColor(255, 255, 255, 255); 35 | const SColor SELECTED_COLOR = SColor(255, 255, 100, 100); 36 | 37 | void IdleLogic(Window &_win); 38 | void HighlightedLogic(Window &_win); 39 | void SelectedLogic(Window &_win); 40 | 41 | virtual void UpdateInternal(Window &_win); 42 | virtual void UpdateAbsPos(Window& _win); 43 | virtual void UpdateAbsDim(Window& _win); 44 | 45 | virtual void Draw(Window &_win); 46 | }; 47 | 48 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/HitTimingGraph.h: -------------------------------------------------------------------------------- 1 | #ifndef HIT_TIMING_GRAPH 2 | #define HIT_TIMING_GRAPH 3 | 4 | #include 5 | 6 | #include "../../ui/Window.h" 7 | #include "../../ui/GuiObj.h" 8 | #include "../Filestructure/Play.h" 9 | #include "../../ui/ColorTable.h" 10 | 11 | class HitTimingGraph : public GuiObj 12 | { 13 | public: 14 | HitTimingGraph(int _xpos, int _ypos, Play* _play); 15 | virtual ~HitTimingGraph(); 16 | 17 | void setBinTable(std::vector _binTable); 18 | void Init(); 19 | 20 | private: 21 | virtual void Draw(Window& _win); 22 | virtual void UpdateInternal(Window& _win); 23 | 24 | void genStdBins(); 25 | void genCtbBins(); 26 | void genTaikoBins(); 27 | void genManiaBins(); 28 | void genDodgeBins(); 29 | 30 | void Clear(); 31 | 32 | std::vector bins; 33 | std::vector binTable; 34 | std::vector textBins; 35 | 36 | ColorTable colorTable; 37 | Play* play; 38 | }; 39 | 40 | #endif // !HIT_TIMING_GRAPH -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/HitTimingMarker.h: -------------------------------------------------------------------------------- 1 | #ifndef HITTIMINGMARKER_H 2 | #define HITTIMINGMARKER_H 3 | 4 | #include 5 | 6 | #include "../../ui/Window.h" 7 | #include "../../ui/GuiObj.h" 8 | #include "../Filestructure/Play.h" 9 | 10 | class HitTimingMarker : public GuiObj 11 | { 12 | public: 13 | HitTimingMarker(int _xpos, int _ypos, Play* _play, int* _viewTime); 14 | 15 | private: 16 | virtual void Draw(Window& _win); 17 | virtual void UpdateInternal(Window& _win); 18 | 19 | void DrawStdTimings(Window& _win); 20 | void DrawCtBTimings(Window& _win); 21 | void DrawTaikoTimings(Window& _win); 22 | void DrawManiaTimings(Window& _win); 23 | void DrawDodgeTimings(Window& _win); 24 | 25 | void UpdateUserControls(Window& _win); 26 | void UpdateZoomTime(Window& _win); 27 | void UpdateZoomView(Window& _win); 28 | 29 | void IdleLogic(Window &_win); 30 | void HighlightedLogic(Window &_win); 31 | 32 | enum STATE 33 | { 34 | IDLE = 0, 35 | HIGHLIGHTED = 1, 36 | SELECTED = 2 37 | }state; 38 | 39 | const SColor IDLE_COLOR = SColor(255, 0, 0, 0); 40 | const SColor HIGHLIGHTED_COLOR = SColor(255, 255, 255, 0); 41 | 42 | SColor edgeCol; 43 | double timeZoom = 1050; 44 | double viewZoom = 1500; 45 | 46 | int* viewTime; 47 | Play* play; 48 | }; 49 | 50 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/Hitcircle.h: -------------------------------------------------------------------------------- 1 | #ifndef HITCIRCLE_H 2 | #define HITCIRCLE_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include "../../ui/GuiObj.h" 9 | #include "../../ui/Window.h" 10 | #include "../Filestructure/Hitobject.h" 11 | #include "../Filestructure/Beatmap.h" 12 | 13 | class Hitcircle: public GuiObj 14 | { 15 | public: 16 | Hitcircle(Mods* _mods, Hitobject* _hitobject, int* _viewTime); 17 | virtual ~Hitcircle(); 18 | 19 | private: 20 | Mods *mods; 21 | Hitobject *hitobject; 22 | int *viewTime; 23 | 24 | SColor edgeCol; 25 | 26 | enum STATE 27 | { 28 | IDLE = 0, 29 | HIGHLIGHTED = 1, 30 | SELECTED = 2 31 | }state; 32 | 33 | const SColor IDLE_COLOR = SColor(255, 150, 150, 150); 34 | const SColor HIGHLIGHTED_COLOR = SColor(255, 255, 255, 255); 35 | const SColor SELECTED_COLOR = SColor(255, 255, 100, 100); 36 | 37 | void IdleLogic(Window &_win); 38 | void HighlightedLogic(Window &_win); 39 | void SelectedLogic(Window &_win); 40 | 41 | virtual void UpdateInternal(Window &_win); 42 | void UpdateDimentions(); 43 | 44 | virtual void Draw(Window &_win); 45 | 46 | inline double getWidthRatio(); 47 | inline double getHeightRatio(); 48 | }; 49 | 50 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/OsuManiaRenderer.h: -------------------------------------------------------------------------------- 1 | #ifndef OSU_MANIA_RENDERER 2 | #define OSU_MANIA_RENDERER 3 | 4 | #include "../../ui/Window.h" 5 | #include "../../ui/GuiObj.h" 6 | #include "HitNote.h" 7 | 8 | class OsuManiaRenderer : public GuiObj 9 | { 10 | public: 11 | OsuManiaRenderer(Play* _play, int* _viewTime, GuiObj* _parent); 12 | virtual ~OsuManiaRenderer(); 13 | 14 | enum Layer 15 | { 16 | VISIBLE = 1 << 0, 17 | // non 18 | // not density 19 | REPLAY = 1 << 3, 20 | TIMINGS = 1 << 4, 21 | HITIMINGS = 1 << 5, 22 | TAPPINGDIFFS = 1 << 6 23 | }; 24 | 25 | void SetLayers(int _layer); 26 | 27 | int getStartTime(); 28 | int getEndTime(); 29 | 30 | private: 31 | void ClearHitnotes(); 32 | void GenerateHitNotes(); 33 | 34 | virtual void UpdateAbsDim(Window& _win); 35 | virtual void UpdateAbsPos(Window& _win); 36 | virtual void UpdateInternal(Window& _win); 37 | void UpdateUserControls(Window& _win); 38 | void UpdateZoom(Window& _win); 39 | 40 | virtual void Draw(Window& _win); 41 | 42 | void RenderVisible(Window& _win); 43 | void RenderReplay(Window& _win); 44 | void RenderTimings(Window& _win); 45 | void RenderHitTimings(Window& _win); 46 | void RenderTappingDiffs(Window& _win); 47 | 48 | int Time2px(double _time); 49 | int px2Time(double _px); 50 | 51 | std::vector hitNotes; 52 | std::vector visiblityPool; 53 | 54 | Play* play; 55 | int* viewTime; 56 | Layer layerState; 57 | double zoom; 58 | }; 59 | 60 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/OsuStdRenderer.h: -------------------------------------------------------------------------------- 1 | #ifndef OSU_STD_RENDERER 2 | #define OSU_STD_RENDERER 3 | 4 | #include "../../ui/Window.h" 5 | #include "../../ui/GuiObj.h" 6 | #include "Hitcircle.h" 7 | 8 | class OsuStdRenderer: public GuiObj 9 | { 10 | public: 11 | OsuStdRenderer(Play* _play, int* _viewTime, GuiObj* _parent); 12 | virtual ~OsuStdRenderer(); 13 | 14 | enum Layer 15 | { 16 | VISIBLE = 1 << 0, 17 | PATHS = 1 << 1, 18 | DENSITY = 1 << 2, 19 | REPLAY = 1 << 3, 20 | REPLAYPATH = 1 << 4 21 | }; 22 | 23 | void SetLayers(int _layer); 24 | 25 | private: 26 | void ClearHitcircles(); 27 | void GenerateHitcircles(); 28 | 29 | virtual void UpdateInternal(Window& _win); 30 | virtual void Draw(Window& _win); 31 | 32 | void RenderVisible(Window& _win); 33 | void RenderPaths(Window& _win); 34 | void RenderDensities(Window& _win); 35 | void RenderReplay(Window& _win); 36 | void RenderReplayPath(Window& _win); 37 | 38 | std::vector hitCircles; 39 | 40 | Play* play; 41 | int* viewTime; 42 | Layer layerState; 43 | }; 44 | 45 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/StatGraph.h: -------------------------------------------------------------------------------- 1 | #ifndef STATGRAPH_H 2 | #define STATGRAPH_H 3 | 4 | #include "../../ui/Graph.h" 5 | #include "../osuStructs.h" 6 | #include "../../ui/Button.h" 7 | 8 | class StatGraph : public GuiObj 9 | { 10 | public: 11 | StatGraph(int _xpos, int _ypos, int *_viewtime); 12 | virtual ~StatGraph(); 13 | 14 | void Init(); 15 | 16 | private: 17 | enum SELECTIONS 18 | { 19 | VEL, 20 | NPS, 21 | OVRLP, 22 | DIFF, 23 | NUM_SELECTIONS 24 | }; 25 | 26 | Graph velGraph; 27 | Button btnUp, btnDwn; 28 | 29 | std::vector* timings; 30 | int *viewtime; 31 | std::pair mouseOver; 32 | 33 | int selection; 34 | 35 | virtual void Draw(Window &_win); 36 | virtual void UpdateInternal(Window &_win); 37 | 38 | void UpdateDataSelect(); 39 | std::vector* getSelection(); 40 | 41 | void CycleSelectUp(); 42 | void CycleSelectDwn(); 43 | }; 44 | 45 | #endif // !STATGRAPH_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/TimingGraph.h: -------------------------------------------------------------------------------- 1 | #ifndef OSUSTATS_H 2 | #define OSUSTATS_H 3 | 4 | #include 5 | 6 | #include "../../ui/Window.h" 7 | #include "../../ui/GuiObj.h" 8 | #include "../Filestructure/Play.h" 9 | #include "TimingObject.h" 10 | 11 | class TimingGraph : public GuiObj 12 | { 13 | public: 14 | TimingGraph(int _xpos, int _ypos, Window& _win, Play* _play); // _res = resolution in px/ms 15 | virtual ~TimingGraph(); 16 | 17 | enum LAYER 18 | { 19 | REFRESHRATE_TICKS = 1 << 0, 20 | HITOBJECT_VISIBILTITY = 1 << 1, 21 | HITOBJECT_HIT_TIMINGS = 1 << 2 22 | 23 | }; 24 | 25 | void EnableLayer(LAYER _layer); 26 | void DisableLayer(LAYER _layer); 27 | int getViewTime(); 28 | bool ViewTimeChanged(); 29 | 30 | double getZoom(); 31 | std::pair getViewTimes(); 32 | 33 | private: 34 | void GenerateVisibilityTimings(); 35 | 36 | virtual void UpdateInternal(Window& _win); 37 | virtual void Draw(Window& _win); 38 | 39 | void IdleLogic(Window &_win); 40 | void HighlightedLogic(Window &_win); 41 | 42 | int getVirtualxPos(); 43 | int getMarkerPos(); 44 | 45 | void UpdateUserControls(Window& _win); 46 | void UpdateZoom(Window& _win); 47 | void UpdateViewTime(Window& _win); 48 | 49 | void drawTimingsText(Window& _win); 50 | void drawViewTimeMarker(Window& _win); 51 | void drawHitobjectVisibilityTimings(Window &_win); 52 | void drawHitobjectHitTimings(Window &_win); 53 | void drawRefreshRateTimings(Window &_win, double _FPS); 54 | 55 | const SColor IDLE_COLOR = SColor(255, 255, 255, 255); 56 | const SColor HIGHLIGHTED_COLOR = SColor(255, 255, 255, 0); 57 | 58 | enum STATE 59 | { 60 | IDLE = 0, 61 | HIGHLIGHTED = 1, 62 | SELECTED = 2 63 | }state; 64 | 65 | SColor edgeCol; 66 | Play* play; 67 | int* res; 68 | 69 | const int HEIGHT = 25; 70 | int layerMask; 71 | double currViewTime, prevViewTime; 72 | double zoom; 73 | bool autoPlay; 74 | 75 | std::vector timingObjects; 76 | }; 77 | 78 | 79 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Drawable/TimingObject.h: -------------------------------------------------------------------------------- 1 | #ifndef TIMINGOBJECT 2 | #define TIMINGOBJECT 3 | 4 | #include "../../ui/GuiObj.h" 5 | #include "../../ui/Window.h" 6 | #include "../Filestructure/Beatmap.h" 7 | #include "../Filestructure/Hitobject.h" 8 | 9 | class TimingGraph; 10 | 11 | class TimingObject : public GuiObj 12 | { 13 | public: 14 | TimingObject(int _xpos, int ypos, int _width, int _height, Hitobject* _hitobject, Mods* _mods, TimingGraph* _timingGraph); 15 | 16 | private: 17 | virtual void UpdateInternal(Window& _win); 18 | void UpdatePosDim(); 19 | 20 | virtual void Draw(Window& _win); 21 | 22 | void IdleLogic(Window &_win); 23 | void HighlightedLogic(Window &_win); 24 | void SelectedLogic(Window &_win); 25 | 26 | void UpdateHitObjectTiming(); 27 | 28 | const SColor IDLE_COLOR = SColor(255, 255, 150, 255); 29 | const SColor HIGHLIGHTED_COLOR = SColor(255, 255, 200, 255); 30 | const SColor SELECTED_COLOR = SColor(255, 255, 100, 255); 31 | SColor color; 32 | 33 | TimingGraph* timingGraph; 34 | Mods* mods; 35 | Hitobject* hitobject; 36 | 37 | int origXpos, origWidth; 38 | 39 | enum STATE 40 | { 41 | IDLE = 0, 42 | HIGHLIGHTED = 1, 43 | SELECTED = 2 44 | }state; 45 | }; 46 | 47 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/Bezier.cpp: -------------------------------------------------------------------------------- 1 | #include "Bezier.h" 2 | 3 | Bezier::Bezier(std::vector _points) 4 | { 5 | points = _points; 6 | 7 | // approximate by finding the length of all points 8 | // (which should be the max possible length of the curve) 9 | double approxlength = 0; 10 | for (int i = 0; i < points.size() - 1; i++) 11 | approxlength += points[i].getDistanceFrom(points[i + 1]); 12 | 13 | init(approxlength); 14 | } 15 | 16 | Bezier::~Bezier() 17 | { 18 | points.clear(); 19 | curvePoints.clear(); 20 | curveDis.clear(); 21 | 22 | std::vector().swap(points); 23 | std::vector().swap(curvePoints); 24 | std::vector().swap(curveDis); 25 | } 26 | 27 | void Bezier::init(double approxlength) 28 | { 29 | // subdivide the curve 30 | ncurve = (int)(approxlength / 4.0) + 2; 31 | for (int i = 0; i < ncurve; i++) 32 | curvePoints.push_back(pointAt(i / (double)(ncurve - 1))); 33 | 34 | // find the distance of each point from the previous point 35 | totalDistance = 0; 36 | for (int i = 0; i < ncurve; i++) 37 | { 38 | curveDis.push_back((i == 0) ? 0 : curvePoints[i].getDistanceFrom(curvePoints[i - 1])); 39 | totalDistance += curveDis[i]; 40 | } 41 | } 42 | 43 | irr::core::vector2di Bezier::pointAt(double t) 44 | { 45 | irr::core::vector2di c; 46 | int n = points.size() - 1; 47 | for (int i = 0; i <= n; i++) 48 | { 49 | double b = bernstein(i, n, t); 50 | c.X += points[i].X * b; 51 | c.Y += points[i].Y * b; 52 | } 53 | return c; 54 | } 55 | 56 | // Returns the points along the curve of the Bezier curve. 57 | std::vector Bezier::getCurvePoint() { return curvePoints; } 58 | 59 | // Returns the distances between a point of the curve and the last point. 60 | std::vector Bezier::getCurveDistances() { return curveDis; } 61 | 62 | // Returns the number of points along the curve. 63 | int Bezier::getCurvesCount() { return ncurve; } 64 | 65 | // Returns the total distances of this Bezier curve. 66 | double Bezier::TotalDistance() { return totalDistance; } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/Bezier.h: -------------------------------------------------------------------------------- 1 | #ifndef _bezier_h_ 2 | #define _bezier_h_ 3 | 4 | #include 5 | #include 6 | 7 | #include "../../irrlicht\include\vector2d.h" 8 | #include "../../utils/mathUtils.h" 9 | 10 | 11 | /** 12 | * Representation of a Bezier curve with the distance between each point calculated. 13 | * 14 | * @author fluddokt (https://github.com/fluddokt) 15 | @porter abraker 16 | */ 17 | 18 | class Bezier 19 | { 20 | public: 21 | // Constructor 22 | // @param points the control points*/ 23 | Bezier(std::vector _points); 24 | virtual ~Bezier(); 25 | 26 | void init(double approxlength); 27 | 28 | irr::core::vector2di pointAt(double _t); 29 | 30 | // Returns the points along the curve of the Bezier curve. 31 | std::vector getCurvePoint(); 32 | 33 | // Returns the distances between a point of the curve and the last point. 34 | std::vector getCurveDistances(); 35 | 36 | // Returns the number of points along the curve. 37 | int getCurvesCount(); 38 | 39 | // Returns the total distances of this Bezier curve. 40 | double TotalDistance(); 41 | 42 | 43 | private: 44 | // The control points of the Bezier curve 45 | std::vector points; 46 | 47 | // Points along the curve of the Bezier curve 48 | std::vector curvePoints; 49 | 50 | // Distances between a point of the curve and the last point 51 | std::vector curveDis; 52 | 53 | // The number of points along the curve 54 | int ncurve; 55 | 56 | // The total distances of this Bezier 57 | double totalDistance; 58 | }; 59 | 60 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/Hitobject.h: -------------------------------------------------------------------------------- 1 | #ifndef HITOBJECT_H 2 | #define HITOBJECT_H 3 | 4 | #include 5 | #include 6 | 7 | #include "../../irrlicht/include/vector2d.h" 8 | 9 | #include "../../utils/mathUtils.h" 10 | #include "../osuEnums.h" 11 | 12 | #include "Bezier.h" 13 | 14 | class Beatmap; 15 | class SliderHitObject; 16 | 17 | enum CurveType 18 | { 19 | PerfectCurve = 'P', 20 | BezierCurve = 'B', 21 | LinearCurve = 'L', 22 | CatmullCurve = 'C' 23 | }; 24 | 25 | 26 | class Hitobject 27 | { 28 | friend class Play; 29 | 30 | public: 31 | Hitobject(std::vector &_objectData); 32 | Hitobject(Hitobject&&) = default; 33 | Hitobject(Hitobject const&) = default; 34 | 35 | virtual ~Hitobject(); 36 | 37 | bool IsHitObjectType(int type); 38 | bool isHitobjectLong(); 39 | 40 | int getHitobjectType(); 41 | long Hitobject::getCloserTime(long _time); 42 | 43 | SliderHitObject* getSlider(); 44 | 45 | irr::core::vector2d getPos() const; 46 | void setPos(irr::core::vector2d _pos); 47 | 48 | int getTime() const; 49 | int getEndTime(); 50 | void setTime(Beatmap* _beamap, int _time); 51 | 52 | std::pair getVisiblityTimes(double _AR, bool _hidden, double _opacityStart, double _opacityEnd); 53 | bool isVisibleAt(int _time, double _AR, bool _hidden); 54 | double getOpacityAt(int _time, double _AR, bool _hidden); 55 | 56 | double GetCircleOverlapPercentage(int CS, Hitobject &c1); 57 | 58 | protected: 59 | int time, index; 60 | irr::core::vector2d pos; 61 | int type; 62 | Beatmap* beatmap; 63 | 64 | void ProcessHitobjectData(std::vector &_objectData); 65 | }; 66 | 67 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA.cpp: -------------------------------------------------------------------------------- 1 | #include "LZMA.h" 2 | #include "LZMA\easylzma\decompress.h" 3 | 4 | #include 5 | #include 6 | 7 | int LZMA::DecompressStreamData(DataStream* _stream) 8 | { 9 | elzma_decompress_handle handle = elzma_decompress_alloc(); 10 | assert(handle != NULL); 11 | 12 | int ret = elzma_decompress_run(handle, inputCallback, (void*)_stream, outputCallback, (void*)_stream, ELZMA_lzma); 13 | 14 | if (ret != ELZMA_E_OK) 15 | { 16 | if (_stream->outData != NULL) 17 | free(_stream->outData); 18 | elzma_decompress_free(&handle); 19 | } 20 | 21 | return ret; 22 | } 23 | 24 | 25 | // ------------ [PRIVATE] ------------- 26 | 27 | 28 | /* an input callback that will be passed to elzma_decompress_run(), 29 | * it reads from a memory buffer */ 30 | int LZMA::inputCallback(void *_ctx, void *_buf, size_t *_size) 31 | { 32 | size_t rd = 0; 33 | struct DataStream *stream = (struct DataStream*)_ctx; 34 | assert(stream != NULL); 35 | 36 | rd = (stream->inLen < *_size) ? stream->inLen : *_size; 37 | if (rd > 0) 38 | { 39 | memcpy(_buf, (void *)stream->inData, rd); 40 | stream->inData += rd; 41 | stream->inLen -= rd; 42 | } 43 | 44 | *_size = rd; 45 | 46 | return 0; 47 | } 48 | 49 | /* an ouput callback that will be passed to elzma_decompress_run(), 50 | * it reallocs and writes to a memory buffer */ 51 | size_t LZMA::outputCallback(void *_ctx, const void *_buf, size_t _size) 52 | { 53 | struct DataStream *stream = (struct DataStream*)_ctx; 54 | assert(stream != nullptr); 55 | 56 | if (_size > 0) 57 | { 58 | stream->outData = (unsigned char*)realloc(stream->outData, stream->outLen + _size); 59 | memcpy((void *)(stream->outData + stream->outLen), _buf, _size); 60 | stream->outLen += _size; 61 | } 62 | 63 | return _size; 64 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA.h: -------------------------------------------------------------------------------- 1 | #ifndef LZMA_H 2 | #define LZMA_H 3 | 4 | static class LZMA 5 | { 6 | public: 7 | struct DataStream 8 | { 9 | const unsigned char * inData; 10 | size_t inLen; 11 | 12 | unsigned char * outData; 13 | size_t outLen; 14 | }; 15 | 16 | static int DecompressStreamData(DataStream* _stream); 17 | 18 | private: 19 | static size_t outputCallback(void *_ctx, const void *_buf, size_t _size); 20 | static int inputCallback(void *_ctx, void *_buf, size_t *_size); 21 | }; 22 | 23 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/common_internal.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Written in 2009 by Lloyd Hilaiel 3 | * 4 | * License 5 | * 6 | * All the cruft you find here is public domain. You don't have to credit 7 | * anyone to use this code, but my personal request is that you mention 8 | * Igor Pavlov for his hard, high quality work. 9 | */ 10 | 11 | #include "common_internal.h" 12 | 13 | static void *elzmaAlloc(void *p, size_t size) { 14 | struct elzma_alloc_struct * as = (struct elzma_alloc_struct *) p; 15 | if (as->clientMallocFunc) { 16 | return as->clientMallocFunc(as->clientMallocContext, size); 17 | } 18 | return malloc(size); 19 | } 20 | 21 | static void elzmaFree(void *p, void *address) { 22 | struct elzma_alloc_struct * as = (struct elzma_alloc_struct *) p; 23 | if (as->clientFreeFunc) { 24 | as->clientFreeFunc(as->clientMallocContext, address); 25 | } else { 26 | free(address); 27 | } 28 | } 29 | 30 | void 31 | init_alloc_struct(struct elzma_alloc_struct * as, 32 | elzma_malloc clientMallocFunc, 33 | void * clientMallocContext, 34 | elzma_free clientFreeFunc, 35 | void * clientFreeContext) 36 | { 37 | as->Alloc = elzmaAlloc; 38 | as->Free = elzmaFree; 39 | as->clientMallocFunc = clientMallocFunc; 40 | as->clientMallocContext = clientMallocContext; 41 | as->clientFreeFunc = clientFreeFunc; 42 | as->clientFreeContext = clientFreeContext; 43 | } 44 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/decompress.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Written in 2009 by Lloyd Hilaiel 3 | * 4 | * License 5 | * 6 | * All the cruft you find here is public domain. You don't have to credit 7 | * anyone to use this code, but my personal request is that you mention 8 | * Igor Pavlov for his hard, high quality work. 9 | * 10 | * easylzma/decompress.h - The API for LZMA decompression using easylzma 11 | */ 12 | 13 | #ifndef __EASYLZMADECOMPRESS_H__ 14 | #define __EASYLZMADECOMPRESS_H__ 15 | 16 | #include "common.h" 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | /** an opaque handle to an lzma decompressor */ 23 | typedef struct _elzma_decompress_handle * elzma_decompress_handle; 24 | 25 | /** 26 | * Allocate a handle to an LZMA decompressor object. 27 | */ 28 | elzma_decompress_handle EASYLZMA_API elzma_decompress_alloc(); 29 | 30 | /** 31 | * set allocation routines (optional, if not called malloc & free will 32 | * be used) 33 | */ 34 | void EASYLZMA_API elzma_decompress_set_allocation_callbacks( 35 | elzma_decompress_handle hand, 36 | elzma_malloc mallocFunc, void * mallocFuncContext, 37 | elzma_free freeFunc, void * freeFuncContext); 38 | 39 | /** 40 | * Free all data associated with an LZMA decompressor object. 41 | */ 42 | void EASYLZMA_API elzma_decompress_free(elzma_decompress_handle * hand); 43 | 44 | /** 45 | * Perform decompression 46 | * 47 | * XXX: should the library automatically detect format by reading stream? 48 | * currently it's based on data external to stream (such as extension 49 | * or convention) 50 | */ 51 | int EASYLZMA_API elzma_decompress_run( 52 | elzma_decompress_handle hand, 53 | elzma_read_callback inputStream, void * inputContext, 54 | elzma_write_callback outputStream, void * outputContext, 55 | elzma_file_format format); 56 | 57 | 58 | #ifdef __cplusplus 59 | }; 60 | #endif 61 | 62 | #endif 63 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/lzip_header.h: -------------------------------------------------------------------------------- 1 | #ifndef __EASYLZMA_LZIP_HEADER__ 2 | #define __EASYLZMA_LZIP_HEADER__ 3 | 4 | #include "common_internal.h" 5 | 6 | /* lzip file format documented here: 7 | * http://download.savannah.gnu.org/releases-noredirect/lzip/manual/ */ 8 | 9 | void initializeLZIPFormatHandler(struct elzma_format_handler * hand); 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/lzma_header.h: -------------------------------------------------------------------------------- 1 | #ifndef __EASYLZMA_LZMA_HEADER__ 2 | #define __EASYLZMA_LZMA_HEADER__ 3 | 4 | #include "common_internal.h" 5 | 6 | /* LZMA-Alone header format gleaned from reading Igor's code */ 7 | 8 | void initializeLZMAFormatHandler(struct elzma_format_handler * hand); 9 | 10 | #endif 11 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/7zBuf.c: -------------------------------------------------------------------------------- 1 | /* 7zBuf.c -- Byte Buffer 2 | 2008-03-28 3 | Igor Pavlov 4 | Public domain */ 5 | 6 | #include "7zBuf.h" 7 | 8 | void Buf_Init(CBuf *p) 9 | { 10 | p->data = 0; 11 | p->size = 0; 12 | } 13 | 14 | int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc) 15 | { 16 | p->size = 0; 17 | if (size == 0) 18 | { 19 | p->data = 0; 20 | return 1; 21 | } 22 | p->data = (Byte *)alloc->Alloc(alloc, size); 23 | if (p->data != 0) 24 | { 25 | p->size = size; 26 | return 1; 27 | } 28 | return 0; 29 | } 30 | 31 | void Buf_Free(CBuf *p, ISzAlloc *alloc) 32 | { 33 | alloc->Free(alloc, p->data); 34 | p->data = 0; 35 | p->size = 0; 36 | } 37 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/7zBuf.h: -------------------------------------------------------------------------------- 1 | /* 7zBuf.h -- Byte Buffer 2 | 2008-10-04 : Igor Pavlov : Public domain */ 3 | 4 | #ifndef __7Z_BUF_H 5 | #define __7Z_BUF_H 6 | 7 | #include "Types.h" 8 | 9 | typedef struct 10 | { 11 | Byte *data; 12 | size_t size; 13 | } CBuf; 14 | 15 | void Buf_Init(CBuf *p); 16 | int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc); 17 | void Buf_Free(CBuf *p, ISzAlloc *alloc); 18 | 19 | typedef struct 20 | { 21 | Byte *data; 22 | size_t size; 23 | size_t pos; 24 | } CDynBuf; 25 | 26 | void DynBuf_Construct(CDynBuf *p); 27 | void DynBuf_SeekToBeg(CDynBuf *p); 28 | int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc); 29 | void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc); 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/7zBuf2.c: -------------------------------------------------------------------------------- 1 | /* 7zBuf2.c -- Byte Buffer 2 | 2008-10-04 : Igor Pavlov : Public domain */ 3 | 4 | #include 5 | #include "7zBuf.h" 6 | 7 | void DynBuf_Construct(CDynBuf *p) 8 | { 9 | p->data = 0; 10 | p->size = 0; 11 | p->pos = 0; 12 | } 13 | 14 | void DynBuf_SeekToBeg(CDynBuf *p) 15 | { 16 | p->pos = 0; 17 | } 18 | 19 | int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc) 20 | { 21 | if (size > p->size - p->pos) 22 | { 23 | size_t newSize = p->pos + size; 24 | Byte *data; 25 | newSize += newSize / 4; 26 | data = (Byte *)alloc->Alloc(alloc, newSize); 27 | if (data == 0) 28 | return 0; 29 | p->size = newSize; 30 | memcpy(data, p->data, p->pos); 31 | alloc->Free(alloc, p->data); 32 | p->data = data; 33 | } 34 | memcpy(p->data + p->pos, buf, size); 35 | p->pos += size; 36 | return 1; 37 | } 38 | 39 | void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc) 40 | { 41 | alloc->Free(alloc, p->data); 42 | p->data = 0; 43 | p->size = 0; 44 | p->pos = 0; 45 | } 46 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/7zCrc.c: -------------------------------------------------------------------------------- 1 | /* 7zCrc.c -- CRC32 calculation 2 | 2008-08-05 3 | Igor Pavlov 4 | Public domain */ 5 | 6 | #include "7zCrc.h" 7 | 8 | #define kCrcPoly 0xEDB88320 9 | UInt32 g_CrcTable[256]; 10 | 11 | void MY_FAST_CALL CrcGenerateTable(void) 12 | { 13 | UInt32 i; 14 | for (i = 0; i < 256; i++) 15 | { 16 | UInt32 r = i; 17 | int j; 18 | for (j = 0; j < 8; j++) 19 | r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1)); 20 | g_CrcTable[i] = r; 21 | } 22 | } 23 | 24 | UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size) 25 | { 26 | const Byte *p = (const Byte *)data; 27 | for (; size > 0 ; size--, p++) 28 | v = CRC_UPDATE_BYTE(v, *p); 29 | return v; 30 | } 31 | 32 | UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size) 33 | { 34 | return CrcUpdate(CRC_INIT_VAL, data, size) ^ 0xFFFFFFFF; 35 | } 36 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/7zCrc.h: -------------------------------------------------------------------------------- 1 | /* 7zCrc.h -- CRC32 calculation 2 | 2008-03-13 3 | Igor Pavlov 4 | Public domain */ 5 | 6 | #ifndef __7Z_CRC_H 7 | #define __7Z_CRC_H 8 | 9 | #include 10 | 11 | #include "Types.h" 12 | 13 | extern UInt32 g_CrcTable[]; 14 | 15 | void MY_FAST_CALL CrcGenerateTable(void); 16 | 17 | #define CRC_INIT_VAL 0xFFFFFFFF 18 | #define CRC_GET_DIGEST(crc) ((crc) ^ 0xFFFFFFFF) 19 | #define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8)) 20 | 21 | UInt32 MY_FAST_CALL CrcUpdate(UInt32 crc, const void *data, size_t size); 22 | UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/7zFile.h: -------------------------------------------------------------------------------- 1 | /* 7zFile.h -- File IO 2 | 2008-11-22 : Igor Pavlov : Public domain */ 3 | 4 | #ifndef __7Z_FILE_H 5 | #define __7Z_FILE_H 6 | 7 | #ifdef _WIN32 8 | #define USE_WINDOWS_FILE 9 | #endif 10 | 11 | #ifdef USE_WINDOWS_FILE 12 | #include 13 | #else 14 | #include 15 | #endif 16 | 17 | #include "Types.h" 18 | 19 | 20 | /* ---------- File ---------- */ 21 | 22 | typedef struct 23 | { 24 | #ifdef USE_WINDOWS_FILE 25 | HANDLE handle; 26 | #else 27 | FILE *file; 28 | #endif 29 | } CSzFile; 30 | 31 | void File_Construct(CSzFile *p); 32 | WRes InFile_Open(CSzFile *p, const char *name); 33 | WRes OutFile_Open(CSzFile *p, const char *name); 34 | WRes File_Close(CSzFile *p); 35 | 36 | /* reads max(*size, remain file's size) bytes */ 37 | WRes File_Read(CSzFile *p, void *data, size_t *size); 38 | 39 | /* writes *size bytes */ 40 | WRes File_Write(CSzFile *p, const void *data, size_t *size); 41 | 42 | WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin); 43 | WRes File_GetLength(CSzFile *p, UInt64 *length); 44 | 45 | 46 | /* ---------- FileInStream ---------- */ 47 | 48 | typedef struct 49 | { 50 | ISeqInStream s; 51 | CSzFile file; 52 | } CFileSeqInStream; 53 | 54 | void FileSeqInStream_CreateVTable(CFileSeqInStream *p); 55 | 56 | 57 | typedef struct 58 | { 59 | ISeekInStream s; 60 | CSzFile file; 61 | } CFileInStream; 62 | 63 | void FileInStream_CreateVTable(CFileInStream *p); 64 | 65 | 66 | typedef struct 67 | { 68 | ISeqOutStream s; 69 | CSzFile file; 70 | } CFileOutStream; 71 | 72 | void FileOutStream_CreateVTable(CFileOutStream *p); 73 | 74 | #endif 75 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/7zVersion.h: -------------------------------------------------------------------------------- 1 | #define MY_VER_MAJOR 4 2 | #define MY_VER_MINOR 63 3 | #define MY_VER_BUILD 0 4 | #define MY_VERSION "4.63" 5 | #define MY_DATE "2008-12-31" 6 | #define MY_COPYRIGHT ": Igor Pavlov : Public domain" 7 | #define MY_VERSION_COPYRIGHT_DATE MY_VERSION " " MY_COPYRIGHT " : " MY_DATE 8 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/Alloc.h: -------------------------------------------------------------------------------- 1 | /* Alloc.h -- Memory allocation functions 2 | 2008-03-13 3 | Igor Pavlov 4 | Public domain */ 5 | 6 | #ifndef __COMMON_ALLOC_H 7 | #define __COMMON_ALLOC_H 8 | 9 | #include 10 | 11 | void *MyAlloc(size_t size); 12 | void MyFree(void *address); 13 | 14 | #ifdef _WIN32 15 | 16 | void SetLargePageSize(); 17 | 18 | void *MidAlloc(size_t size); 19 | void MidFree(void *address); 20 | void *BigAlloc(size_t size); 21 | void BigFree(void *address); 22 | 23 | #else 24 | 25 | #define MidAlloc(size) MyAlloc(size) 26 | #define MidFree(address) MyFree(address) 27 | #define BigAlloc(size) MyAlloc(size) 28 | #define BigFree(address) MyFree(address) 29 | 30 | #endif 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/Bcj2.h: -------------------------------------------------------------------------------- 1 | /* Bcj2.h -- Converter for x86 code (BCJ2) 2 | 2008-10-04 : Igor Pavlov : Public domain */ 3 | 4 | #ifndef __BCJ2_H 5 | #define __BCJ2_H 6 | 7 | #include "Types.h" 8 | 9 | /* 10 | Conditions: 11 | outSize <= FullOutputSize, 12 | where FullOutputSize is full size of output stream of x86_2 filter. 13 | 14 | If buf0 overlaps outBuf, there are two required conditions: 15 | 1) (buf0 >= outBuf) 16 | 2) (buf0 + size0 >= outBuf + FullOutputSize). 17 | 18 | Returns: 19 | SZ_OK 20 | SZ_ERROR_DATA - Data error 21 | */ 22 | 23 | int Bcj2_Decode( 24 | const Byte *buf0, SizeT size0, 25 | const Byte *buf1, SizeT size1, 26 | const Byte *buf2, SizeT size2, 27 | const Byte *buf3, SizeT size3, 28 | Byte *outBuf, SizeT outSize); 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/Bra.h: -------------------------------------------------------------------------------- 1 | /* Bra.h -- Branch converters for executables 2 | 2008-10-04 : Igor Pavlov : Public domain */ 3 | 4 | #ifndef __BRA_H 5 | #define __BRA_H 6 | 7 | #include "Types.h" 8 | 9 | /* 10 | These functions convert relative addresses to absolute addresses 11 | in CALL instructions to increase the compression ratio. 12 | 13 | In: 14 | data - data buffer 15 | size - size of data 16 | ip - current virtual Instruction Pinter (IP) value 17 | state - state variable for x86 converter 18 | encoding - 0 (for decoding), 1 (for encoding) 19 | 20 | Out: 21 | state - state variable for x86 converter 22 | 23 | Returns: 24 | The number of processed bytes. If you call these functions with multiple calls, 25 | you must start next call with first byte after block of processed bytes. 26 | 27 | Type Endian Alignment LookAhead 28 | 29 | x86 little 1 4 30 | ARMT little 2 2 31 | ARM little 4 0 32 | PPC big 4 0 33 | SPARC big 4 0 34 | IA64 little 16 0 35 | 36 | size must be >= Alignment + LookAhead, if it's not last block. 37 | If (size < Alignment + LookAhead), converter returns 0. 38 | 39 | Example: 40 | 41 | UInt32 ip = 0; 42 | for () 43 | { 44 | ; size must be >= Alignment + LookAhead, if it's not last block 45 | SizeT processed = Convert(data, size, ip, 1); 46 | data += processed; 47 | size -= processed; 48 | ip += processed; 49 | } 50 | */ 51 | 52 | #define x86_Convert_Init(state) { state = 0; } 53 | SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding); 54 | SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); 55 | SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); 56 | SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); 57 | SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); 58 | SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); 59 | 60 | #endif 61 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/BraIA64.c: -------------------------------------------------------------------------------- 1 | /* BraIA64.c -- Converter for IA-64 code 2 | 2008-10-04 : Igor Pavlov : Public domain */ 3 | 4 | #include "Bra.h" 5 | 6 | static const Byte kBranchTable[32] = 7 | { 8 | 0, 0, 0, 0, 0, 0, 0, 0, 9 | 0, 0, 0, 0, 0, 0, 0, 0, 10 | 4, 4, 6, 6, 0, 0, 7, 7, 11 | 4, 4, 0, 0, 4, 4, 0, 0 12 | }; 13 | 14 | SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding) 15 | { 16 | SizeT i; 17 | if (size < 16) 18 | return 0; 19 | size -= 16; 20 | for (i = 0; i <= size; i += 16) 21 | { 22 | UInt32 instrTemplate = data[i] & 0x1F; 23 | UInt32 mask = kBranchTable[instrTemplate]; 24 | UInt32 bitPos = 5; 25 | int slot; 26 | for (slot = 0; slot < 3; slot++, bitPos += 41) 27 | { 28 | UInt32 bytePos, bitRes; 29 | UInt64 instruction, instNorm; 30 | int j; 31 | if (((mask >> slot) & 1) == 0) 32 | continue; 33 | bytePos = (bitPos >> 3); 34 | bitRes = bitPos & 0x7; 35 | instruction = 0; 36 | for (j = 0; j < 6; j++) 37 | instruction += (UInt64)data[i + j + bytePos] << (8 * j); 38 | 39 | instNorm = instruction >> bitRes; 40 | if (((instNorm >> 37) & 0xF) == 0x5 && ((instNorm >> 9) & 0x7) == 0) 41 | { 42 | UInt32 src = (UInt32)((instNorm >> 13) & 0xFFFFF); 43 | UInt32 dest; 44 | src |= ((UInt32)(instNorm >> 36) & 1) << 20; 45 | 46 | src <<= 4; 47 | 48 | if (encoding) 49 | dest = ip + (UInt32)i + src; 50 | else 51 | dest = src - (ip + (UInt32)i); 52 | 53 | dest >>= 4; 54 | 55 | instNorm &= ~((UInt64)(0x8FFFFF) << 13); 56 | instNorm |= ((UInt64)(dest & 0xFFFFF) << 13); 57 | instNorm |= ((UInt64)(dest & 0x100000) << (36 - 20)); 58 | 59 | instruction &= (1 << bitRes) - 1; 60 | instruction |= (instNorm << bitRes); 61 | for (j = 0; j < 6; j++) 62 | data[i + j + bytePos] = (Byte)(instruction >> (8 * j)); 63 | } 64 | } 65 | } 66 | return i; 67 | } 68 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/CpuArch.h: -------------------------------------------------------------------------------- 1 | /* CpuArch.h 2 | 2008-08-05 3 | Igor Pavlov 4 | Public domain */ 5 | 6 | #ifndef __CPUARCH_H 7 | #define __CPUARCH_H 8 | 9 | /* 10 | LITTLE_ENDIAN_UNALIGN means: 11 | 1) CPU is LITTLE_ENDIAN 12 | 2) it's allowed to make unaligned memory accesses 13 | if LITTLE_ENDIAN_UNALIGN is not defined, it means that we don't know 14 | about these properties of platform. 15 | */ 16 | 17 | #if defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64) || defined(__i386__) || defined(__x86_64__) 18 | #define LITTLE_ENDIAN_UNALIGN 19 | #endif 20 | 21 | #ifdef LITTLE_ENDIAN_UNALIGN 22 | 23 | #define GetUi16(p) (*(const UInt16 *)(p)) 24 | #define GetUi32(p) (*(const UInt32 *)(p)) 25 | #define GetUi64(p) (*(const UInt64 *)(p)) 26 | #define SetUi32(p, d) *(UInt32 *)(p) = (d); 27 | 28 | #else 29 | 30 | #define GetUi16(p) (((const Byte *)(p))[0] | ((UInt16)((const Byte *)(p))[1] << 8)) 31 | 32 | #define GetUi32(p) ( \ 33 | ((const Byte *)(p))[0] | \ 34 | ((UInt32)((const Byte *)(p))[1] << 8) | \ 35 | ((UInt32)((const Byte *)(p))[2] << 16) | \ 36 | ((UInt32)((const Byte *)(p))[3] << 24)) 37 | 38 | #define GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32)) 39 | 40 | #define SetUi32(p, d) { UInt32 _x_ = (d); \ 41 | ((Byte *)(p))[0] = (Byte)_x_; \ 42 | ((Byte *)(p))[1] = (Byte)(_x_ >> 8); \ 43 | ((Byte *)(p))[2] = (Byte)(_x_ >> 16); \ 44 | ((Byte *)(p))[3] = (Byte)(_x_ >> 24); } 45 | 46 | #endif 47 | 48 | #if defined(LITTLE_ENDIAN_UNALIGN) && defined(_WIN64) && (_MSC_VER >= 1300) 49 | 50 | #pragma intrinsic(_byteswap_ulong) 51 | #pragma intrinsic(_byteswap_uint64) 52 | #define GetBe32(p) _byteswap_ulong(*(const UInt32 *)(const Byte *)(p)) 53 | #define GetBe64(p) _byteswap_uint64(*(const UInt64 *)(const Byte *)(p)) 54 | 55 | #else 56 | 57 | #define GetBe32(p) ( \ 58 | ((UInt32)((const Byte *)(p))[0] << 24) | \ 59 | ((UInt32)((const Byte *)(p))[1] << 16) | \ 60 | ((UInt32)((const Byte *)(p))[2] << 8) | \ 61 | ((const Byte *)(p))[3] ) 62 | 63 | #define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4)) 64 | 65 | #endif 66 | 67 | #define GetBe16(p) (((UInt16)((const Byte *)(p))[0] << 8) | ((const Byte *)(p))[1]) 68 | 69 | #endif 70 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/LzHash.h: -------------------------------------------------------------------------------- 1 | /* LzHash.h -- HASH functions for LZ algorithms 2 | 2008-10-04 : Igor Pavlov : Public domain */ 3 | 4 | #ifndef __LZHASH_H 5 | #define __LZHASH_H 6 | 7 | #define kHash2Size (1 << 10) 8 | #define kHash3Size (1 << 16) 9 | #define kHash4Size (1 << 20) 10 | 11 | #define kFix3HashSize (kHash2Size) 12 | #define kFix4HashSize (kHash2Size + kHash3Size) 13 | #define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size) 14 | 15 | #define HASH2_CALC hashValue = cur[0] | ((UInt32)cur[1] << 8); 16 | 17 | #define HASH3_CALC { \ 18 | UInt32 temp = p->crc[cur[0]] ^ cur[1]; \ 19 | hash2Value = temp & (kHash2Size - 1); \ 20 | hashValue = (temp ^ ((UInt32)cur[2] << 8)) & p->hashMask; } 21 | 22 | #define HASH4_CALC { \ 23 | UInt32 temp = p->crc[cur[0]] ^ cur[1]; \ 24 | hash2Value = temp & (kHash2Size - 1); \ 25 | hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \ 26 | hashValue = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)) & p->hashMask; } 27 | 28 | #define HASH5_CALC { \ 29 | UInt32 temp = p->crc[cur[0]] ^ cur[1]; \ 30 | hash2Value = temp & (kHash2Size - 1); \ 31 | hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \ 32 | hash4Value = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)); \ 33 | hashValue = (hash4Value ^ (p->crc[cur[4]] << 3)) & p->hashMask; \ 34 | hash4Value &= (kHash4Size - 1); } 35 | 36 | /* #define HASH_ZIP_CALC hashValue = ((cur[0] | ((UInt32)cur[1] << 8)) ^ p->crc[cur[2]]) & 0xFFFF; */ 37 | #define HASH_ZIP_CALC hashValue = ((cur[2] | ((UInt32)cur[0] << 8)) ^ p->crc[cur[1]]) & 0xFFFF; 38 | 39 | 40 | #define MT_HASH2_CALC \ 41 | hash2Value = (p->crc[cur[0]] ^ cur[1]) & (kHash2Size - 1); 42 | 43 | #define MT_HASH3_CALC { \ 44 | UInt32 temp = p->crc[cur[0]] ^ cur[1]; \ 45 | hash2Value = temp & (kHash2Size - 1); \ 46 | hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); } 47 | 48 | #define MT_HASH4_CALC { \ 49 | UInt32 temp = p->crc[cur[0]] ^ cur[1]; \ 50 | hash2Value = temp & (kHash2Size - 1); \ 51 | hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \ 52 | hash4Value = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)) & (kHash4Size - 1); } 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/LZMA/easylzma/pavlov/LzmaLib.c: -------------------------------------------------------------------------------- 1 | /* LzmaLib.c -- LZMA library wrapper 2 | 2008-08-05 3 | Igor Pavlov 4 | Public domain */ 5 | 6 | #include "LzmaEnc.h" 7 | #include "LzmaDec.h" 8 | #include "Alloc.h" 9 | #include "LzmaLib.h" 10 | 11 | static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); } 12 | static void SzFree(void *p, void *address) { p = p; MyFree(address); } 13 | static ISzAlloc g_Alloc = { SzAlloc, SzFree }; 14 | 15 | MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen, 16 | unsigned char *outProps, size_t *outPropsSize, 17 | int level, /* 0 <= level <= 9, default = 5 */ 18 | unsigned dictSize, /* use (1 << N) or (3 << N). 4 KB < dictSize <= 128 MB */ 19 | int lc, /* 0 <= lc <= 8, default = 3 */ 20 | int lp, /* 0 <= lp <= 4, default = 0 */ 21 | int pb, /* 0 <= pb <= 4, default = 2 */ 22 | int fb, /* 5 <= fb <= 273, default = 32 */ 23 | int numThreads /* 1 or 2, default = 2 */ 24 | ) 25 | { 26 | CLzmaEncProps props; 27 | LzmaEncProps_Init(&props); 28 | props.level = level; 29 | props.dictSize = dictSize; 30 | props.lc = lc; 31 | props.lp = lp; 32 | props.pb = pb; 33 | props.fb = fb; 34 | props.numThreads = numThreads; 35 | 36 | return LzmaEncode(dest, destLen, src, srcLen, &props, outProps, outPropsSize, 0, 37 | NULL, &g_Alloc, &g_Alloc); 38 | } 39 | 40 | 41 | MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen, 42 | const unsigned char *props, size_t propsSize) 43 | { 44 | ELzmaStatus status; 45 | return LzmaDecode(dest, destLen, src, srcLen, props, (unsigned)propsSize, LZMA_FINISH_ANY, &status, &g_Alloc); 46 | } 47 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/Mods.h: -------------------------------------------------------------------------------- 1 | #ifndef MODS_H 2 | #define MODS_H 3 | 4 | class Mods 5 | { 6 | struct Modifier 7 | { 8 | // visual modifiers 9 | bool HD = false; // shows then hides hides notes before hitting 10 | bool FI = false; // shows notes right before hitting (mania) 11 | bool FL = false; // shows a limited section of the play field 12 | bool RV = false; // flips the notes on a diagonal x-y axis 13 | 14 | // difficulty modifiers 15 | bool HT = false; // Half time (-TM) 16 | bool DT = false; // Double time (+TM) 17 | bool EZ = false; // Easy (-CS, -OD, -AR) 18 | bool HR = false; // Hard Rock (+CS, +OD, +AR) 19 | }; 20 | 21 | 22 | public: 23 | enum MODS 24 | { 25 | NM = 0 << 0, 26 | NF = 1 << 0, 27 | EZ = 1 << 1, 28 | // video mod no longer exists 29 | HD = 1 << 3, 30 | HR = 1 << 4, 31 | SD = 1 << 5, 32 | DT = 1 << 6, 33 | RL = 1 << 7, 34 | HT = 1 << 8, 35 | NC = 1 << 9, 36 | FL = 1 << 10, 37 | AU = 1 << 11, 38 | SO = 1 << 12, 39 | AP = 1 << 13, 40 | PF = 1 << 14, 41 | K4 = 1 << 15, 42 | K5 = 1 << 16, 43 | K6 = 1 << 17, 44 | K7 = 1 << 18, 45 | K8 = 1 << 19, 46 | FI = 1 << 20, 47 | RD = 1 << 21, 48 | // Cinema 49 | // Taget practice 50 | K9 = 1 << 24, 51 | CP = 1 << 25, 52 | // ??? 53 | }; 54 | 55 | Mods(); 56 | 57 | void setModifier(MODS _mod); 58 | Modifier getModifier(); 59 | 60 | void setAR(double _AR); 61 | void setCS(double _CS); 62 | void setOD(double _OD); 63 | void setTM(double _TM); 64 | 65 | double getAR(); 66 | double getCS(); 67 | double getOD(); 68 | double getTM(); 69 | 70 | private: 71 | void ApplyDiffMods(); 72 | 73 | Modifier mod; 74 | 75 | double AR; // Approach rate 76 | double CS; // Circle Size 77 | double OD; // Overall Difficulty (how precise the hits need to be) 78 | double TM; // Time multiplier; how faster the map is 79 | }; 80 | 81 | #endif // !MODS_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/Play.h: -------------------------------------------------------------------------------- 1 | #ifndef PLAY_H 2 | #define PLAY_H 3 | 4 | #include "Beatmap.h" 5 | #include "Replay.h" 6 | #include "Mods.h" 7 | 8 | class ScoreEngine; 9 | 10 | class Play 11 | { 12 | public: 13 | enum ModSource 14 | { 15 | BEATMAP, 16 | REPLAY, 17 | CUSTOM 18 | }; 19 | 20 | Play(); 21 | virtual ~Play(); 22 | 23 | Beatmap *beatmap; 24 | Replay *replay; 25 | ScoreEngine *scoreEngine; 26 | Mods custom; 27 | 28 | void LoadBeatmap(std::string _beatmapFile); 29 | void LoadReplay(std::string _replayFile); 30 | 31 | void setMods(ModSource _source); 32 | Mods* getMod(); 33 | 34 | private: 35 | 36 | void ValidateMods(); 37 | 38 | void ApplyMods(); 39 | void ApplyVisual(); 40 | void ApplyTimings(); 41 | 42 | Mods activeMods, prevMods; 43 | ModSource currModSource; 44 | }; 45 | 46 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/Replay.h: -------------------------------------------------------------------------------- 1 | #ifndef REPLAY_H 2 | #define REPLAY_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include "../../irrlicht/include/vector2d.h" 9 | 10 | #include "../osuEnums.h" 11 | #include "../osuStructs.h" 12 | #include "Beatmap.h" 13 | 14 | 15 | class Replay 16 | { 17 | friend class Play; 18 | 19 | public: 20 | Replay(); 21 | virtual ~Replay(); 22 | 23 | void ProcessReplay(std::string _filepath, Beatmap* _beatmap); 24 | 25 | osu::TIMING getFrameAt(long _time); 26 | osu::TIMING getFrame(int _frame) const; 27 | std::vector& const getReplayStream(); 28 | int getNumFrames(); 29 | 30 | Mods getMods(); 31 | 32 | bool isValid(); 33 | bool isBeatmap(std::string* _MD5); 34 | bool isGamemode(GAMEMODE _gamemode); 35 | 36 | private: 37 | enum DATA 38 | { 39 | TIME = 0, 40 | MOUSE = 1, 41 | KEYBRD = 2 42 | }; 43 | 44 | // Generated 45 | std::vector replayStream; 46 | 47 | // Extracted from replay data 48 | std::string beatmapMD5; 49 | char gameMode; 50 | int version; 51 | std::string player; 52 | std::string replayMD5; 53 | short num300; 54 | short num200; 55 | short num50; 56 | short numMax; 57 | short num100; 58 | short numMiss; 59 | int score; 60 | short combo; 61 | char perfect; 62 | int mods; 63 | std::string graph; 64 | long long timestamp; 65 | 66 | Mods mod; 67 | 68 | // *.osr file reading 69 | bool ParseFile(std::ifstream &_replayFile); 70 | void ParseReplayData(unsigned char* _data, size_t _length, char _gamemode); 71 | std::string ReadOsuStr(std::ifstream &_replayFile); 72 | 73 | // Data processing 74 | void ValidateMods(); 75 | void ApplyMods(); 76 | 77 | int FindFrameAt(long _time); 78 | 79 | private: 80 | void ClearReplay(); 81 | }; 82 | 83 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/TimingPoint.cpp: -------------------------------------------------------------------------------- 1 | #include "TimingPoint.h" 2 | 3 | TimingPoint::TimingPoint() 4 | { 5 | 6 | } 7 | 8 | double TimingPoint::getBPM(bool raw) 9 | { 10 | if (raw) 11 | return 60000 / this->beatInterval; 12 | else 13 | return this->BPM; 14 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Filestructure/TimingPoint.h: -------------------------------------------------------------------------------- 1 | #ifndef TIMINGPOINT_H 2 | #define TIMINGPOINT_H 3 | 4 | class TimingPoint 5 | { 6 | friend class Beatmap; 7 | 8 | public: 9 | TimingPoint(); 10 | 11 | int offset = -1; 12 | double beatInterval = 0; 13 | double beatLength = 0; 14 | int meter = -1; 15 | bool inherited = 0; 16 | 17 | double sm = -1; // processed 18 | 19 | double getBPM(bool raw = false); 20 | 21 | private: 22 | double BPM; 23 | }; 24 | 25 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/ScoreEngine.cpp: -------------------------------------------------------------------------------- 1 | #include "ScoreEngine.h" 2 | 3 | #include "osu-std/score.h" 4 | #include "osu-catch/score.h" 5 | #include "osu-taiko/score.h" 6 | #include "osu-mania/score.h" 7 | #include "osu-dodge/score.h" 8 | 9 | #include 10 | 11 | ScoreEngine::ScoreEngine(){} 12 | 13 | void ScoreEngine::genAccTimings(Play* _play) 14 | { 15 | // need beatmap and replay for score generation 16 | if (!_play->beatmap->isValid()) return; 17 | if (!_play->replay->isValid()) return; 18 | 19 | GAMEMODE gamemode = _play->beatmap->getGamemode(); 20 | switch (gamemode) 21 | { 22 | case OSU_STANDARD: 23 | OSUSTANDARD::genAccTimings(_play); 24 | /// OSUSTANDARD::genPrcTimings(_play); \TODO 25 | break; 26 | 27 | case OSU_TAIKO: 28 | OSUTAIKO::genAccTimings(_play); 29 | break; 30 | 31 | case OSU_CATCH: 32 | OSUCATCH::genAccTimings(_play); 33 | break; 34 | 35 | case OSU_MANIA: 36 | OSUMANIA::genAccTimings(_play); 37 | break; 38 | 39 | case OSU_DODGE: 40 | OSUDODGE::genAccTimings(_play); 41 | break; 42 | 43 | default: 44 | break; 45 | } 46 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/ScoreEngine.h: -------------------------------------------------------------------------------- 1 | #ifndef SCORENGINE_H 2 | #define SCORENGINE_H 3 | 4 | #include 5 | 6 | #include "../Filestructure/Play.h" 7 | #include "../osu_mania.h" 8 | 9 | class ScoreEngine 10 | { 11 | public: 12 | ScoreEngine(); 13 | void genAccTimings(Play* _play); 14 | }; 15 | 16 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/osu-catch/score.cpp: -------------------------------------------------------------------------------- 1 | #include "score.h" 2 | 3 | std::vector OSUCATCH::accTimings; 4 | static Play* play; 5 | 6 | void OSUCATCH::genAccTimings(Play* _play) 7 | { 8 | accTimings.clear(); 9 | std::vector().swap(accTimings); 10 | 11 | play = _play; 12 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/osu-catch/score.h: -------------------------------------------------------------------------------- 1 | #ifndef CATCH_SCORE_H 2 | #define CATCH_SCORE_H 3 | 4 | #include 5 | 6 | #include "../../osu_catch.h" 7 | #include "../../Filestructure/Play.h" 8 | #include "../../osuStructs.h" 9 | 10 | namespace OSUCATCH 11 | { 12 | extern std::vector accTimings; 13 | 14 | void genAccTimings(Play* _play); 15 | 16 | std::tuple getNextEvent(int* _iFrame); 17 | 18 | std::pair getODms(Hitobject* _prevNote, Hitobject* _currNote, Hitobject* _nextNote, bool _press); 19 | }; 20 | 21 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/osu-dodge/score.cpp: -------------------------------------------------------------------------------- 1 | #include "score.h" 2 | 3 | std::vector OSUDODGE::accTimings; 4 | static Play* play; 5 | 6 | void OSUDODGE::genAccTimings(Play* _play) 7 | { 8 | accTimings.clear(); 9 | std::vector().swap(accTimings); 10 | 11 | play = _play; 12 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/osu-dodge/score.h: -------------------------------------------------------------------------------- 1 | #ifndef DODGE_SCORE_H 2 | #define DODGE_SCORE_H 3 | 4 | #include 5 | 6 | #include "../../osu_dodge.h" 7 | #include "../../Filestructure/Play.h" 8 | #include "../../osuStructs.h" 9 | 10 | namespace OSUDODGE 11 | { 12 | extern std::vector accTimings; 13 | 14 | void genAccTimings(Play* _play); 15 | 16 | std::tuple getNextEvent(int* _iFrame); 17 | 18 | std::pair getODms(Hitobject* _prevNote, Hitobject* _currNote, Hitobject* _nextNote, bool _press); 19 | }; 20 | 21 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/osu-mania/score.h: -------------------------------------------------------------------------------- 1 | #ifndef MANIA_SCORE_H 2 | #define MANIA_SCORE_H 3 | 4 | #include 5 | 6 | #include "../../osu_mania.h" 7 | #include "../../Filestructure/Play.h" 8 | #include "../../osuStructs.h" 9 | 10 | namespace OSUMANIA 11 | { 12 | extern std::vector accTimings; 13 | 14 | void genAccTimings(Play* _play); 15 | std::tuple getNextEvent(int* _iFrame); 16 | 17 | int getJudgment(int _frameTime, int _noteTime, bool _pressState); 18 | 19 | namespace SCORE 20 | { 21 | struct KeyInfo 22 | { 23 | double hitTiming; 24 | int key; 25 | std::vector* pressState; 26 | std::vector* nextNote; 27 | }; 28 | 29 | int getJudgment(int _frameTime, int _noteTime, bool _pressState); 30 | std::pair getODms(Hitobject* _prevNote, Hitobject* _currNote, Hitobject* _nextNote, bool _press); 31 | 32 | void processHit(std::vector* _accTimings, Hitobject* _currNote, KeyInfo _info); 33 | void processMiss(std::vector* _accTimings, Hitobject* _currNote, KeyInfo _info); 34 | void HandleEarlyMiss(std::vector* _accTimings, Hitobject* _currNote, KeyInfo _info); 35 | }; 36 | }; 37 | 38 | #endif // !MANIA_SCORE_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/osu-std/score.h: -------------------------------------------------------------------------------- 1 | #ifndef STANDARD_SCORE_H 2 | #define STANDARD_SCORE_H 3 | 4 | #include 5 | 6 | #include "../../osu_standard.h" 7 | #include "../../Filestructure/Play.h" 8 | #include "../../osuStructs.h" 9 | 10 | namespace OSUSTANDARD 11 | { 12 | extern std::vector accTimings; 13 | 14 | void genAccTimings(Play* _play); 15 | bool sortAccTimings(osu::TIMING i, osu::TIMING j); 16 | 17 | std::tuple getNextEvent(int* _iFrame); 18 | Hitobject* getNextNote(int* _iNote); 19 | 20 | namespace SCORE 21 | { 22 | struct KeyInfo 23 | { 24 | double hitTiming; 25 | int key; 26 | std::vector* pressState; 27 | bool* nextNote; 28 | }; 29 | 30 | int getJudgment(int _frameTime, int _noteTime, bool _pressState); 31 | 32 | void processHit(std::vector* _accTimings, Hitobject* _currNote, KeyInfo _info); 33 | void processMiss(std::vector* _accTimings, Hitobject* _currNote, KeyInfo _info); 34 | void HandleEarlyMiss(std::vector* _accTimings, Hitobject* _currNote, KeyInfo _info); 35 | }; 36 | }; 37 | 38 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/osu-taiko/score.cpp: -------------------------------------------------------------------------------- 1 | #include "score.h" 2 | 3 | std::vector OSUTAIKO::accTimings; 4 | static Play* play; 5 | 6 | void OSUTAIKO::genAccTimings(Play* _play) 7 | { 8 | play = _play; 9 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/Score/osu-taiko/score.h: -------------------------------------------------------------------------------- 1 | #ifndef TAIKO_SCORE_H 2 | #define TAIKO_SCORE_H 3 | 4 | #include 5 | 6 | #include "../../osu_taiko.h" 7 | #include "../../Filestructure/Play.h" 8 | #include "../../osuStructs.h" 9 | 10 | namespace OSUTAIKO 11 | { 12 | extern std::vector accTimings; 13 | 14 | void genAccTimings(Play* _play); 15 | 16 | std::tuple getNextEvent(int* _iFrame); 17 | Hitobject* getNextNoteOnColumn(int _column, int* _iNote); 18 | 19 | std::pair getODms(Hitobject* _prevNote, Hitobject* _currNote, Hitobject* _nextNote, bool _press); 20 | }; 21 | 22 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osuCalc.cpp: -------------------------------------------------------------------------------- 1 | #include "osuCalc.h" 2 | #include "../utils/mathUtils.h" 3 | 4 | // diameter 5 | double CS2px(double _CS) 6 | { 7 | return 109 - 9 * _CS; 8 | } 9 | 10 | // diameter 11 | double px2CS(double _px) 12 | { 13 | return (109 - _px) / 9; 14 | } 15 | 16 | double AR2ms(double _AR) 17 | { 18 | if (_AR <= 5) return 1800 - 120 * _AR; 19 | else return 1950 - 150 * _AR; 20 | } 21 | 22 | double ms2AR(double _ms) 23 | { 24 | if (_ms >= 1200.0) return (1800 - _ms) / 120.0; 25 | else return (1950 - _ms) / 150.0; 26 | } 27 | 28 | // for 300 score 29 | double OD2ms(double _OD) 30 | { 31 | return 79.5 - 6.0 * _OD; 32 | } 33 | 34 | // for 300 score 35 | double ms2OD(double _ms) 36 | { 37 | return (79.5 - _ms) / 6.0; 38 | } 39 | 40 | // Slider osu!px/s 41 | double SV2px_s(double _SV, double _BPM) 42 | { 43 | return (_BPM / 60.0) * _SV * 100; 44 | } 45 | 46 | // Approach Circle at t 47 | double ApCS2px_ps(double _CS, double _AR, double _t) 48 | { 49 | return 4 * CS2px(_CS) - 3 * CS2px(_CS) * (_t / MAX(800, AR2ms(_AR))); 50 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osuCalc.h: -------------------------------------------------------------------------------- 1 | #ifndef OSUCALC_H 2 | #define OSUCALC_H 3 | 4 | double CS2px(double _CS); 5 | 6 | double px2CS(double _px); 7 | 8 | double AR2ms(double _AR); 9 | 10 | double ms2AR(double _ms); 11 | 12 | // for 300 score 13 | double OD2ms(double _OD); 14 | 15 | // for 300 score 16 | double ms2OD(double _ms); 17 | 18 | // Slider osu!px/s 19 | double SV2px_s(double _SV, double _BPM); 20 | 21 | // Approach Circle at t 22 | double ApCS2px_ps(double _CS, double _AR, double _t); 23 | 24 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osuEnums.h: -------------------------------------------------------------------------------- 1 | #ifndef OSU_ENUMS 2 | #define OSU_ENUMS 3 | 4 | enum GAMEMODE 5 | { 6 | OSU_STANDARD = 0, 7 | OSU_TAIKO = 1, 8 | OSU_CATCH = 2, 9 | OSU_MANIA = 3, 10 | OSU_DODGE = 4, 11 | GAMEMODE_ERROR 12 | }; 13 | 14 | /// \TODO: The Mods class takes care of this, so get rid of this 15 | enum MODS 16 | { 17 | // non 18 | NF = 1 << 0, 19 | EZ = 1 << 1, 20 | // video mod no longer exists 21 | HD = 1 << 3, 22 | HR = 1 << 4, 23 | SD = 1 << 5, 24 | DT = 1 << 6, 25 | RL = 1 << 7, 26 | HT = 1 << 8, 27 | NC = 1 << 9, 28 | FL = 1 << 10, 29 | AU = 1 << 11, 30 | SO = 1 << 12, 31 | AP = 1 << 13, 32 | PF = 1 << 14, 33 | K4 = 1 << 15, 34 | K5 = 1 << 16, 35 | K6 = 1 << 17, 36 | K7 = 1 << 18, 37 | K8 = 1 << 19, 38 | FI = 1 << 20, 39 | RD = 1 << 21, 40 | // Cinema 41 | // Taget practice 42 | K9 = 1 << 24, 43 | CP = 1 << 25, 44 | // ??? 45 | }; 46 | 47 | enum HITOBJECTYPE 48 | { 49 | CIRCLE = 1 << 0, 50 | SLIDER = 1 << 1, 51 | NCOMBO = 1 << 2, 52 | SPINNER = 1 << 3, 53 | // ??? 54 | MANIALONG = 1 << 7 55 | }; 56 | 57 | namespace HITOBJECTNORMAL 58 | { 59 | enum 60 | { 61 | XPOS = 0, 62 | YPOS = 1, 63 | TIME = 2, 64 | TYPE = 3, 65 | HITSOUND = 4, 66 | ADDITION = 5 67 | }; 68 | }; 69 | 70 | namespace HITOBJECTSLIDER 71 | { 72 | enum 73 | { 74 | XPOS = 0, 75 | YPOS = 1, 76 | TIME = 2, 77 | TYPE = 3, 78 | HITSOUND = 4, 79 | SLIDERTYPE = 5, 80 | PIXELENGTH = 6, 81 | ADDITION = 5 82 | }; 83 | }; 84 | 85 | namespace HITOBJECTSPINNER 86 | { 87 | enum 88 | { 89 | XPOS = 0, 90 | YPOS = 1, 91 | TIME = 2, 92 | TYPE = 3, 93 | HITSOUND = 4, 94 | ENDTIME = 5, 95 | ADDITION = 6 96 | }; 97 | }; 98 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osuStructs.cpp: -------------------------------------------------------------------------------- 1 | #include "osuStructs.h" 2 | #include "../utils/mathUtils.h" 3 | 4 | int osu::FindTimingAt(std::vector& _timings, double _time) 5 | { 6 | int start = 0; 7 | int end = _timings.size() - 2; 8 | int mid; 9 | 10 | while (start <= end) 11 | { 12 | mid = (start + end) / 2; 13 | 14 | if (BTWN(_timings[mid].time, _time, _timings[mid + 1].time)) 15 | return mid + 1; 16 | 17 | if (_time < _timings[mid].time) 18 | end = mid - 1; 19 | else 20 | start = mid + 1; 21 | } 22 | } 23 | 24 | bool sortATimings(osu::TIMING i, osu::TIMING j) 25 | { 26 | return i.time < j.time; 27 | } 28 | 29 | 30 | void osu::SortByTime(std::vector& _timings) 31 | { 32 | std::sort(_timings.begin(), _timings.end(), sortATimings); 33 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osuStructs.h: -------------------------------------------------------------------------------- 1 | #ifndef OSUSTRUCTS_H 2 | #define OSUSTRUCTS_H 3 | 4 | #include 5 | #include "../irrlicht/include/vector2d.h" 6 | 7 | namespace osu 8 | { 9 | struct TIMING 10 | { 11 | long time; // The what time this occurs at 12 | double data; // generic data associated with this timing 13 | int key; // generic integral data (can be used for which key pressed, timing state, etc) 14 | bool press; // generic boolean data (can be used to determine slider or not, pressed key or not, etc) 15 | 16 | irr::core::vector2df pos; // additional timing info for 2d coordinates 17 | }; 18 | 19 | int FindTimingAt(std::vector& _timings, double _time); 20 | void SortByTime(std::vector& _timings); 21 | }; 22 | 23 | #endif // !OSUSTRUCTS_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osu_catch.h: -------------------------------------------------------------------------------- 1 | #ifndef OSU_CATCH_H 2 | #define OSU_CATCH_H 3 | 4 | #include 5 | #include "osuStructs.h" 6 | 7 | namespace OSUCATCH 8 | { 9 | 10 | } 11 | 12 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osu_dodge.h: -------------------------------------------------------------------------------- 1 | #ifndef OSU_DODGE_H 2 | #define OSU_DODGE_H 3 | 4 | #include 5 | #include "osuStructs.h" 6 | 7 | namespace OSUDODGE 8 | { 9 | 10 | } 11 | 12 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osu_mania.h: -------------------------------------------------------------------------------- 1 | #ifndef OSU_MANIA_H 2 | #define OSU_MANIA_H 3 | 4 | #include "../utils/mathUtils.h" 5 | #include "../osu!/Filestructure/Play.h" 6 | #include "osuStructs.h" 7 | 8 | namespace OSUMANIA 9 | { 10 | const int MANIA_END = -1; 11 | 12 | // dir = true -> look forward 13 | // dir = false -> look backward 14 | int FindHitobjectAt(Play* _play, long _time, int _key, bool _dir); 15 | 16 | // Returns the key column based on the xpos of the note and the number of keys there are 17 | int getKey(int _xpos, int _keys); 18 | 19 | // Fetches the next note in the specified column. Returns nullptr and sets the index to -1 if it has reached the end 20 | Hitobject* getNextNoteOnColumn(Play* _play, int _column, int* _iNote); 21 | 22 | // Fetches the index of the next note in the specified column. Returns -1 if it has reached the end 23 | int getNextIndexOnColumn(std::vector& _hitobjects, int _column, int _keys, int _iNote); 24 | 25 | int getNumPressesOnNextTiming(Play* _play, int* _iNote); 26 | 27 | // Checks to see if all indices came to an end in terms of time indicated by indices _i 28 | bool isAtEnd(int _KEYS, std::vector& _i, std::vector& _hitobjects); 29 | 30 | // Checks to see of _keyCheck is behind all other columns in terms of time indicated by indices _i 31 | bool isBehindOtherColumns(int _KEYS, int _keyCheck, std::vector& _i, std::vector& _hitobjects); 32 | 33 | int getButtonState(int _prevKey, int _currKey, int _key); 34 | } 35 | 36 | #endif // !OSU_MANIA_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osu_standard.h: -------------------------------------------------------------------------------- 1 | #ifndef OSU_STANDARD_H 2 | #define OSU_STANDARD_H 3 | 4 | #include 5 | #include 6 | #include "../irrlicht/include/vector2d.h" 7 | #include "Filestructure\Hitobject.h" 8 | #include "Filestructure\SliderHitObject.h" 9 | #include "osuStructs.h" 10 | 11 | namespace OSUSTANDARD 12 | { 13 | int FindHitobjectAt(std::vector& _hitobjects, long _time, bool _dir = false); 14 | bool isHitobjectAt(std::vector& _hitobjects, long _prevTime, long _currTime); 15 | 16 | std::vector getPattern(std::vector& _hitobjects, int _num, double _interval, long _time, bool _skipSliders = false, bool _newHitobject = false); 17 | osu::TIMING getNextTickPoint(std::vector& _hitobjects, long* _time); 18 | 19 | int getButtonState(int _prevKey, int _currKey); 20 | } 21 | 22 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/osu!/osu_taiko.h: -------------------------------------------------------------------------------- 1 | #ifndef OSU_TAIKO_H 2 | #define OSU_TAIKO_H 3 | 4 | #include 5 | #include "osuStructs.h" 6 | 7 | namespace OSUTAIKO 8 | { 9 | } 10 | 11 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Button.cpp: -------------------------------------------------------------------------------- 1 | #include "Button.h" 2 | #include "../utils/mathUtils.h" 3 | 4 | Button::Button(GuiObj* _parent) : GuiObj(0, 0, 0, 0, _parent){} 5 | 6 | Button::Button(int _xpos, int _ypos, int _width, int _height, GuiObj* _parent) : GuiObj(_xpos, _ypos, _width, _height, _parent) 7 | { 8 | pressed = false; 9 | triggered = false; 10 | 11 | state = IDLE; 12 | guiType = "Button"; 13 | } 14 | 15 | Button::~Button() 16 | { 17 | 18 | } 19 | 20 | void Button::Resize(int _width, int _height) 21 | { 22 | width = _width; 23 | height = _height; 24 | } 25 | 26 | bool Button::isPressed() 27 | { 28 | return pressed; 29 | } 30 | 31 | bool Button::isTriggered() 32 | { 33 | return triggered; 34 | } 35 | 36 | 37 | // -------- Private -------- 38 | 39 | 40 | void Button::Draw(Window &_win) 41 | { 42 | switch (state) 43 | { 44 | case IDLE: 45 | _win.driver->draw2DRectangle(video::SColor(255, 150, 150, 150), 46 | core::rect(absXpos, absYpos, absXpos + width, absYpos + height)); 47 | break; 48 | 49 | case HOLD: 50 | _win.driver->draw2DRectangle(video::SColor(255, 100, 100, 100), 51 | core::rect(absXpos, absYpos, absXpos + width, absYpos + height)); 52 | break; 53 | 54 | default: 55 | // ??? 56 | break; 57 | } 58 | } 59 | 60 | void Button::UpdateInternal(Window &_win) 61 | { 62 | switch (state) 63 | { 64 | case IDLE: 65 | IdleLogic(_win); 66 | break; 67 | 68 | case HOLD: 69 | HoldLogic(_win); 70 | break; 71 | 72 | default: 73 | // ??? 74 | break; 75 | } 76 | } 77 | 78 | void Button::IdleLogic(Window &_win) 79 | { 80 | bool leftEdge = _win.reciever.GetMouseState().LeftButtonEdge; 81 | if (this->isMouseOnObj(_win, true) && leftEdge) 82 | { 83 | state = HOLD; 84 | pressed = true; 85 | triggered = true; 86 | } 87 | } 88 | 89 | void Button::HoldLogic(Window &_win) 90 | { 91 | bool leftButton = _win.reciever.GetMouseState().LeftButtonDown; 92 | 93 | triggered = false; 94 | 95 | if (!leftButton) 96 | { 97 | state = IDLE; 98 | pressed = false; 99 | } 100 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Button.h: -------------------------------------------------------------------------------- 1 | #ifndef BUTTON_H 2 | #define BUTTON_H 3 | 4 | #include "Window.h" 5 | #include "GuiObj.h" 6 | 7 | class Button: public GuiObj 8 | { 9 | public: 10 | Button(GuiObj* _parent = nullptr); 11 | Button(int _xpos, int _ypos, int _width, int _height, GuiObj* parent = nullptr); 12 | virtual ~Button(); 13 | 14 | void Resize(int _width, int _height); 15 | 16 | bool isPressed(); 17 | bool isTriggered(); 18 | 19 | private: 20 | bool pressed, triggered; 21 | 22 | enum State 23 | { 24 | IDLE = 0, 25 | HOLD = 1 26 | }state; 27 | 28 | virtual void Draw(Window &_win); 29 | virtual void UpdateInternal(Window &_win); 30 | 31 | void IdleLogic(Window &_win); 32 | void HoldLogic(Window &_win); 33 | }; 34 | 35 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/ColorTable.cpp: -------------------------------------------------------------------------------- 1 | #include "ColorTable.h" 2 | #include 3 | 4 | ColorTable::ColorTable() {} 5 | 6 | ColorTable::~ColorTable() {} 7 | 8 | bool sortTable(std::pair _val1, std::pair _val2) 9 | { 10 | return _val1.first < _val2.first; 11 | } 12 | 13 | void ColorTable::AddValueMap(double _val, irr::video::SColor _color) 14 | { 15 | table.push_back(std::pair(_val, _color)); 16 | std::sort(table.begin(), table.end(), sortTable); 17 | } 18 | 19 | irr::video::SColor ColorTable::getColor(double _val) 20 | { 21 | for (int i = table.size() - 1; i >= 0; i--) 22 | { 23 | if (_val >= table[i].first) 24 | return table[i].second; 25 | } 26 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/ColorTable.h: -------------------------------------------------------------------------------- 1 | #ifndef COLORTABLE_H 2 | #define COLORTABLE_H 3 | 4 | #include 5 | #include "../irrlicht/include/SColor.h" 6 | 7 | class ColorTable 8 | { 9 | public: 10 | ColorTable(); 11 | virtual ~ColorTable(); 12 | 13 | void AddValueMap(double _val, irr::video::SColor _color); 14 | irr::video::SColor getColor(double _val); 15 | 16 | private: 17 | std::vector> table; // higher than currValue, but before next value corresponds to the color 18 | }; 19 | 20 | #endif // !COLORTABLE_H -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Dialog.h: -------------------------------------------------------------------------------- 1 | #ifndef DIALOG_H 2 | #define DIALOG_H 3 | 4 | #include "Window.h" 5 | #include "GuiObj.h" 6 | #include "pane.h" 7 | #include "Button.h" 8 | 9 | class Dialog: public GuiObj 10 | { 11 | public: 12 | Dialog(int _xpos, int _ypos, int _width, int _height, GuiObj* _parent = nullptr); 13 | virtual ~Dialog(); 14 | 15 | private: 16 | const int TITLEBAR_SIZE = 12; 17 | 18 | Pane* pane; 19 | 20 | Button* btnToggleMinimize; 21 | Button* btnClose; 22 | Button* titleBar; 23 | Button* resize; 24 | 25 | enum State 26 | { 27 | MINIMIZED = 0, 28 | MAXIMIZED = 1 29 | }state; 30 | 31 | 32 | virtual void Draw(Window& _win); 33 | virtual void UpdateInternal(Window& _win); 34 | }; 35 | 36 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Event.h: -------------------------------------------------------------------------------- 1 | #ifndef EVENT_H 2 | #define EVENT_H 3 | 4 | #include "../irrlicht/include/irrlicht.h" 5 | 6 | using namespace irr; 7 | using namespace core; 8 | 9 | class EventReceiver : public IEventReceiver 10 | { 11 | public: 12 | EventReceiver(); 13 | 14 | struct SMouseState 15 | { 16 | int wheelCurr, wheelPrev, wheelMove; 17 | core::position2di positionCurr, positionPrev, positionMove; 18 | bool LeftButtonDown, LeftButtonEdge; 19 | SMouseState() : LeftButtonDown(false), LeftButtonEdge(false) { } 20 | }; 21 | 22 | virtual bool OnEvent(const SEvent& event); 23 | void Update(); 24 | 25 | virtual bool IsKeyDown(EKEY_CODE keyCode) const; 26 | bool IsKeyEdgeDown(EKEY_CODE keyCode) const; 27 | bool IsKeyEdgeUp(EKEY_CODE keyCode) const; 28 | 29 | const SMouseState &GetMouseState(void) const; 30 | int getWheel(bool _mode = false); // _mode = 0: 0 if no change, _mode = 1: get the last value 31 | vector2di getCursorDelta(); 32 | 33 | private: 34 | SMouseState MouseState; 35 | 36 | // We use this array to store the current state of each key 37 | bool keyState[KEY_KEY_CODES_COUNT]; 38 | bool currKeyState[KEY_KEY_CODES_COUNT]; 39 | bool prevKeyState[KEY_KEY_CODES_COUNT]; 40 | }; 41 | 42 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Graph.h: -------------------------------------------------------------------------------- 1 | #ifndef GRAPH_H 2 | #define GRAPH_H 3 | 4 | #include 5 | 6 | #include "Window.h" 7 | #include "GuiObj.h" 8 | #include "ColorTable.h" 9 | 10 | class Graph: public GuiObj 11 | { 12 | public: 13 | Graph(GuiObj* _parent = nullptr); 14 | Graph(int _xpos, int _ypos, int _width, int _height, GuiObj* _parent = nullptr); 15 | virtual ~Graph(); 16 | 17 | void SetContParam(double* _xVal, double *_yVal, double _maxVals); 18 | void SetStaticParam(std::vector *_xVal, std::vector *_yVal, double _maxVals); 19 | 20 | void SetMouseOverVal(bool _mouseOver); 21 | 22 | void Clear(); 23 | 24 | void setWindow(double _xBeg, double _yBeg, double _xEnd, double _yEnd); 25 | void Resize(int _width, int _height); 26 | 27 | private: 28 | enum AXIS 29 | { 30 | X_AXIS, 31 | Y_AXIS 32 | }; 33 | 34 | virtual void Draw(Window &_win); 35 | virtual void UpdateInternal(Window &_win); 36 | 37 | void UpdateMouseOver(Window &_win); 38 | 39 | double Val2Pos(double _val, AXIS _axis); 40 | 41 | double *xVal, *yVal; 42 | double xBeg, xEnd, yBeg, yEnd; 43 | double maxVals; 44 | bool cont; 45 | bool mouseOver; 46 | 47 | std::pair, std::queue> vals; 48 | ColorTable table; 49 | }; 50 | 51 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/GuiObj.h: -------------------------------------------------------------------------------- 1 | #ifndef GUIOBJ_H 2 | #define GUIOBJ_H 3 | 4 | #include 5 | #include "Window.h" 6 | 7 | class GuiObj 8 | { 9 | // friend class GuiObj; 10 | 11 | public: 12 | enum CLIPPOS 13 | { 14 | NONEPOS = 0, 15 | TOPLEFT = 1, TOPCENTER = 2, TOPRIGHT = 3, 16 | MIDLEFT = 4, MIDCENTER = 5, MIDRIGHT = 6, 17 | BTMLEFT = 7, BTMCENTER = 8, BTMRIGHT = 9, 18 | }; 19 | 20 | enum CLIPDIM 21 | { 22 | BTM = 1, CENTERY = 2, CENTERX = 4, RIGHT = 8, NONEDIM = 16 23 | }; 24 | 25 | void Update(Window& _win); 26 | 27 | void setPos(int _xpos, int _ypos); 28 | void setMargin(int _right, int _btm); 29 | void setParent(GuiObj* _obj); 30 | void setVisible(bool _visible); 31 | void setDepth(int _depth); 32 | 33 | core::vector2di getPos() const; 34 | core::vector2di getMid() const; 35 | core::dimension2di getDim() const; 36 | int getDepth() const; 37 | 38 | 39 | bool isMouseOnObj(Window& _win, bool _only = false); 40 | bool hasParent(); 41 | bool isParent(GuiObj* _obj); 42 | 43 | int getID() const; 44 | void UpdateID(); 45 | 46 | void ClipPosTo(CLIPPOS _area); // \TODO: Allow cliping to any object 47 | void addClipDimTo(CLIPDIM _dir); 48 | 49 | protected: 50 | GuiObj(int _xpos, int _ypos, int _width, int _height, GuiObj* _parent = nullptr); 51 | virtual ~GuiObj(); 52 | 53 | int xpos, ypos; 54 | int absXpos, absYpos; 55 | int width, height; 56 | int marginRight, marginBtm; 57 | 58 | GuiObj* parent; 59 | //std::vector children; 60 | 61 | int id; 62 | int depth; 63 | 64 | CLIPPOS clipPos; 65 | int clipDim; 66 | bool visible; 67 | std::string guiType; 68 | 69 | private: 70 | virtual void UpdateInternal(Window& _win) = 0; 71 | virtual void Draw(Window& _win) = 0; 72 | 73 | virtual void UpdateAbsPos(Window& _win); 74 | virtual void UpdateAbsDim(Window& _win); 75 | }; 76 | 77 | 78 | void UpdateGuiObjs(Window& _win); 79 | void SortGuiObjs(); 80 | void SetRelativeGuiLayer(GuiObj* _top, GuiObj* _btm); 81 | int FindGuiObj(GuiObj* _guiObj); 82 | 83 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Scrollbar.h: -------------------------------------------------------------------------------- 1 | #ifndef SCROLLBAR_H 2 | #define SCROLLBAR_H 3 | 4 | #include "Window.h" 5 | #include "Button.h" 6 | #include "GuiObj.h" 7 | 8 | class Scrollbar: public GuiObj 9 | { 10 | public: 11 | static const int WIDTH = 12; 12 | enum ORIENTATION 13 | { 14 | VERTICAL = 0, 15 | HORIZANTAL = 1 16 | }; 17 | 18 | Scrollbar(int _xpos, int _ypos, ORIENTATION _scrollBarOrientation, int _pxLength, int _pxAreaLength, GuiObj* _parent = nullptr); 19 | virtual ~Scrollbar(); 20 | 21 | void setPxLength(int _length); 22 | void setPxAreaLength(int _length); 23 | 24 | double getScrollerPercent(); 25 | 26 | private: 27 | int pxLength, pxAreaLength; 28 | 29 | double scrollPos; 30 | ORIENTATION scrollBarOrientation; 31 | 32 | Button* btnUp; 33 | Button* btnDown; 34 | Button* scroller; 35 | 36 | virtual void Draw(Window &_win); 37 | virtual void UpdateInternal(Window &_win); 38 | 39 | void UpdateScrollerPos(Window &_win); 40 | void UpdateScrollerLength(); 41 | 42 | int getScrollerLength(); 43 | double getScrollerRatio(); 44 | }; 45 | 46 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Slider.h: -------------------------------------------------------------------------------- 1 | #ifndef SLIDER_H 2 | #define SLIDER_H 3 | 4 | #include "Window.h" 5 | #include "GuiObj.h" 6 | #include 7 | 8 | using namespace std; 9 | 10 | class Slider: public GuiObj 11 | { 12 | public: 13 | enum AUTO_DIR 14 | { 15 | FORWARD = 0, 16 | BACKWARD = 1 17 | }; 18 | 19 | enum AUTO_MODE 20 | { 21 | LOOP = 0, 22 | REVERSE = 1 23 | }; 24 | 25 | Slider(int _x, int _y, double _width, double _val = 0.0); 26 | 27 | void setRange(double _min, double _max); 28 | 29 | void setVal(double _val); 30 | 31 | void setWidth(double _width); 32 | 33 | void setAuto(bool _auto, AUTO_MODE _autoMode); 34 | 35 | double getVal(); 36 | 37 | private: 38 | double max, min, val; 39 | bool automate; 40 | 41 | AUTO_DIR autoDir; 42 | AUTO_MODE autoMode; 43 | 44 | const SColor SLIDER_COLOR = SColor(255, 255, 255, 255); 45 | const int SLIDER_POINT_RADIUS = 5; 46 | 47 | enum State 48 | { 49 | IDLE = 0, 50 | HOLD = 1 51 | }state; 52 | 53 | double Pos2percent(int _pos); 54 | 55 | double Pos2val(int _pos); 56 | 57 | int Percent2pos(double _percent); 58 | 59 | int Val2pos(double _val); 60 | 61 | void UpdateAuto(); 62 | 63 | void IdleLogic(Window &_win); 64 | 65 | void HoldLogic(Window &_win); 66 | 67 | virtual void Draw(Window &_win); 68 | virtual void UpdateInternal(Window &_win); 69 | }; 70 | 71 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Window.cpp: -------------------------------------------------------------------------------- 1 | #include "Window.h" 2 | #include 3 | 4 | Window::Window(int _width , int _height) 5 | { 6 | initOsWindow(); 7 | 8 | device = createDevice(video::EDT_SOFTWARE, dimension2d(_width, _height), 16, false, false, false, &reciever); 9 | if (!device) 10 | { 11 | // \TODO: Print cause of error 12 | exit(1); 13 | } 14 | 15 | driver = device->getVideoDriver(); 16 | if (!driver) 17 | { 18 | // \TODO: Print cause of error 19 | device->drop(); 20 | 21 | exit(1); 22 | } 23 | 24 | if (!driver->queryFeature(video::EVDF_RENDER_TO_TARGET)) 25 | { 26 | // \TODO: Print cause of error 27 | device->drop(); 28 | 29 | exit(1); 30 | } 31 | 32 | guienv = device->getGUIEnvironment(); 33 | if (!guienv) 34 | { 35 | // \TODO: Print cause of error 36 | device->drop(); 37 | 38 | exit(1); 39 | } 40 | 41 | font = device->getGUIEnvironment()->getBuiltInFont(); 42 | if (!font) 43 | { 44 | // \TODO: Print cause of error 45 | device->drop(); 46 | 47 | exit(1); 48 | } 49 | 50 | currMs = 0; 51 | prevMs = 0; 52 | } 53 | 54 | dimension2di Window::getDimentions() 55 | { 56 | return dimension2di(driver->getScreenSize()); 57 | } 58 | 59 | void Window::updateFPS() 60 | { 61 | prevMs = currMs; 62 | currMs = std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(); 63 | } 64 | 65 | double Window::getFPS() const 66 | { 67 | return 1000.0/ (double)(currMs - prevMs); 68 | } 69 | 70 | 71 | // ----------- [PRIVATE] ------------ 72 | void Window::initOsWindow() 73 | { 74 | #ifdef _WIN32 75 | initWindow(); 76 | #endif 77 | 78 | #ifdef LINUX 79 | initLinux(); 80 | #endif 81 | 82 | #ifdef _MAC 83 | initMac(); 84 | #endif 85 | } 86 | 87 | void Window::initWindow() 88 | { 89 | 90 | } 91 | 92 | void Window::initLinux() 93 | { 94 | 95 | } 96 | 97 | void Window::initMac() 98 | { 99 | 100 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/Window.h: -------------------------------------------------------------------------------- 1 | #ifndef WINDOW_H 2 | #define WINDOW_H 3 | 4 | #include "../irrlicht/include/irrlicht.h" 5 | #include "Event.h" 6 | 7 | using namespace irr; 8 | using namespace core; 9 | using namespace video; 10 | using namespace gui; 11 | 12 | // \TODO: Figure out why this is not working. Getting this to work 13 | // will allow to have a global ever reciever for all windows 14 | //static EventReceiver reciever; 15 | 16 | // \TODO: Figure out how to change window position while using the 17 | // software renderer. This will allow to have a better workspace/view 18 | 19 | class Window 20 | { 21 | public: 22 | IrrlichtDevice *device; 23 | IVideoDriver* driver; 24 | IGUIEnvironment* guienv; 25 | IGUIFont* font; 26 | EventReceiver reciever; 27 | 28 | Window(int _width = 640, int _height = 480); 29 | dimension2di getDimentions(); 30 | 31 | void updateFPS(); 32 | double getFPS() const; 33 | 34 | private: 35 | long prevMs, currMs; 36 | 37 | void initOsWindow(); 38 | 39 | void initWindow(); 40 | void initLinux(); 41 | void initMac(); 42 | }; 43 | 44 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/drawUtils.cpp: -------------------------------------------------------------------------------- 1 | #include "drawUtils.h" 2 | #include "../utils/Geometry.h" 3 | #include "../utils/mathUtils.h" 4 | #include "../osu!/Filestructure/SliderHitobject.h" 5 | 6 | void DrawLine(Window &_win, Hitobject& _hc1, Hitobject& _hc2) 7 | { 8 | _win.driver->draw2DLine(vector2di(_hc1.getPos().X, _hc1.getPos().Y), vector2di(_hc2.getPos().X, _hc2.getPos().Y), SColor(255, 255, 0, 0)); 9 | 10 | position2d midpoint = getMidpoint(_hc1.getPos(), _hc2.getPos()); 11 | 12 | _win.font->draw(core::stringw(getDist(_hc1.getPos(), _hc2.getPos())), 13 | core::rect(midpoint.X, midpoint.Y, 100, 10), 14 | video::SColor(255, 255, 255, 255)); 15 | 16 | // \TODO draw dist or velocity label 17 | } 18 | 19 | void DrawArc(Window &_win, int _xpos, int _ypos, double _radius, SColor _color, double _startAngle, double _radAngle) 20 | { 21 | // step is such that the circle is drawn with minimal 22 | // amount of iterations while not showing any gaps 23 | if (_radius < 0) _radius = 0; 24 | for (double i = _startAngle; i < _startAngle + _radAngle; i += PX_PER_RAD(_radius)) 25 | _win.driver->drawPixel(_xpos + cos(i)*_radius, _ypos + sin(i)*_radius, _color); 26 | } 27 | 28 | void DrawAngle(Window &_win, Hitobject& _hc1, Hitobject& _hc2, Hitobject& _hc3) 29 | { 30 | const int RADIUS = 10; 31 | double thetaRot; 32 | double angle = getAngle(_hc1.getPos(), _hc2.getPos(), _hc3.getPos()); 33 | 34 | vector2d pos1 = _hc1.getSlider()->GetSliderPos(_hc1.getEndTime()); 35 | vector2d pos2 = _hc2.getSlider()->GetSliderPos(_hc2.getEndTime()); 36 | 37 | _win.driver->draw2DLine(vector2di(pos1.X, pos1.Y), vector2di(_hc2.getPos().X, _hc2.getPos().Y), SColor(255, 255, 0, 0)); 38 | _win.driver->draw2DLine(vector2di(pos2.X, pos2.Y), vector2di(_hc3.getPos().X, _hc3.getPos().Y), SColor(255, 255, 0, 0)); 39 | 40 | _win.font->draw(core::stringw(rad2deg(angle)), 41 | core::rect(_hc2.getPos().X + 10, _hc2.getPos().Y + 10, 100, 10), 42 | video::SColor(255, 255, 255, 255)); 43 | 44 | if (getRotDir(_hc1.getPos(), _hc2.getPos(), _hc3.getPos()) == DIR::CW) 45 | thetaRot = getAbsoluteAngle(_hc2.getPos(), _hc3.getPos()); 46 | else 47 | thetaRot = getAbsoluteAngle(_hc2.getPos(), _hc1.getPos()); 48 | 49 | DrawArc(_win, _hc2.getPos().X, _hc2.getPos().Y, RADIUS, SColor(255, 255, 0, 0), thetaRot, angle); 50 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/drawUtils.h: -------------------------------------------------------------------------------- 1 | #ifndef DEBUGRENDER_H 2 | #define DEBUGRENDER_H 3 | #define _USE_MATH_DEFINES 4 | 5 | #include 6 | #include 7 | 8 | #include "Window.h" 9 | #include "../osu!/Filestructure/Hitobject.h" 10 | 11 | void DrawLine(Window &_win, Hitobject& _hc1, Hitobject& _hc2); 12 | void DrawArc(Window &_win, int _xpos, int _ypos, double _radius, SColor _color = SColor(255, 255, 255, 255), double _startAngle = 0.0, double _radAngle = 2 * M_PI); 13 | void DrawAngle(Window &_win, Hitobject& _hc1, Hitobject& _hc2, Hitobject& _hc3); 14 | 15 | 16 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/pane.cpp: -------------------------------------------------------------------------------- 1 | #include "Pane.h" 2 | 3 | Pane::Pane(int _xpos, int _ypos, int _width, int _height, int _virtWidth, int _virtHeight, GuiObj* _parent) : GuiObj(_xpos, _ypos, _width, _height, _parent) 4 | { 5 | virtWidth = _virtWidth; 6 | virtHeight = _virtHeight; 7 | 8 | verScrollbar = new Scrollbar(0, 0, Scrollbar::VERTICAL, _height, _virtHeight, this); 9 | verScrollbar->ClipPosTo(TOPRIGHT); 10 | verScrollbar->addClipDimTo(BTM); 11 | verScrollbar->setMargin(0, 12); 12 | 13 | horScrollbar = new Scrollbar(0, 0, Scrollbar::HORIZANTAL, _width, _virtWidth, this); 14 | horScrollbar->ClipPosTo(BTMLEFT); 15 | horScrollbar->addClipDimTo(BTM); 16 | horScrollbar->addClipDimTo(RIGHT); 17 | horScrollbar->setMargin(12, 0); 18 | 19 | SetRelativeGuiLayer(verScrollbar, this); 20 | 21 | guiType = "Pane"; 22 | } 23 | 24 | Pane::~Pane() 25 | { 26 | delete verScrollbar; 27 | delete horScrollbar; 28 | } 29 | 30 | void Pane::addObj(GuiObj* _obj) 31 | { 32 | _obj->setParent(this); 33 | objs.push_back(_obj); 34 | } 35 | 36 | void Pane::setSize(int _width, int _height) 37 | { 38 | width = _width; 39 | height = _height; 40 | } 41 | 42 | void Pane::setVirtSize(int _width, int _height) 43 | { 44 | virtWidth = _width; 45 | virtHeight = _height; 46 | } 47 | 48 | 49 | // -------- Private ---------- 50 | 51 | 52 | void Pane::Draw(Window& _win) 53 | { 54 | _win.driver->draw2DRectangle(video::SColor(255, 100, 100, 200), 55 | core::rect(absXpos, absYpos, absXpos + width, absYpos + height)); 56 | } 57 | 58 | void Pane::UpdateInternal(Window& _win) 59 | { 60 | if (virtHeight > height) verScrollbar->setVisible(true); 61 | else verScrollbar->setVisible(false); 62 | 63 | if (virtWidth > width) horScrollbar->setVisible(true); 64 | else horScrollbar->setVisible(false); 65 | 66 | for (int i = 0; i < objs.size(); i++) 67 | { 68 | if (objs[i] != nullptr) 69 | objs[i]->Update(_win); 70 | } 71 | 72 | verScrollbar->Update(_win); 73 | horScrollbar->Update(_win); 74 | } -------------------------------------------------------------------------------- /osu-Replay-Analyzer/ui/pane.h: -------------------------------------------------------------------------------- 1 | #ifndef PANE_H 2 | #define PANE_H 3 | 4 | #include 5 | 6 | #include "Window.h" 7 | #include "GuiObj.h" 8 | #include "Scrollbar.h" 9 | 10 | class Pane: public GuiObj 11 | { 12 | public: 13 | Pane(int _xpos, int _ypos, int _width, int _height, int _virtWidth, int _virtHight, GuiObj* _parent = nullptr); 14 | virtual ~Pane(); 15 | 16 | void addObj(GuiObj* _obj); 17 | 18 | void setSize(int _width, int _height); 19 | void setVirtSize(int _width, int _height); 20 | 21 | private: 22 | Scrollbar *verScrollbar, *horScrollbar; 23 | int virtWidth, virtHeight; 24 | 25 | std::vector objs; 26 | 27 | virtual void Draw(Window& _win); 28 | virtual void UpdateInternal(Window& _win); 29 | }; 30 | 31 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/Geometry.h: -------------------------------------------------------------------------------- 1 | #ifndef GEOMETRY_H 2 | #define GEOMETRY_H 3 | 4 | #include 5 | #include "../irrlicht/include/irrlicht.h" 6 | #include "../osu!/Filestructure/Play.h" 7 | 8 | using namespace irr; 9 | using namespace core; 10 | 11 | double getSlope(position2d _p1, position2d _p2); 12 | double getDist(position2d _p1, position2d _p2); 13 | 14 | bool isPointOnLine(position2d _point, std::pair, position2d> _line); 15 | bool HasIntersectionPoint(std::pair, position2d> _line1, std::pair, position2d> _line2); 16 | 17 | double Deg2px(double _deg, double _res, double _fov); 18 | double px2Deg(double _px, double _res, double _fov); 19 | 20 | double getVelocity(position2d _p1, position2d _p2, double _t1, double _t2); 21 | 22 | enum DIR 23 | { 24 | CCW = 0, 25 | CW = 1 26 | }; 27 | 28 | // Gets the directional angle in rads (-pi -> pi) 29 | double getDirAngle(position2d a, position2d b, position2d c); 30 | 31 | // Gets the normal angle in rads (0 -> pi) 32 | double getAngle(position2d _p1, position2d _ref, position2d _p3); 33 | 34 | // Gets the angular direction of a vector 35 | double getAbsoluteAngle(position2d _p1, position2d _p2); 36 | 37 | // Get the rotational direction 38 | DIR getRotDir(position2d _p1, position2d _ref, position2d _p3); 39 | 40 | position2d getMidpoint(position2d _p1, position2d _p2); 41 | double getNormal(position2d _p1, position2d _p2); 42 | 43 | double addAngle(double _rad1, double rad2); 44 | 45 | double rad2deg(double _rad); 46 | double deg2rad(double _deg); 47 | 48 | double getCircleArea(double _radius); 49 | double getCircleOverlapArea(double _radius, double _dist); 50 | double GetHitobjectOverlapArea(Play *_play, int _indexA, int _indexB); 51 | 52 | #endif 53 | 54 | -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/Lambert.h: -------------------------------------------------------------------------------- 1 | /* 2 | Implementation of Lambert W function 3 | Copyright (C) 2009 Darko Veberic, darko.veberic@ung.si 4 | This program is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 3 of the License, or 7 | (at your option) any later version. 8 | This program is distributed in the hope that it will be useful, 9 | but WITHOUT ANY WARRANTY; without even the implied warranty of 10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 | GNU General Public License for more details. 12 | You should have received a copy of the GNU General Public License 13 | along with this program. If not, see . 14 | 25 Jun 2009 15 | */ 16 | 17 | #ifndef _utl_LambertW_h_ 18 | #define _utl_LambertW_h_ 19 | 20 | /** Approximate Lambert W function 21 | Accuracy at least 5 decimal places in all definition range. 22 | See LambertW() for details. 23 | \param branch: valid values are 0 and -1 24 | \param x: real-valued argument \f$\geq-1/e\f$ 25 | \ingroup math 26 | */ 27 | template double LambertWApproximation(const double x); 28 | 29 | /** Lambert W function 30 | Lambert function \f$y={\rm W}(x)\f$ is defined as a solution 31 | to the \f$x=ye^y\f$ expression and is also known as 32 | "product logarithm". Since the inverse of \f$ye^y\f$ is not 33 | single-valued, the Lambert function has two real branches 34 | \f${\rm W}_0\f$ and \f${\rm W}_{-1}\f$. 35 | \f${\rm W}_0(x)\f$ has real values in the interval 36 | \f$[-1/e,\infty]\f$ and \f${\rm W}_{-1}(x)\f$ has real values 37 | in the interval \f$[-1/e,0]\f$. 38 | Accuracy is the nominal double type resolution 39 | (16 decimal places). 40 | \param branch: valid values are 0 and -1 41 | \param x: real-valued argument \f$\geq-1/e\f$ (range depends on 42 | branch) 43 | */ 44 | template double LambertW(const double x); 45 | 46 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/LambertW.h: -------------------------------------------------------------------------------- 1 | /* 2 | Implementation of the Lambert W function 3 | 4 | Copyright (C) 2011 Darko Veberic, darko.veberic@ijs.si 5 | 6 | This program is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | This program is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with this program. If not, see . 18 | */ 19 | 20 | #ifndef _utl_LambertW_h_ 21 | #define _utl_LambertW_h_ 22 | 23 | #include 24 | 25 | 26 | namespace utl 27 | { 28 | template double LambertW(const double x); 29 | 30 | 31 | inline double LambertW(const int branch, const double x) 32 | { 33 | switch (branch) 34 | { 35 | case -1: return LambertW<-1>(x); 36 | case 0: return LambertW<0>(x); 37 | default: return std::numeric_limits::quiet_NaN(); 38 | } 39 | } 40 | 41 | } 42 | 43 | 44 | #endif -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/MD5/hl_exception.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/utils/MD5/hl_exception.h -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/MD5/hl_hashwrapper.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/utils/MD5/hl_hashwrapper.h -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/MD5/hl_md5.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/utils/MD5/hl_md5.cpp -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/MD5/hl_md5.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/utils/MD5/hl_md5.h -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/MD5/hl_md5wrapper.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/utils/MD5/hl_md5wrapper.cpp -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/MD5/hl_md5wrapper.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/utils/MD5/hl_md5wrapper.h -------------------------------------------------------------------------------- /osu-Replay-Analyzer/utils/MD5/hl_types.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/abraker95/osu-Replay-Analyzer/bc6df97efd2109a80717f6f5785ab29855e14aaa/osu-Replay-Analyzer/utils/MD5/hl_types.h --------------------------------------------------------------------------------