├── .gitignore ├── BuildScripts ├── README.txt ├── build-linux.sh ├── mock-config.txt ├── mock-prep.sh ├── mock-shell.sh ├── mock-sync.sh └── mock-sync.txt ├── CMakeLists.txt ├── Game └── src │ ├── game │ ├── CMakeLists.txt │ ├── Game-Info.plist │ ├── Lux.icns │ ├── Lux.ico │ ├── Lux.rc │ ├── Lux.sln │ ├── Lux.sln.old │ ├── Lux.vcproj │ ├── Lux.vcxproj │ ├── Lux.vcxproj.filters │ ├── LuxAchievementHandler.cpp │ ├── LuxAchievementHandler.h │ ├── LuxAnimatedProp.cpp │ ├── LuxAnimatedProp.h │ ├── LuxArea.cpp │ ├── LuxArea.h │ ├── LuxAreaNodes.cpp │ ├── LuxAreaNodes.h │ ├── LuxArea_ColorGrading.cpp │ ├── LuxArea_ColorGrading.h │ ├── LuxArea_Examine.cpp │ ├── LuxArea_Examine.h │ ├── LuxArea_Flashback.cpp │ ├── LuxArea_Flashback.h │ ├── LuxArea_Infection.cpp │ ├── LuxArea_Infection.h │ ├── LuxArea_Ladder.cpp │ ├── LuxArea_Ladder.h │ ├── LuxArea_Liquid.cpp │ ├── LuxArea_Liquid.h │ ├── LuxArea_Rope.cpp │ ├── LuxArea_Rope.h │ ├── LuxArea_Script.cpp │ ├── LuxArea_Script.h │ ├── LuxArea_Sign.cpp │ ├── LuxArea_Sign.h │ ├── LuxArea_SlimeDamage.cpp │ ├── LuxArea_SlimeDamage.h │ ├── LuxArea_Sticky.cpp │ ├── LuxArea_Sticky.h │ ├── LuxBase.cpp │ ├── LuxBase.h │ ├── LuxBasePersonal.h │ ├── LuxCommentaryIcon.cpp │ ├── LuxCommentaryIcon.h │ ├── LuxCompletionCountHandler.cpp │ ├── LuxCompletionCountHandler.h │ ├── LuxConfigHandler.cpp │ ├── LuxConfigHandler.h │ ├── LuxCredits.cpp │ ├── LuxCredits.h │ ├── LuxCritter_Bug.cpp │ ├── LuxCritter_Bug.h │ ├── LuxCritter_Spider.cpp │ ├── LuxCritter_Spider.h │ ├── LuxDebugHandler.cpp │ ├── LuxDebugHandler.h │ ├── LuxDemoEnd.cpp │ ├── LuxDemoEnd.h │ ├── LuxEffectHandler.cpp │ ├── LuxEffectHandler.h │ ├── LuxEffectRenderer.cpp │ ├── LuxEffectRenderer.h │ ├── LuxEnemy.cpp │ ├── LuxEnemy.h │ ├── LuxEnemyMover.cpp │ ├── LuxEnemyMover.h │ ├── LuxEnemyPathfinder.cpp │ ├── LuxEnemyPathfinder.h │ ├── LuxEnemy_Child.cpp │ ├── LuxEnemy_Child.h │ ├── LuxEnemy_Grunt.cpp │ ├── LuxEnemy_Grunt.h │ ├── LuxEnemy_ManPig.cpp │ ├── LuxEnemy_ManPig.h │ ├── LuxEnemy_WaterLurker.cpp │ ├── LuxEnemy_WaterLurker.h │ ├── LuxEntity.cpp │ ├── LuxEntity.h │ ├── LuxGlobalDataHandler.cpp │ ├── LuxGlobalDataHandler.h │ ├── LuxHandObject.cpp │ ├── LuxHandObject.h │ ├── LuxHandObject_LightSource.cpp │ ├── LuxHandObject_LightSource.h │ ├── LuxHandObject_Melee.cpp │ ├── LuxHandObject_Melee.h │ ├── LuxHelpFuncs.cpp │ ├── LuxHelpFuncs.h │ ├── LuxHintHandler.cpp │ ├── LuxHintHandler.h │ ├── LuxIdleBehavior_ManPig.h │ ├── LuxInfectionHandler.cpp │ ├── LuxInfectionHandler.h │ ├── LuxInputHandler.cpp │ ├── LuxInputHandler.h │ ├── LuxInsanityHandler.cpp │ ├── LuxInsanityHandler.h │ ├── LuxInteractConnections.cpp │ ├── LuxInteractConnections.h │ ├── LuxInventory.cpp │ ├── LuxInventory.h │ ├── LuxItemType.cpp │ ├── LuxItemType.h │ ├── LuxJournal.cpp │ ├── LuxJournal.h │ ├── LuxKeyEntry.fl │ ├── LuxLoadScreenHandler.cpp │ ├── LuxLoadScreenHandler.h │ ├── LuxMainMenu.cpp │ ├── LuxMainMenu.h │ ├── LuxMainMenu_CustomStory.cpp │ ├── LuxMainMenu_CustomStory.h │ ├── LuxMainMenu_KeyConfig.cpp │ ├── LuxMainMenu_KeyConfig.h │ ├── LuxMainMenu_LoadGame.cpp │ ├── LuxMainMenu_LoadGame.h │ ├── LuxMainMenu_Options.cpp │ ├── LuxMainMenu_Options.h │ ├── LuxMainMenu_Profile.cpp │ ├── LuxMainMenu_Profile.h │ ├── LuxMap.cpp │ ├── LuxMap.h │ ├── LuxMapHandler.cpp │ ├── LuxMapHandler.h │ ├── LuxMapHelper.cpp │ ├── LuxMapHelper.h │ ├── LuxMessageHandler.cpp │ ├── LuxMessageHandler.h │ ├── LuxMoveState.cpp │ ├── LuxMoveState.h │ ├── LuxMoveState_ClimbLedge.cpp │ ├── LuxMoveState_ClimbLedge.h │ ├── LuxMoveState_Normal.cpp │ ├── LuxMoveState_Normal.h │ ├── LuxMusicHandler.cpp │ ├── LuxMusicHandler.h │ ├── LuxPlayer.cpp │ ├── LuxPlayer.h │ ├── LuxPlayerHands.cpp │ ├── LuxPlayerHands.h │ ├── LuxPlayerHelpers.cpp │ ├── LuxPlayerHelpers.h │ ├── LuxPlayerState.cpp │ ├── LuxPlayerState.h │ ├── LuxPlayerState_DefaultBase.cpp │ ├── LuxPlayerState_DefaultBase.h │ ├── LuxPlayerState_HandObject.cpp │ ├── LuxPlayerState_HandObject.h │ ├── LuxPlayerState_Interact.cpp │ ├── LuxPlayerState_Interact.h │ ├── LuxPlayerState_InteractGrab.cpp │ ├── LuxPlayerState_InteractGrab.h │ ├── LuxPlayerState_InteractLever.cpp │ ├── LuxPlayerState_InteractLever.h │ ├── LuxPlayerState_InteractPush.cpp │ ├── LuxPlayerState_InteractPush.h │ ├── LuxPlayerState_InteractRotateBase.cpp │ ├── LuxPlayerState_InteractRotateBase.h │ ├── LuxPlayerState_InteractSlide.cpp │ ├── LuxPlayerState_InteractSlide.h │ ├── LuxPlayerState_InteractSwingDoor.cpp │ ├── LuxPlayerState_InteractSwingDoor.h │ ├── LuxPlayerState_InteractWheel.cpp │ ├── LuxPlayerState_InteractWheel.h │ ├── LuxPlayerState_Ladder.cpp │ ├── LuxPlayerState_Ladder.h │ ├── LuxPlayerState_Normal.cpp │ ├── LuxPlayerState_Normal.h │ ├── LuxPlayerState_UseItem.cpp │ ├── LuxPlayerState_UseItem.h │ ├── LuxPostEffects.cpp │ ├── LuxPostEffects.h │ ├── LuxPreMenu.cpp │ ├── LuxPreMenu.h │ ├── LuxProgressLogHandler.cpp │ ├── LuxProgressLogHandler.h │ ├── LuxProp.cpp │ ├── LuxProp.h │ ├── LuxProp_Button.cpp │ ├── LuxProp_Button.h │ ├── LuxProp_Chest.cpp │ ├── LuxProp_Chest.h │ ├── LuxProp_CritterBase.cpp │ ├── LuxProp_CritterBase.h │ ├── LuxProp_EmotionStone.cpp │ ├── LuxProp_EmotionStone.h │ ├── LuxProp_Item.cpp │ ├── LuxProp_Item.h │ ├── LuxProp_Lamp.cpp │ ├── LuxProp_Lamp.h │ ├── LuxProp_LevelDoor.cpp │ ├── LuxProp_LevelDoor.h │ ├── LuxProp_Lever.cpp │ ├── LuxProp_Lever.h │ ├── LuxProp_MoveObject.cpp │ ├── LuxProp_MoveObject.h │ ├── LuxProp_MultiSlider.cpp │ ├── LuxProp_MultiSlider.h │ ├── LuxProp_NPC.cpp │ ├── LuxProp_NPC.h │ ├── LuxProp_Object.cpp │ ├── LuxProp_Object.h │ ├── LuxProp_OilBarrel.cpp │ ├── LuxProp_OilBarrel.h │ ├── LuxProp_PhoneBox.cpp │ ├── LuxProp_PhoneBox.h │ ├── LuxProp_Photocell.cpp │ ├── LuxProp_Photocell.h │ ├── LuxProp_SwingDoor.cpp │ ├── LuxProp_SwingDoor.h │ ├── LuxProp_VoiceFlashbackTrigger.cpp │ ├── LuxProp_VoiceFlashbackTrigger.h │ ├── LuxProp_Wheel.cpp │ ├── LuxProp_Wheel.h │ ├── LuxSaveHandler.cpp │ ├── LuxSaveHandler.h │ ├── LuxSavedEngineTypes.cpp │ ├── LuxSavedEngineTypes.h │ ├── LuxSavedGame.cpp │ ├── LuxSavedGame.h │ ├── LuxSavedGameTypes.cpp │ ├── LuxSavedGameTypes.h │ ├── LuxSavedMap.cpp │ ├── LuxSavedMap.h │ ├── LuxScriptHandler.cpp │ ├── LuxScriptHandler.h │ ├── LuxStaticProp.cpp │ ├── LuxStaticProp.h │ ├── LuxTypes.cpp │ ├── LuxTypes.h │ ├── Main.cpp │ ├── PostEffect_Cells.cpp │ ├── PostEffect_Cells.h │ ├── StdAfx.cpp │ ├── StdAfx.h │ ├── _old │ │ ├── LuxEnemy.cpp │ │ ├── LuxEnemy.h │ │ ├── LuxEnemyMover.cpp │ │ ├── LuxEnemyMover.h │ │ ├── LuxEnemyPathfinder.cpp │ │ ├── LuxEnemyPathfinder.h │ │ ├── LuxEnemy_ManPig.cpp │ │ ├── LuxEnemy_ManPig.h │ │ ├── LuxEnemy_Tesla.cpp │ │ └── LuxEnemy_Tesla.h │ ├── aamfp.icns │ ├── aamfp.ico │ └── resource.h │ ├── lang_conv │ ├── LangConv.cpp │ ├── LangConv.h │ ├── LangConv.sln │ └── LangConv.vcproj │ ├── launcher-macosx │ ├── CMakeLists.txt │ ├── EditorSuite.plist │ ├── HPLMinimal.h │ ├── HPLMinimal.mm │ ├── Launcher-Info.plist │ ├── LauncherAppDelegate.h │ ├── LauncherAppDelegate.mm │ ├── MainWindow.xib │ ├── Startup.plist │ ├── TabBackground.h │ ├── TabBackground.m │ ├── launcher_bg.jpg │ └── main.m │ └── launcher │ ├── CMakeLists.txt │ ├── Launcher.rc │ ├── Launcher.sln │ ├── Launcher.vcproj │ ├── LauncherCz.vcproj │ ├── LauncherHelper.cpp │ ├── LauncherHelper.h │ ├── LauncherRus.vcproj │ ├── Lux.ico │ ├── Main.cpp │ ├── Main.h │ ├── QualityChooser.cpp │ ├── QualityChooser.h │ ├── background.jpg │ ├── glut.h │ ├── glut32.lib │ ├── launcher.cpp │ ├── launcher.fl │ ├── launcher.h │ ├── launcherCz.cpp │ ├── launcherCz.fl │ ├── launcherCz.h │ ├── launcherRus.cpp │ ├── launcherRus.fl │ ├── launcherRus.h │ └── resource.h ├── HPL2 ├── core │ ├── CMakeLists.txt │ ├── HPL2_0.sln │ ├── HPL2_0.vcproj │ ├── SDLMain.h │ ├── SDLMain.m │ ├── _HPL2_2010.sln │ ├── _HPL2_2010.vcproj │ ├── _HPL2_2010.vcxproj │ ├── _HPL2_2010.vcxproj.filters │ ├── buildcounter.pl │ ├── buildcounterinput.txt │ ├── include │ │ ├── BuildID_HPL2_0.h │ │ ├── ai │ │ │ ├── AI.h │ │ │ ├── AINodeContainer.h │ │ │ ├── AINodeGenerator.h │ │ │ ├── AStar.h │ │ │ └── StateMachine.h │ │ ├── engine │ │ │ ├── Engine.h │ │ │ ├── EngineInitVars.h │ │ │ ├── EngineTypes.h │ │ │ ├── LowLevelEngineSetup.h │ │ │ ├── SaveGame.h │ │ │ ├── ScriptFuncs.h │ │ │ ├── Updateable.h │ │ │ └── Updater.h │ │ ├── generate │ │ │ ├── Generate.h │ │ │ ├── GenerateTypes.h │ │ │ └── VoxelMap.h │ │ ├── graphics │ │ │ ├── Animation.h │ │ │ ├── AnimationTrack.h │ │ │ ├── Bitmap.h │ │ │ ├── Bone.h │ │ │ ├── BoneState.h │ │ │ ├── Color.h │ │ │ ├── DecalCreator.h │ │ │ ├── FontData.h │ │ │ ├── FrameBase.h │ │ │ ├── FrameBitmap.h │ │ │ ├── FrameBuffer.h │ │ │ ├── FrameSubImage.h │ │ │ ├── FrameTexture.h │ │ │ ├── GPUProgram.h │ │ │ ├── GPUShader.h │ │ │ ├── Graphics.h │ │ │ ├── GraphicsTypes.h │ │ │ ├── LowLevelGraphics.h │ │ │ ├── Material.h │ │ │ ├── MaterialType.h │ │ │ ├── MaterialType_BasicSolid.h │ │ │ ├── MaterialType_BasicTranslucent.h │ │ │ ├── MaterialType_Decal.h │ │ │ ├── MaterialType_Water.h │ │ │ ├── Mesh.h │ │ │ ├── MeshCreator.h │ │ │ ├── OcclusionQuery.h │ │ │ ├── PostEffect.h │ │ │ ├── PostEffectComposite.h │ │ │ ├── PostEffect_Bloom.h │ │ │ ├── PostEffect_ColorConvTex.h │ │ │ ├── PostEffect_ColorGrading.h │ │ │ ├── PostEffect_ImageTrail.h │ │ │ ├── PostEffect_RadialBlur.h │ │ │ ├── ProgramComboManager.h │ │ │ ├── RenderFunctions.h │ │ │ ├── RenderList.h │ │ │ ├── Renderable.h │ │ │ ├── Renderer.h │ │ │ ├── RendererDeferred.h │ │ │ ├── RendererSimple.h │ │ │ ├── RendererWireFrame.h │ │ │ ├── Skeleton.h │ │ │ ├── SubMesh.h │ │ │ ├── Texture.h │ │ │ ├── TextureCreator.h │ │ │ ├── VertexBuffer.h │ │ │ └── VideoStream.h │ │ ├── gui │ │ │ ├── Gui.h │ │ │ ├── GuiGfxElement.h │ │ │ ├── GuiMaterial.h │ │ │ ├── GuiMaterialBasicTypes.h │ │ │ ├── GuiPopUp.h │ │ │ ├── GuiPopUpColorPicker.h │ │ │ ├── GuiPopUpFilePicker.h │ │ │ ├── GuiPopUpMessageBox.h │ │ │ ├── GuiPopUpUIKeyboard.h │ │ │ ├── GuiSet.h │ │ │ ├── GuiSkin.h │ │ │ ├── GuiTypes.h │ │ │ ├── Widget.h │ │ │ ├── WidgetBaseClasses.h │ │ │ ├── WidgetButton.h │ │ │ ├── WidgetCheckBox.h │ │ │ ├── WidgetComboBox.h │ │ │ ├── WidgetContextMenu.h │ │ │ ├── WidgetDummy.h │ │ │ ├── WidgetFrame.h │ │ │ ├── WidgetGroup.h │ │ │ ├── WidgetImage.h │ │ │ ├── WidgetLabel.h │ │ │ ├── WidgetListBox.h │ │ │ ├── WidgetListBoxBase.h │ │ │ ├── WidgetMainMenu.h │ │ │ ├── WidgetMenu.h │ │ │ ├── WidgetMenuItem.h │ │ │ ├── WidgetMultiPropertyListBox.h │ │ │ ├── WidgetSlider.h │ │ │ ├── WidgetTabFrame.h │ │ │ ├── WidgetTextBox.h │ │ │ └── WidgetWindow.h │ │ ├── haptic │ │ │ ├── Haptic.h │ │ │ ├── HapticForce.h │ │ │ ├── HapticShape.h │ │ │ ├── HapticSurface.h │ │ │ ├── HapticTypes.h │ │ │ └── LowLevelHaptic.h │ │ ├── hpl.h │ │ ├── impl │ │ │ ├── BitmapLoaderDevil.h │ │ │ ├── BitmapLoaderDevilDDS.h │ │ │ ├── BitmapLoaderDevilMisc.h │ │ │ ├── CGProgram.h │ │ │ ├── CGShader.h │ │ │ ├── CharacterBodyNewton.h │ │ │ ├── CollideShapeNewton.h │ │ │ ├── FmodSoundChannel.h │ │ │ ├── FmodSoundData.h │ │ │ ├── FrameBufferGL.h │ │ │ ├── GLSLProgram.h │ │ │ ├── GLSLShader.h │ │ │ ├── GamepadSDL.h │ │ │ ├── GamepadSDL2.h │ │ │ ├── GamepadXInput.h │ │ │ ├── KeyboardSDL.h │ │ │ ├── LowLevelGraphicsSDL.h │ │ │ ├── LowLevelInputSDL.h │ │ │ ├── LowLevelPhysicsNewton.h │ │ │ ├── LowLevelResourcesSDL.h │ │ │ ├── LowLevelSoundFmod.h │ │ │ ├── LowLevelSoundOpenAL.h │ │ │ ├── LowLevelSystemSDL.h │ │ │ ├── MeshLoaderCollada.h │ │ │ ├── MeshLoaderFBX.h │ │ │ ├── MeshLoaderMSH.h │ │ │ ├── MouseSDL.h │ │ │ ├── MutexSDL.h │ │ │ ├── MutexWin32.h │ │ │ ├── OcclusionQueryOGL.h │ │ │ ├── OpenALSoundChannel.h │ │ │ ├── OpenALSoundData.h │ │ │ ├── OpenALSoundEnvironment.h │ │ │ ├── PBuffer.h │ │ │ ├── PhysicsBodyNewton.h │ │ │ ├── PhysicsControllerNewton.h │ │ │ ├── PhysicsJointBallNewton.h │ │ │ ├── PhysicsJointHingeNewton.h │ │ │ ├── PhysicsJointNewton.h │ │ │ ├── PhysicsJointScrewNewton.h │ │ │ ├── PhysicsJointSliderNewton.h │ │ │ ├── PhysicsMaterialNewton.h │ │ │ ├── PhysicsRopeNewton.h │ │ │ ├── PhysicsWorldNewton.h │ │ │ ├── SDLEngineSetup.h │ │ │ ├── SDLFontData.h │ │ │ ├── SDLTexture.h │ │ │ ├── SqScript.h │ │ │ ├── TaskKeyHook.h │ │ │ ├── ThreadSDL.h │ │ │ ├── ThreadWin32.h │ │ │ ├── TimerSDL.h │ │ │ ├── VertexBufferOGL_Array.h │ │ │ ├── VertexBufferOGL_VBO.h │ │ │ ├── VertexBufferOpenGL.h │ │ │ ├── VideoStreamTheora.h │ │ │ ├── XmlDocumentTiny.h │ │ │ ├── scriptarray.h │ │ │ ├── scripthelper.h │ │ │ ├── scriptstdstring.h │ │ │ └── tinyXML │ │ │ │ ├── tinystr.h │ │ │ │ └── tinyxml.h │ │ ├── input │ │ │ ├── Action.h │ │ │ ├── ActionGamepadAxis.h │ │ │ ├── ActionGamepadButton.h │ │ │ ├── ActionGamepadHat.h │ │ │ ├── ActionHaptic.h │ │ │ ├── ActionKeyboard.h │ │ │ ├── ActionMouseButton.h │ │ │ ├── Gamepad.h │ │ │ ├── Input.h │ │ │ ├── InputDevice.h │ │ │ ├── InputTypes.h │ │ │ ├── Keyboard.h │ │ │ ├── LowLevelInput.h │ │ │ └── Mouse.h │ │ ├── math │ │ │ ├── BoundingVolume.h │ │ │ ├── CRC.h │ │ │ ├── Frustum.h │ │ │ ├── Math.h │ │ │ ├── MathTypes.h │ │ │ ├── Matrix.h │ │ │ ├── MeshTypes.h │ │ │ ├── PidController.h │ │ │ ├── Quaternion.h │ │ │ ├── Spring.h │ │ │ ├── Vector2.h │ │ │ └── Vector3.h │ │ ├── physics │ │ │ ├── CharacterBody.h │ │ │ ├── CollideData.h │ │ │ ├── CollideShape.h │ │ │ ├── LowLevelPhysics.h │ │ │ ├── Physics.h │ │ │ ├── PhysicsBody.h │ │ │ ├── PhysicsController.h │ │ │ ├── PhysicsJoint.h │ │ │ ├── PhysicsJointBall.h │ │ │ ├── PhysicsJointHinge.h │ │ │ ├── PhysicsJointScrew.h │ │ │ ├── PhysicsJointSlider.h │ │ │ ├── PhysicsMaterial.h │ │ │ ├── PhysicsRope.h │ │ │ ├── PhysicsTypes.h │ │ │ ├── PhysicsWorld.h │ │ │ ├── SurfaceData.h │ │ │ └── VerletParticle.h │ │ ├── resources │ │ │ ├── AnimationManager.h │ │ │ ├── BinaryBuffer.h │ │ │ ├── BitmapLoader.h │ │ │ ├── BitmapLoaderHandler.h │ │ │ ├── ConfigFile.h │ │ │ ├── EngineFileLoading.h │ │ │ ├── EntFileManager.h │ │ │ ├── EntityLoader_Object.h │ │ │ ├── FileSearcher.h │ │ │ ├── FontManager.h │ │ │ ├── GpuShaderManager.h │ │ │ ├── ImageManager.h │ │ │ ├── LanguageFile.h │ │ │ ├── LowLevelResources.h │ │ │ ├── MaterialManager.h │ │ │ ├── MeshLoader.h │ │ │ ├── MeshLoaderHandler.h │ │ │ ├── MeshManager.h │ │ │ ├── ParticleManager.h │ │ │ ├── ResourceBase.h │ │ │ ├── ResourceLoader.h │ │ │ ├── ResourceLoaderHandler.h │ │ │ ├── ResourceManager.h │ │ │ ├── Resources.h │ │ │ ├── ResourcesTypes.h │ │ │ ├── ScriptManager.h │ │ │ ├── SoundEntityManager.h │ │ │ ├── SoundManager.h │ │ │ ├── TextureManager.h │ │ │ ├── VideoLoader.h │ │ │ ├── VideoLoaderHandler.h │ │ │ ├── VideoManager.h │ │ │ ├── WorldLoader.h │ │ │ ├── WorldLoaderHandler.h │ │ │ ├── WorldLoaderHplMap.h │ │ │ └── XmlDocument.h │ │ ├── scene │ │ │ ├── AnimationState.h │ │ │ ├── Beam.h │ │ │ ├── BillBoard.h │ │ │ ├── Camera.h │ │ │ ├── DummyRenderable.h │ │ │ ├── Entity3D.h │ │ │ ├── FogArea.h │ │ │ ├── GuiSetEntity.h │ │ │ ├── Light.h │ │ │ ├── LightBox.h │ │ │ ├── LightPoint.h │ │ │ ├── LightSpot.h │ │ │ ├── MeshEntity.h │ │ │ ├── Node3D.h │ │ │ ├── NodeState.h │ │ │ ├── ParticleEmitter.h │ │ │ ├── ParticleEmitter_UserData.h │ │ │ ├── ParticleSystem.h │ │ │ ├── RenderableContainer.h │ │ │ ├── RenderableContainer_BoxTree.h │ │ │ ├── RenderableContainer_DynBoxTree.h │ │ │ ├── RenderableContainer_List.h │ │ │ ├── RopeEntity.h │ │ │ ├── Scene.h │ │ │ ├── SceneTypes.h │ │ │ ├── SoundEntity.h │ │ │ ├── SubMeshEntity.h │ │ │ ├── Viewport.h │ │ │ └── World.h │ │ ├── sound │ │ │ ├── LowLevelSound.h │ │ │ ├── MusicHandler.h │ │ │ ├── Sound.h │ │ │ ├── SoundChannel.h │ │ │ ├── SoundData.h │ │ │ ├── SoundEntityData.h │ │ │ ├── SoundEnvironment.h │ │ │ ├── SoundHandler.h │ │ │ └── SoundTypes.h │ │ └── system │ │ │ ├── BinTree.h │ │ │ ├── Container.h │ │ │ ├── LogicTimer.h │ │ │ ├── LowLevelSystem.h │ │ │ ├── MemoryManager.h │ │ │ ├── Mutex.h │ │ │ ├── Platform.h │ │ │ ├── PreprocessParser.h │ │ │ ├── SHA1.h │ │ │ ├── Script.h │ │ │ ├── SerializeClass.h │ │ │ ├── String.h │ │ │ ├── System.h │ │ │ ├── SystemTypes.h │ │ │ ├── Thread.h │ │ │ └── Timer.h │ └── sources │ │ ├── BuildID_HPL2_0_Win32.cpp │ │ ├── ai │ │ ├── AI.cpp │ │ ├── AINodeContainer.cpp │ │ ├── AINodeGenerator.cpp │ │ ├── AStar.cpp │ │ └── StateMachine.cpp │ │ ├── engine │ │ ├── Engine.cpp │ │ ├── EngineTypes.cpp │ │ ├── SaveGame.cpp │ │ ├── ScriptFuncs.cpp │ │ └── Updater.cpp │ │ ├── generate │ │ ├── Generate.cpp │ │ ├── GenerateTypes.cpp │ │ └── VoxelMap.cpp │ │ ├── graphics │ │ ├── Animation.cpp │ │ ├── AnimationTrack.cpp │ │ ├── Bitmap.cpp │ │ ├── Bone.cpp │ │ ├── BoneState.cpp │ │ ├── Color.cpp │ │ ├── DecalCreator.cpp │ │ ├── FontData.cpp │ │ ├── FrameBitmap.cpp │ │ ├── FrameSubImage.cpp │ │ ├── FrameTexture.cpp │ │ ├── GPUProgram.cpp │ │ ├── GPUShader.cpp │ │ ├── Graphics.cpp │ │ ├── GraphicsTypes.cpp │ │ ├── LowLevelGraphics.cpp │ │ ├── Material.cpp │ │ ├── MaterialType.cpp │ │ ├── MaterialType_BasicSolid.cpp │ │ ├── MaterialType_BasicTranslucent.cpp │ │ ├── MaterialType_Decal.cpp │ │ ├── MaterialType_Water.cpp │ │ ├── Mesh.cpp │ │ ├── MeshCreator.cpp │ │ ├── PostEffect.cpp │ │ ├── PostEffectComposite.cpp │ │ ├── PostEffect_Bloom.cpp │ │ ├── PostEffect_ColorConvTex.cpp │ │ ├── PostEffect_ColorGrading.cpp │ │ ├── PostEffect_ImageTrail.cpp │ │ ├── PostEffect_RadialBlur.cpp │ │ ├── ProgramComboManager.cpp │ │ ├── RenderFunctions.cpp │ │ ├── RenderList.cpp │ │ ├── Renderable.cpp │ │ ├── Renderer.cpp │ │ ├── RendererDeferred.cpp │ │ ├── RendererSimple.cpp │ │ ├── RendererWireFrame.cpp │ │ ├── Skeleton.cpp │ │ ├── SubMesh.cpp │ │ └── TextureCreator.cpp │ │ ├── gui │ │ ├── Gui.cpp │ │ ├── GuiGfxElement.cpp │ │ ├── GuiMaterialBasicTypes.cpp │ │ ├── GuiPopUp.cpp │ │ ├── GuiPopUpColorPicker.cpp │ │ ├── GuiPopUpFilePicker.cpp │ │ ├── GuiPopUpMessageBox.cpp │ │ ├── GuiPopUpUIKeyboard.cpp │ │ ├── GuiSet.cpp │ │ ├── GuiSkin.cpp │ │ ├── Widget.cpp │ │ ├── WidgetBaseClasses.cpp │ │ ├── WidgetButton.cpp │ │ ├── WidgetCheckBox.cpp │ │ ├── WidgetComboBox.cpp │ │ ├── WidgetContextMenu.cpp │ │ ├── WidgetDummy.cpp │ │ ├── WidgetFrame.cpp │ │ ├── WidgetGroup.cpp │ │ ├── WidgetImage.cpp │ │ ├── WidgetLabel.cpp │ │ ├── WidgetListBox.cpp │ │ ├── WidgetListBoxBase.cpp │ │ ├── WidgetMainMenu.cpp │ │ ├── WidgetMenu.cpp │ │ ├── WidgetMenuItem.cpp │ │ ├── WidgetMultiPropertyListBox.cpp │ │ ├── WidgetSlider.cpp │ │ ├── WidgetTabFrame.cpp │ │ ├── WidgetTextBox.cpp │ │ └── WidgetWindow.cpp │ │ ├── haptic │ │ ├── Haptic.cpp │ │ └── LowLevelHaptic.cpp │ │ ├── impl │ │ ├── BitmapLoaderDevil.cpp │ │ ├── BitmapLoaderDevilDDS.cpp │ │ ├── BitmapLoaderDevilMisc.cpp │ │ ├── CGProgram.cpp │ │ ├── CGShader.cpp │ │ ├── CharacterBodyNewton.cpp │ │ ├── CollideShapeNewton.cpp │ │ ├── FmodSoundChannel.cpp │ │ ├── FmodSoundData.cpp │ │ ├── FrameBufferGL.cpp │ │ ├── GLSLProgram.cpp │ │ ├── GLSLShader.cpp │ │ ├── GamepadSDL.cpp │ │ ├── GamepadSDL2.cpp │ │ ├── GamepadXInput.cpp │ │ ├── KeyboardSDL.cpp │ │ ├── LowLevelGraphicsSDL.cpp │ │ ├── LowLevelInputSDL.cpp │ │ ├── LowLevelPhysicsNewton.cpp │ │ ├── LowLevelResourcesSDL.cpp │ │ ├── LowLevelSoundFmod.cpp │ │ ├── LowLevelSoundOpenAL.cpp │ │ ├── LowLevelSystemSDL.cpp │ │ ├── MeshLoaderCollada.cpp │ │ ├── MeshLoaderColladaHelpers.cpp │ │ ├── MeshLoaderColladaLoader.cpp │ │ ├── MeshLoaderFBX.cpp │ │ ├── MeshLoaderMSH.cpp │ │ ├── MouseSDL.cpp │ │ ├── MutexSDL.cpp │ │ ├── MutexWin32.cpp │ │ ├── OcclusionQueryOGL.cpp │ │ ├── OpenALSoundChannel.cpp │ │ ├── OpenALSoundData.cpp │ │ ├── OpenALSoundEnvironment.cpp │ │ ├── PBuffer.cpp │ │ ├── PhysicsBodyNewton.cpp │ │ ├── PhysicsControllerNewton.cpp │ │ ├── PhysicsJointBallNewton.cpp │ │ ├── PhysicsJointHingeNewton.cpp │ │ ├── PhysicsJointScrewNewton.cpp │ │ ├── PhysicsJointSliderNewton.cpp │ │ ├── PhysicsMaterialNewton.cpp │ │ ├── PhysicsRopeNewton.cpp │ │ ├── PhysicsWorldNewton.cpp │ │ ├── PlatformMacOSX.mm │ │ ├── PlatformSDL.cpp │ │ ├── PlatformUnix.cpp │ │ ├── PlatformWin32.cpp │ │ ├── SDLEngineSetup.cpp │ │ ├── SDLFontData.cpp │ │ ├── SDLFragmentProgram.cpp │ │ ├── SDLTexture.cpp │ │ ├── SDLVertexProgram.cpp │ │ ├── SqScript.cpp │ │ ├── ThreadSDL.cpp │ │ ├── ThreadWin32.cpp │ │ ├── TimerSDL.cpp │ │ ├── VertexBufferOGL_Array.cpp │ │ ├── VertexBufferOGL_VBO.cpp │ │ ├── VertexBufferOpenGL.cpp │ │ ├── VideoStreamTheora.cpp │ │ ├── XmlDocumentTiny.cpp │ │ ├── scriptarray.cpp │ │ ├── scripthelper.cpp │ │ ├── scriptstdstring.cpp │ │ ├── scriptstdstring_utils.cpp │ │ └── tinyXml │ │ │ ├── tinystr.cpp │ │ │ ├── tinyxml.cpp │ │ │ ├── tinyxmlerror.cpp │ │ │ └── tinyxmlparser.cpp │ │ ├── input │ │ ├── Action.cpp │ │ ├── ActionGamepadAxis.cpp │ │ ├── ActionGamepadButton.cpp │ │ ├── ActionGamepadHat.cpp │ │ ├── ActionHaptic.cpp │ │ ├── ActionKeyboard.cpp │ │ ├── ActionMouseButton.cpp │ │ ├── Gamepad.cpp │ │ ├── Input.cpp │ │ ├── InputDevice.cpp │ │ ├── Keyboard.cpp │ │ └── Mouse.cpp │ │ ├── math │ │ ├── BoundingVolume.cpp │ │ ├── CRC.cpp │ │ ├── Frustum.cpp │ │ ├── Math.cpp │ │ ├── MathTypes.cpp │ │ ├── MeshTypes.cpp │ │ ├── Quaternion.cpp │ │ └── Spring.cpp │ │ ├── physics │ │ ├── CharacterBody.cpp │ │ ├── Physics.cpp │ │ ├── PhysicsBody.cpp │ │ ├── PhysicsController.cpp │ │ ├── PhysicsJoint.cpp │ │ ├── PhysicsJointBall.cpp │ │ ├── PhysicsJointHinge.cpp │ │ ├── PhysicsJointScrew.cpp │ │ ├── PhysicsJointSlider.cpp │ │ ├── PhysicsRope.cpp │ │ ├── PhysicsWorld.cpp │ │ ├── SurfaceData.cpp │ │ └── VerletParticle.cpp │ │ ├── resources │ │ ├── AnimationManager.cpp │ │ ├── BinaryBuffer.cpp │ │ ├── BitmapLoaderHandler.cpp │ │ ├── ConfigFile.cpp │ │ ├── EngineFileLoading.cpp │ │ ├── EntFileManager.cpp │ │ ├── EntityLoader_Object.cpp │ │ ├── FileSearcher.cpp │ │ ├── FontManager.cpp │ │ ├── GpuShaderManager.cpp │ │ ├── ImageManager.cpp │ │ ├── LanguageFile.cpp │ │ ├── MaterialManager.cpp │ │ ├── MeshLoaderHandler.cpp │ │ ├── MeshManager.cpp │ │ ├── ParticleManager.cpp │ │ ├── ResourceBase.cpp │ │ ├── ResourceLoader.cpp │ │ ├── ResourceLoaderHandler.cpp │ │ ├── ResourceManager.cpp │ │ ├── Resources.cpp │ │ ├── ScriptManager.cpp │ │ ├── SoundEntityManager.cpp │ │ ├── SoundManager.cpp │ │ ├── TextureManager.cpp │ │ ├── VideoLoaderHandler.cpp │ │ ├── VideoManager.cpp │ │ ├── WorldLoaderHandler.cpp │ │ ├── WorldLoaderHplMap.cpp │ │ └── XmlDocument.cpp │ │ ├── scene │ │ ├── AnimationState.cpp │ │ ├── Beam.cpp │ │ ├── BillBoard.cpp │ │ ├── Camera.cpp │ │ ├── DummyRenderable.cpp │ │ ├── Entity3D.cpp │ │ ├── FogArea.cpp │ │ ├── GuiSetEntity.cpp │ │ ├── Light.cpp │ │ ├── LightBox.cpp │ │ ├── LightPoint.cpp │ │ ├── LightSpot.cpp │ │ ├── MeshEntity.cpp │ │ ├── Node3D.cpp │ │ ├── NodeState.cpp │ │ ├── ParticleEmitter.cpp │ │ ├── ParticleEmitter_UserData.cpp │ │ ├── ParticleSystem.cpp │ │ ├── RenderableContainer.cpp │ │ ├── RenderableContainer_BoxTree.cpp │ │ ├── RenderableContainer_DynBoxTree.cpp │ │ ├── RenderableContainer_List.cpp │ │ ├── RopeEntity.cpp │ │ ├── Scene.cpp │ │ ├── SoundEntity.cpp │ │ ├── SubMeshEntity.cpp │ │ ├── Viewport.cpp │ │ └── World.cpp │ │ ├── sound │ │ ├── LowLevelSound.cpp │ │ ├── MusicHandler.cpp │ │ ├── Sound.cpp │ │ ├── SoundChannel.cpp │ │ ├── SoundEntityData.cpp │ │ └── SoundHandler.cpp │ │ └── system │ │ ├── Container.cpp │ │ ├── LogicTimer.cpp │ │ ├── MemoryManager.cpp │ │ ├── Mutex.cpp │ │ ├── Platform.cpp │ │ ├── PreprocessParser.cpp │ │ ├── SHA1.cpp │ │ ├── SerializeClass.cpp │ │ ├── String.cpp │ │ ├── System.cpp │ │ └── Thread.cpp ├── dependencies.zip └── tools │ ├── HplLangTool │ ├── App.ico │ ├── AssemblyInfo.cs │ ├── Form1.cs │ ├── Form1.resx │ ├── HpLangTool.sln │ ├── HplLangTool.csproj │ ├── HplTrans.cs │ ├── MainForm.cs │ └── MainForm.resx │ ├── LuxBasePersonal.h │ ├── editors │ ├── CMakeLists.txt │ ├── common │ │ ├── BoxCreator.cpp │ │ ├── BoxCreator.h │ │ ├── DirectoryHandler.cpp │ │ ├── DirectoryHandler.h │ │ ├── EdModule.h │ │ ├── EdType.cpp │ │ ├── EdType.h │ │ ├── EdWorld.cpp │ │ ├── EdWorld.h │ │ ├── EditMode.h │ │ ├── Editor.cpp │ │ ├── Editor.h │ │ ├── EditorAction.cpp │ │ ├── EditorAction.h │ │ ├── EditorActionArea.cpp │ │ ├── EditorActionArea.h │ │ ├── EditorActionCompoundObject.cpp │ │ ├── EditorActionCompoundObject.h │ │ ├── EditorActionDynamicEntity.cpp │ │ ├── EditorActionDynamicEntity.h │ │ ├── EditorActionEntity.cpp │ │ ├── EditorActionEntity.h │ │ ├── EditorActionHandler.cpp │ │ ├── EditorActionHandler.h │ │ ├── EditorActionLight.cpp │ │ ├── EditorActionLight.h │ │ ├── EditorActionMisc.cpp │ │ ├── EditorActionMisc.h │ │ ├── EditorActionSelection.cpp │ │ ├── EditorActionSelection.h │ │ ├── EditorActionsArea.cpp │ │ ├── EditorActionsArea.h │ │ ├── EditorActionsBodies.cpp │ │ ├── EditorActionsBodies.h │ │ ├── EditorActionsSubMesh.cpp │ │ ├── EditorActionsSubMesh.h │ │ ├── EditorAxisAlignedPlane.cpp │ │ ├── EditorAxisAlignedPlane.h │ │ ├── EditorBaseClasses.cpp │ │ ├── EditorBaseClasses.h │ │ ├── EditorClipPlane.cpp │ │ ├── EditorClipPlane.h │ │ ├── EditorEditMode.cpp │ │ ├── EditorEditMode.h │ │ ├── EditorEditModeAreas.cpp │ │ ├── EditorEditModeAreas.h │ │ ├── EditorEditModeBillboards.cpp │ │ ├── EditorEditModeBillboards.h │ │ ├── EditorEditModeBodies.cpp │ │ ├── EditorEditModeBodies.h │ │ ├── EditorEditModeCombine.cpp │ │ ├── EditorEditModeCombine.h │ │ ├── EditorEditModeDecals.cpp │ │ ├── EditorEditModeDecals.h │ │ ├── EditorEditModeDummy.h │ │ ├── EditorEditModeEntities.cpp │ │ ├── EditorEditModeEntities.h │ │ ├── EditorEditModeFactory.cpp │ │ ├── EditorEditModeFactory.h │ │ ├── EditorEditModeFogAreas.cpp │ │ ├── EditorEditModeFogAreas.h │ │ ├── EditorEditModeJoints.cpp │ │ ├── EditorEditModeJoints.h │ │ ├── EditorEditModeLights.cpp │ │ ├── EditorEditModeLights.h │ │ ├── EditorEditModeParticleSystems.cpp │ │ ├── EditorEditModeParticleSystems.h │ │ ├── EditorEditModePrimitive.cpp │ │ ├── EditorEditModePrimitive.h │ │ ├── EditorEditModeSelect.cpp │ │ ├── EditorEditModeSelect.h │ │ ├── EditorEditModeSelectTool.cpp │ │ ├── EditorEditModeSelectTool.h │ │ ├── EditorEditModeSelectToolRotate.cpp │ │ ├── EditorEditModeSelectToolRotate.h │ │ ├── EditorEditModeSelectToolScale.cpp │ │ ├── EditorEditModeSelectToolScale.h │ │ ├── EditorEditModeSelectToolTranslate.cpp │ │ ├── EditorEditModeSelectToolTranslate.h │ │ ├── EditorEditModeSounds.cpp │ │ ├── EditorEditModeSounds.h │ │ ├── EditorEditModeStaticObjects.cpp │ │ ├── EditorEditModeStaticObjects.h │ │ ├── EditorGrid.cpp │ │ ├── EditorGrid.h │ │ ├── EditorHelper.cpp │ │ ├── EditorHelper.h │ │ ├── EditorIndex.cpp │ │ ├── EditorIndex.h │ │ ├── EditorInput.cpp │ │ ├── EditorInput.h │ │ ├── EditorSelection.cpp │ │ ├── EditorSelection.h │ │ ├── EditorThumbnailBuilder.cpp │ │ ├── EditorThumbnailBuilder.h │ │ ├── EditorTypes.h │ │ ├── EditorUIPicker.h │ │ ├── EditorUserClassDefinitionManager.cpp │ │ ├── EditorUserClassDefinitionManager.h │ │ ├── EditorVar.cpp │ │ ├── EditorVar.h │ │ ├── EditorViewport.cpp │ │ ├── EditorViewport.h │ │ ├── EditorWindow.cpp │ │ ├── EditorWindow.h │ │ ├── EditorWindowAreas.cpp │ │ ├── EditorWindowAreas.h │ │ ├── EditorWindowBillboards.cpp │ │ ├── EditorWindowBillboards.h │ │ ├── EditorWindowBodies.cpp │ │ ├── EditorWindowBodies.h │ │ ├── EditorWindowCombine.cpp │ │ ├── EditorWindowCombine.h │ │ ├── EditorWindowDecals.cpp │ │ ├── EditorWindowDecals.h │ │ ├── EditorWindowEditModeSidebar.cpp │ │ ├── EditorWindowEditModeSidebar.h │ │ ├── EditorWindowEntities.cpp │ │ ├── EditorWindowEntities.h │ │ ├── EditorWindowEntityEditBox.cpp │ │ ├── EditorWindowEntityEditBox.h │ │ ├── EditorWindowEntityEditBoxArea.cpp │ │ ├── EditorWindowEntityEditBoxArea.h │ │ ├── EditorWindowEntityEditBoxBillboard.cpp │ │ ├── EditorWindowEntityEditBoxBillboard.h │ │ ├── EditorWindowEntityEditBoxBody.cpp │ │ ├── EditorWindowEntityEditBoxBody.h │ │ ├── EditorWindowEntityEditBoxBodyShape.cpp │ │ ├── EditorWindowEntityEditBoxBodyShape.h │ │ ├── EditorWindowEntityEditBoxBone.cpp │ │ ├── EditorWindowEntityEditBoxBone.h │ │ ├── EditorWindowEntityEditBoxCompound.cpp │ │ ├── EditorWindowEntityEditBoxCompound.h │ │ ├── EditorWindowEntityEditBoxDecal.cpp │ │ ├── EditorWindowEntityEditBoxDecal.h │ │ ├── EditorWindowEntityEditBoxEntity.cpp │ │ ├── EditorWindowEntityEditBoxEntity.h │ │ ├── EditorWindowEntityEditBoxFogArea.cpp │ │ ├── EditorWindowEntityEditBoxFogArea.h │ │ ├── EditorWindowEntityEditBoxGroup.cpp │ │ ├── EditorWindowEntityEditBoxGroup.h │ │ ├── EditorWindowEntityEditBoxGroupShapes.cpp │ │ ├── EditorWindowEntityEditBoxGroupShapes.h │ │ ├── EditorWindowEntityEditBoxJoint.cpp │ │ ├── EditorWindowEntityEditBoxJoint.h │ │ ├── EditorWindowEntityEditBoxLight.cpp │ │ ├── EditorWindowEntityEditBoxLight.h │ │ ├── EditorWindowEntityEditBoxParticleSystem.cpp │ │ ├── EditorWindowEntityEditBoxParticleSystem.h │ │ ├── EditorWindowEntityEditBoxPrimitive.cpp │ │ ├── EditorWindowEntityEditBoxPrimitive.h │ │ ├── EditorWindowEntityEditBoxSound.cpp │ │ ├── EditorWindowEntityEditBoxSound.h │ │ ├── EditorWindowEntityEditBoxStaticObject.cpp │ │ ├── EditorWindowEntityEditBoxStaticObject.h │ │ ├── EditorWindowEntityEditBoxSubMesh.cpp │ │ ├── EditorWindowEntityEditBoxSubMesh.h │ │ ├── EditorWindowEntitySearch.cpp │ │ ├── EditorWindowEntitySearch.h │ │ ├── EditorWindowFactory.cpp │ │ ├── EditorWindowFactory.h │ │ ├── EditorWindowFogAreas.cpp │ │ ├── EditorWindowFogAreas.h │ │ ├── EditorWindowInputWorldName.cpp │ │ ├── EditorWindowInputWorldName.h │ │ ├── EditorWindowJoints.cpp │ │ ├── EditorWindowJoints.h │ │ ├── EditorWindowLights.cpp │ │ ├── EditorWindowLights.h │ │ ├── EditorWindowLoaderStatus.cpp │ │ ├── EditorWindowLoaderStatus.h │ │ ├── EditorWindowLowerToolbar.cpp │ │ ├── EditorWindowLowerToolbar.h │ │ ├── EditorWindowMaterialEditor.cpp │ │ ├── EditorWindowMaterialEditor.h │ │ ├── EditorWindowObjectBrowser.cpp │ │ ├── EditorWindowObjectBrowser.h │ │ ├── EditorWindowOptions.cpp │ │ ├── EditorWindowOptions.h │ │ ├── EditorWindowParticleSystems.cpp │ │ ├── EditorWindowParticleSystems.h │ │ ├── EditorWindowPrimitives.cpp │ │ ├── EditorWindowPrimitives.h │ │ ├── EditorWindowSelect.cpp │ │ ├── EditorWindowSelect.h │ │ ├── EditorWindowSoundBrowser.cpp │ │ ├── EditorWindowSoundBrowser.h │ │ ├── EditorWindowSounds.cpp │ │ ├── EditorWindowSounds.h │ │ ├── EditorWindowStaticObjects.cpp │ │ ├── EditorWindowStaticObjects.h │ │ ├── EditorWindowTextureBrowser.cpp │ │ ├── EditorWindowTextureBrowser.h │ │ ├── EditorWindowViewport.cpp │ │ ├── EditorWindowViewport.h │ │ ├── EditorWorld.cpp │ │ ├── EditorWorld.h │ │ ├── EngineEntity.cpp │ │ ├── EngineEntity.h │ │ ├── EntityIcon.cpp │ │ ├── EntityIcon.h │ │ ├── EntityPicker.cpp │ │ ├── EntityPicker.h │ │ ├── EntityWrapper.cpp │ │ ├── EntityWrapper.h │ │ ├── EntityWrapperArea.cpp │ │ ├── EntityWrapperArea.h │ │ ├── EntityWrapperBillboard.cpp │ │ ├── EntityWrapperBillboard.h │ │ ├── EntityWrapperBody.cpp │ │ ├── EntityWrapperBody.h │ │ ├── EntityWrapperBodyShape.cpp │ │ ├── EntityWrapperBodyShape.h │ │ ├── EntityWrapperBone.cpp │ │ ├── EntityWrapperBone.h │ │ ├── EntityWrapperCompoundObject.cpp │ │ ├── EntityWrapperCompoundObject.h │ │ ├── EntityWrapperDecal.cpp │ │ ├── EntityWrapperDecal.h │ │ ├── EntityWrapperEntity.cpp │ │ ├── EntityWrapperEntity.h │ │ ├── EntityWrapperFactory.cpp │ │ ├── EntityWrapperFactory.h │ │ ├── EntityWrapperFogArea.cpp │ │ ├── EntityWrapperFogArea.h │ │ ├── EntityWrapperJoint.cpp │ │ ├── EntityWrapperJoint.h │ │ ├── EntityWrapperJointBall.cpp │ │ ├── EntityWrapperJointBall.h │ │ ├── EntityWrapperJointHinge.cpp │ │ ├── EntityWrapperJointHinge.h │ │ ├── EntityWrapperJointScrew.cpp │ │ ├── EntityWrapperJointScrew.h │ │ ├── EntityWrapperJointSlider.cpp │ │ ├── EntityWrapperJointSlider.h │ │ ├── EntityWrapperLight.cpp │ │ ├── EntityWrapperLight.h │ │ ├── EntityWrapperLightBox.cpp │ │ ├── EntityWrapperLightBox.h │ │ ├── EntityWrapperLightPoint.cpp │ │ ├── EntityWrapperLightPoint.h │ │ ├── EntityWrapperLightSpot.cpp │ │ ├── EntityWrapperLightSpot.h │ │ ├── EntityWrapperParticleSystem.cpp │ │ ├── EntityWrapperParticleSystem.h │ │ ├── EntityWrapperPrimitive.cpp │ │ ├── EntityWrapperPrimitive.h │ │ ├── EntityWrapperPrimitivePlane.cpp │ │ ├── EntityWrapperPrimitivePlane.h │ │ ├── EntityWrapperSound.cpp │ │ ├── EntityWrapperSound.h │ │ ├── EntityWrapperStaticObject.cpp │ │ ├── EntityWrapperStaticObject.h │ │ ├── EntityWrapperSubMesh.cpp │ │ ├── EntityWrapperSubMesh.h │ │ ├── ShapeCreator.h │ │ ├── SphereCreator.cpp │ │ ├── SphereCreator.h │ │ ├── StdAfx.cpp │ │ ├── StdAfx.h │ │ ├── SurfacePicker.cpp │ │ └── SurfacePicker.h │ ├── leveleditor │ │ ├── BuildID_LevelEditor.h │ │ ├── BuildID_LevelEditor_Win32.cpp │ │ ├── LevelEditor.cpp │ │ ├── LevelEditor.h │ │ ├── LevelEditorActions.cpp │ │ ├── LevelEditorActions.h │ │ ├── LevelEditorEditModeToolbox.cpp │ │ ├── LevelEditorEditModeToolbox.h │ │ ├── LevelEditorLowerToolbar.cpp │ │ ├── LevelEditorLowerToolbar.h │ │ ├── LevelEditorMain.cpp │ │ ├── LevelEditorStaticObjectCombo.cpp │ │ ├── LevelEditorStaticObjectCombo.h │ │ ├── LevelEditorTypes.h │ │ ├── LevelEditorWindow.cpp │ │ ├── LevelEditorWindow.h │ │ ├── LevelEditorWindowGroup.cpp │ │ ├── LevelEditorWindowGroup.h │ │ ├── LevelEditorWindowLevelSettings.cpp │ │ ├── LevelEditorWindowLevelSettings.h │ │ ├── LevelEditorWorld.cpp │ │ ├── LevelEditorWorld.h │ │ ├── buildcounterinput.txt │ │ ├── leveleditor.sln │ │ ├── leveleditor.vcproj │ │ ├── leveleditor.vcxproj │ │ └── leveleditor.vcxproj.filters │ ├── materialeditor │ │ ├── BuildID_MaterialEditor.h │ │ ├── BuildID_MaterialEditor_Win32.cpp │ │ ├── MaterialEditor.cpp │ │ ├── MaterialEditor.h │ │ ├── MaterialEditorMain.cpp │ │ ├── MaterialEditorTypes.h │ │ ├── buildcounterinput.txt │ │ ├── materialeditor.sln │ │ ├── materialeditor.vcproj │ │ └── materialeditor.vcxproj │ ├── modeleditor │ │ ├── BuildID_ModelEditor.h │ │ ├── BuildID_ModelEditor_Win32.cpp │ │ ├── ModelEditor.cpp │ │ ├── ModelEditor.h │ │ ├── ModelEditorActions.cpp │ │ ├── ModelEditorActions.h │ │ ├── ModelEditorEditModeToolbox.cpp │ │ ├── ModelEditorEditModeToolbox.h │ │ ├── ModelEditorLowerToolbar.cpp │ │ ├── ModelEditorLowerToolbar.h │ │ ├── ModelEditorMain.cpp │ │ ├── ModelEditorTypes.h │ │ ├── ModelEditorWindowAnimations.cpp │ │ ├── ModelEditorWindowAnimations.h │ │ ├── ModelEditorWindowOutline.cpp │ │ ├── ModelEditorWindowOutline.h │ │ ├── ModelEditorWindowPhysicsTest.cpp │ │ ├── ModelEditorWindowPhysicsTest.h │ │ ├── ModelEditorWindowUserSettings.cpp │ │ ├── ModelEditorWindowUserSettings.h │ │ ├── ModelEditorWorld.cpp │ │ ├── ModelEditorWorld.h │ │ ├── buildcounterinput.txt │ │ ├── modeleditor.sln │ │ ├── modeleditor.vcproj │ │ └── modeleditor.vcxproj │ └── particleeditor │ │ ├── BuildID_ParticleEditor.h │ │ ├── BuildID_ParticleEditor_Win32.cpp │ │ ├── EntityWrapperParticleEmitter.cpp │ │ ├── EntityWrapperParticleEmitter.h │ │ ├── ParticleEditor.cpp │ │ ├── ParticleEditor.h │ │ ├── ParticleEditorActions.cpp │ │ ├── ParticleEditorActions.h │ │ ├── ParticleEditorMain.cpp │ │ ├── ParticleEditorTypes.h │ │ ├── ParticleEditorWindowEmitterParams.cpp │ │ ├── ParticleEditorWindowEmitterParams.h │ │ ├── ParticleEditorWindowEmitters.cpp │ │ ├── ParticleEditorWindowEmitters.h │ │ ├── ParticleEditorWorld.cpp │ │ ├── ParticleEditorWorld.h │ │ ├── buildcounterinput.txt │ │ ├── particleeditor.sln │ │ ├── particleeditor.vcproj │ │ └── particleeditor.vcxproj │ ├── mapview │ ├── MapView.cpp │ ├── MapView.h │ ├── MapView.sln │ ├── MapView.vcproj │ ├── MapView.vcxproj │ └── MapView.vcxproj.filters │ ├── modelview │ ├── ModelView.cpp │ ├── ModelView.h │ ├── ModelView.sln │ ├── ModelView.vcproj │ └── ModelView.vcxproj │ ├── mshconverter │ ├── CMakeLists.txt │ ├── MshConverter.cpp │ ├── MshConverter.h │ ├── MshConverter.sln │ └── MshConverter.vcproj │ ├── particleview │ ├── ParticleView.cpp │ ├── ParticleView.h │ ├── ParticleView.sln │ └── ParticleView.vcproj │ └── texconverter │ ├── TexConverter.cpp │ ├── TexConverter.h │ ├── TexConverter.sln │ ├── TexConverter.vcproj │ └── TexHelpers.cpp ├── LICENSE └── README.md /BuildScripts/build-linux.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | dir=$PWD 4 | arch=$1 5 | 6 | if [ -z "$arch" ]; then 7 | echo "Specify if 32 or 64 arch sync" 8 | exit 1 9 | fi 10 | 11 | shift 1 12 | 13 | echo "Syncing code in 2 seconds" 14 | sleep 2 15 | ./mock-sync.sh $arch 16 | 17 | if [ "$arch" = "32" ]; then 18 | suffix="x86" 19 | else 20 | suffix="x86_64" 21 | fi 22 | 23 | if [ -r ./mock-config.txt ]; then 24 | . ./mock-config.txt 25 | else 26 | echo "Missing mock-config.txt" 27 | exit 1 28 | fi 29 | 30 | if [ $arch -eq 32 ]; then 31 | ROOT=$ROOT32 32 | elif [ $arch -eq 64 ]; then 33 | ROOT=$ROOT64 34 | else 35 | echo "Pick a correct sync arch (32 or 64)" 36 | exit 1 37 | fi 38 | 39 | root=`mock -r $ROOT --print-root-path`/builddir 40 | 41 | cat > $root/$dst_root/build.sh < 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleExecutable 8 | ${MACOSX_BUNDLE_EXECUTABLE_NAME} 9 | CFBundleIconFile 10 | ${MACOSX_BUNDLE_ICON_FILE} 11 | CFBundleIdentifier 12 | ${MACOSX_BUNDLE_GUI_IDENTIFIER} 13 | CFBundleInfoDictionaryVersion 14 | 6.0 15 | CFBundleName 16 | ${MACOSX_BUNDLE_BUNDLE_NAME} 17 | CFBundleDisplayName 18 | ${MACOSX_BUNDLE_EXECUTABLE_NAME} 19 | CFBundlePackageType 20 | APPL 21 | CFBundleShortVersionString 22 | ${MACOSX_BUNDLE_SHORT_VERSION_STRING} 23 | CFBundleVersion 24 | ${MACOSX_BUNDLE_BUNDLE_VERSION} 25 | LSApplicationCategoryType 26 | public.app-category.adventure-games 27 | LSMinimumSystemVersion 28 | 10.6 29 | NSHumanReadableCopyright 30 | ${MACOSX_BUNDLE_COPYRIGHT} 31 | StartFolder 32 | PARENT 33 | 34 | 35 | -------------------------------------------------------------------------------- /Game/src/game/Lux.icns: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/game/Lux.icns -------------------------------------------------------------------------------- /Game/src/game/Lux.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/game/Lux.ico -------------------------------------------------------------------------------- /Game/src/game/Lux.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 12.00 2 | # Visual Studio 15 3 | VisualStudioVersion = 15.0.28307.1209 4 | MinimumVisualStudioVersion = 10.0.40219.1 5 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Lux", "Lux.vcxproj", "{C6E72C29-38A3-4897-AA05-E87B0323AA71}" 6 | EndProject 7 | Global 8 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 9 | Debug|Win32 = Debug|Win32 10 | Demo|Win32 = Demo|Win32 11 | Release|Win32 = Release|Win32 12 | EndGlobalSection 13 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 14 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.ActiveCfg = Release|Win32 15 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.Build.0 = Release|Win32 16 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Demo|Win32.ActiveCfg = Demo|Win32 17 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Demo|Win32.Build.0 = Demo|Win32 18 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.ActiveCfg = Release|Win32 19 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.Build.0 = Release|Win32 20 | EndGlobalSection 21 | GlobalSection(SolutionProperties) = preSolution 22 | HideSolutionNode = FALSE 23 | EndGlobalSection 24 | GlobalSection(ExtensibilityGlobals) = postSolution 25 | SolutionGuid = {2093143A-34B5-44DC-A726-5F7AC93C38BE} 26 | EndGlobalSection 27 | EndGlobal 28 | -------------------------------------------------------------------------------- /Game/src/game/Lux.sln.old: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 8.00 2 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Lux", "Lux.vcproj", "{C6E72C29-38A3-4897-AA05-E87B0323AA71}" 3 | ProjectSection(ProjectDependencies) = postProject 4 | EndProjectSection 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfiguration) = preSolution 8 | Debug = Debug 9 | Demo = Demo 10 | Release = Release 11 | Release Steam = Release Steam 12 | Release_Serial = Release_Serial 13 | EndGlobalSection 14 | GlobalSection(ProjectConfiguration) = postSolution 15 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug.ActiveCfg = Release|Win32 16 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug.Build.0 = Release|Win32 17 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Demo.ActiveCfg = Demo|Win32 18 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Demo.Build.0 = Demo|Win32 19 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release.ActiveCfg = Release|Win32 20 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release.Build.0 = Release|Win32 21 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release Steam.ActiveCfg = Release|Win32 22 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release Steam.Build.0 = Release|Win32 23 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release_Serial.ActiveCfg = Release|Win32 24 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release_Serial.Build.0 = Release|Win32 25 | EndGlobalSection 26 | GlobalSection(ExtensibilityGlobals) = postSolution 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityAddIns) = postSolution 29 | EndGlobalSection 30 | EndGlobal 31 | -------------------------------------------------------------------------------- /Game/src/game/LuxIdleBehavior_ManPig.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef LUX_IDLE_BEHAVIOR_MANPIG 21 | #define LUX_IDLE_BEHAVIOR_MANPIG 22 | 23 | enum eLuxIdleBehavior 24 | { 25 | eLuxIdleBehavior_None, 26 | eLuxIdleBehavior_Stalk, 27 | eLuxIdleBehavior_Track, 28 | }; 29 | 30 | #endif -------------------------------------------------------------------------------- /Game/src/game/LuxInfectionHandler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef PIGS_INSANITY_HANDLER_H 21 | #define PIGS_INSANITY_HANDLER_H 22 | 23 | //---------------------------------------------- 24 | 25 | #include "LuxBase.h" 26 | 27 | //---------------------------------------------- 28 | 29 | class cLuxInfectionHandler : public iLuxUpdateable 30 | { 31 | // :TODO: friend class cLuxInfectionHandler_SaveData; 32 | public: 33 | cLuxInfectionHandler(); 34 | ~cLuxInfectionHandler(); 35 | 36 | void CreateCellGuiSet(); 37 | void LoadCellTextures(); 38 | 39 | void OnDraw(float afFrameTime); 40 | 41 | /*void OnStart(); 42 | void Reset(); 43 | void Update(float afTimeStep); 44 | */ 45 | 46 | 47 | private: 48 | 49 | //std::vector mvEvents; 50 | 51 | cGuiSet 52 | * mpCellGuiSet; 53 | std::vector 54 | mvCellGfx; 55 | }; 56 | 57 | 58 | #endif // PIGS_INSANITY_HANDLER_H -------------------------------------------------------------------------------- /Game/src/game/LuxProgressLogHandler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef LUX_PROGRESS_LOG_HANDLER_H 21 | #define LUX_PROGRESS_LOG_HANDLER_H 22 | 23 | //---------------------------------------------- 24 | 25 | #include "LuxBase.h" 26 | 27 | //---------------------------------------- 28 | 29 | class cLuxProgressLogHandler : public iLuxUpdateable 30 | { 31 | public: 32 | cLuxProgressLogHandler(); 33 | ~cLuxProgressLogHandler(); 34 | 35 | void LoadUserConfig(); 36 | void SaveUserConfig(); 37 | 38 | void OnStart(); 39 | void Update(float afTimeStep); 40 | void Reset(); 41 | 42 | void CreateAndResetLogFile(); 43 | 44 | void AddLog(eLuxProgressLogLevel aLevel, const tString& asMessage); 45 | 46 | private: 47 | tString LevelToString(eLuxProgressLogLevel aLevel); 48 | 49 | int mlCounter; 50 | int mlFileNameCount; 51 | bool mbActive; 52 | 53 | FILE *mpFile; 54 | }; 55 | 56 | //---------------------------------------------- 57 | 58 | 59 | #endif // LUX_PROGRESS_LOG_HANDLER_H 60 | -------------------------------------------------------------------------------- /Game/src/game/LuxTypes.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/game/LuxTypes.h -------------------------------------------------------------------------------- /Game/src/game/StdAfx.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "StdAfx.h" 21 | -------------------------------------------------------------------------------- /Game/src/game/StdAfx.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef LUX_STDAFX_H 21 | #define LUX_STDAFX_H 22 | 23 | #include "hpl.h" 24 | 25 | #endif // LUX_STDAFX_H 26 | -------------------------------------------------------------------------------- /Game/src/game/aamfp.icns: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/game/aamfp.icns -------------------------------------------------------------------------------- /Game/src/game/aamfp.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/game/aamfp.ico -------------------------------------------------------------------------------- /Game/src/game/resource.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | //{{NO_DEPENDENCIES}} 21 | // Microsoft Visual C++ generated include file. 22 | // Used by Lux.rc 23 | // 24 | #define PENUMBRA_ICO 102 25 | #define IDI_ICON1 112 26 | 27 | // Next default values for new objects 28 | // 29 | #ifdef APSTUDIO_INVOKED 30 | #ifndef APSTUDIO_READONLY_SYMBOLS 31 | #define _APS_NEXT_RESOURCE_VALUE 113 32 | #define _APS_NEXT_COMMAND_VALUE 40001 33 | #define _APS_NEXT_CONTROL_VALUE 1001 34 | #define _APS_NEXT_SYMED_VALUE 101 35 | #endif 36 | #endif 37 | -------------------------------------------------------------------------------- /Game/src/lang_conv/LangConv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | -------------------------------------------------------------------------------- /Game/src/lang_conv/LangConv.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 8.00 2 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LangConv", "LangConv.vcproj", "{824433CE-9979-440F-9C99-6DEEE7253EE6}" 3 | ProjectSection(ProjectDependencies) = postProject 4 | EndProjectSection 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfiguration) = preSolution 8 | Debug = Debug 9 | Release = Release 10 | EndGlobalSection 11 | GlobalSection(ProjectConfiguration) = postSolution 12 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Debug.ActiveCfg = Release|Win32 13 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Debug.Build.0 = Release|Win32 14 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Release.ActiveCfg = Release|Win32 15 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Release.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(ExtensibilityGlobals) = postSolution 18 | EndGlobalSection 19 | GlobalSection(ExtensibilityAddIns) = postSolution 20 | EndGlobalSection 21 | EndGlobal 22 | -------------------------------------------------------------------------------- /Game/src/launcher-macosx/EditorSuite.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | Label 7 | Level Editor 8 | Executable 9 | ./LevelEditor.app 10 | 11 | 12 | Label 13 | Material Editor 14 | Executable 15 | ./MaterialEditor.app 16 | 17 | 18 | Label 19 | Particle Editor 20 | Executable 21 | ./ParticleEditor.app 22 | 23 | 24 | Label 25 | Model Editor 26 | Executable 27 | ./ModelEditor.app 28 | 29 | 30 | Label 31 | Map Viewer 32 | Executable 33 | ./MapViewer.app 34 | 35 | 36 | Label 37 | Model Viewer 38 | Executable 39 | ./ModelViewer.app 40 | 41 | 42 | Label 43 | Open Custom Stories 44 | Method 45 | openCustomStories 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /Game/src/launcher-macosx/HPLMinimal.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | // 21 | // HPLMinimal.h 22 | // Lux 23 | // 24 | // Created by Edward Rudd on 8/19/10. 25 | // Copyright 2010 OutOfOrder.cc. All rights reserved. 26 | // 27 | 28 | #import 29 | 30 | #import "system/Platform.h" 31 | 32 | namespace hpl { 33 | void Error(const char* fmt, ...); 34 | } -------------------------------------------------------------------------------- /Game/src/launcher-macosx/HPLMinimal.mm: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | // 21 | // HPLMinimal.mm 22 | // Lux 23 | // 24 | // Created by Edward Rudd on 8/19/10. 25 | // Copyright 2010 OutOfOrder.cc. All rights reserved. 26 | // 27 | 28 | #import "HPLMinimal.h" 29 | 30 | 31 | #include 32 | 33 | namespace hpl { 34 | void Warning(const char* fmt, ...) { 35 | va_list ap; 36 | va_start(ap, fmt); 37 | char buff[1024]; 38 | vsnprintf(buff, 1024, fmt, ap); 39 | NSLog(@"Warn: %s", buff); 40 | va_end(ap); 41 | } 42 | 43 | void Error(const char* fmt, ...) { 44 | va_list ap; 45 | va_start(ap, fmt); 46 | char buff[1024]; 47 | vsnprintf(buff, 1024, fmt, ap); 48 | NSLog(@"Err: %s", buff); 49 | va_end(ap); 50 | } 51 | 52 | void Log(const char* fmt, ...) { 53 | va_list ap; 54 | va_start(ap, fmt); 55 | char buff[1024]; 56 | vsnprintf(buff, 1024, fmt, ap); 57 | NSLog(@"Log: %s", buff); 58 | va_end(ap); 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /Game/src/launcher-macosx/Launcher-Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleExecutable 8 | ${MACOSX_BUNDLE_EXECUTABLE_NAME} 9 | CFBundleIconFile 10 | ${MACOSX_BUNDLE_ICON_FILE} 11 | CFBundleIdentifier 12 | ${MACOSX_BUNDLE_GUI_IDENTIFIER} 13 | CFBundleInfoDictionaryVersion 14 | 6.0 15 | CFBundleName 16 | ${MACOSX_BUNDLE_BUNDLE_NAME} 17 | CFBundleDisplayName 18 | ${MACOSX_BUNDLE_EXECUTABLE_NAME} 19 | CFBundlePackageType 20 | APPL 21 | CFBundleShortVersionString 22 | ${MACOSX_BUNDLE_SHORT_VERSION_STRING} 23 | CFBundleVersion 24 | ${MACOSX_BUNDLE_BUNDLE_VERSION} 25 | LSApplicationCategoryType 26 | public.app-category.adventure-games 27 | LSMinimumSystemVersion 28 | 10.6 29 | NSHumanReadableCopyright 30 | ${MACOSX_BUNDLE_COPYRIGHT} 31 | NSMainNibFile 32 | MainWindow 33 | NSPrincipalClass 34 | NSApplication 35 | GamePath 36 | ./AmnesiaAMFP.app/Contents/MacOS/AmnesiaAMFP 37 | StartFolder 38 | PARENT 39 | 40 | 41 | -------------------------------------------------------------------------------- /Game/src/launcher-macosx/TabBackground.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | // 21 | // TabBackground.h 22 | // Lux 23 | // 24 | // Created by Edward Rudd on 8/18/10. 25 | // Copyright 2010 OutOfOrder.cc. All rights reserved. 26 | // 27 | 28 | #import 29 | 30 | 31 | @interface TabBackground : NSView { 32 | 33 | } 34 | 35 | @end 36 | -------------------------------------------------------------------------------- /Game/src/launcher-macosx/TabBackground.m: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | // 21 | // TabBackground.m 22 | // Lux 23 | // 24 | // Created by Edward Rudd on 8/18/10. 25 | // Copyright 2010 OutOfOrder.cc. All rights reserved. 26 | // 27 | 28 | #import "TabBackground.h" 29 | 30 | 31 | @implementation TabBackground 32 | 33 | - (id)initWithFrame:(NSRect)frame { 34 | self = [super initWithFrame:frame]; 35 | if (self) { 36 | // Initialization code here. 37 | } 38 | return self; 39 | } 40 | 41 | - (void)drawRect:(NSRect)dirtyRect { 42 | [[NSColor windowBackgroundColor] setFill]; 43 | NSBezierPath *p = [NSBezierPath bezierPath]; 44 | [p appendBezierPathWithRoundedRect:[self bounds] xRadius:10 yRadius:10]; 45 | [p fill]; 46 | } 47 | 48 | @end 49 | -------------------------------------------------------------------------------- /Game/src/launcher-macosx/launcher_bg.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/launcher-macosx/launcher_bg.jpg -------------------------------------------------------------------------------- /Game/src/launcher-macosx/main.m: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | // 21 | // main.m 22 | // Launcher 23 | // 24 | // Created by Edward Rudd on 3/20/09. 25 | // Copyright OutOfOrder.cc 2009. All rights reserved. 26 | // 27 | 28 | #import 29 | 30 | int main(int argc, char *argv[]) 31 | { 32 | return NSApplicationMain(argc, (const char **) argv); 33 | } 34 | -------------------------------------------------------------------------------- /Game/src/launcher/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required (VERSION 2.8) 2 | project(Launcher) 3 | 4 | include_directories( 5 | ${HPL2_INCLUDE_DIR} 6 | ${DEP_INCLUDE_DIR} 7 | ) 8 | 9 | link_directories( 10 | ${DEP_LIB_DIR} 11 | ) 12 | 13 | add_definitions(-DUSE_SDL2) 14 | 15 | add_executable(Launcher launcher.cpp Main.cpp QualityChooser.cpp LauncherHelper.cpp) 16 | target_link_libraries(Launcher HPL2 fltk_images fltk Xext X11 Xft fontconfig jpeg) 17 | 18 | install(TARGETS Launcher 19 | RUNTIME DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/../../redist" 20 | CONFIGURATIONS Debug) 21 | 22 | install(TARGETS Launcher 23 | RUNTIME DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/../../Production" 24 | CONFIGURATIONS RelWithDebInfo) 25 | 26 | # vim: et ts=4 27 | -------------------------------------------------------------------------------- /Game/src/launcher/Launcher.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Launcher", "Launcher.vcxproj", "{C6E72C29-38A3-4897-AA05-E87B0323AA71}" 4 | EndProject 5 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LauncherRussian", "LauncherRus.vcxproj", "{C82F7D41-6E2C-4806-AE2C-B4D67FF03E17}" 6 | EndProject 7 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LauncherCzech", "LauncherCz.vcxproj", "{B2766359-F754-4FF4-83DE-A2BD7C1E29C7}" 8 | EndProject 9 | Global 10 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 11 | Debug|Win32 = Debug|Win32 12 | Release|Win32 = Release|Win32 13 | EndGlobalSection 14 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 15 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.ActiveCfg = Debug|Win32 16 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.Build.0 = Debug|Win32 17 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.ActiveCfg = Release|Win32 18 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.Build.0 = Release|Win32 19 | {C82F7D41-6E2C-4806-AE2C-B4D67FF03E17}.Debug|Win32.ActiveCfg = Debug|Win32 20 | {C82F7D41-6E2C-4806-AE2C-B4D67FF03E17}.Release|Win32.ActiveCfg = Release|Win32 21 | {B2766359-F754-4FF4-83DE-A2BD7C1E29C7}.Debug|Win32.ActiveCfg = Debug|Win32 22 | {B2766359-F754-4FF4-83DE-A2BD7C1E29C7}.Release|Win32.ActiveCfg = Release|Win32 23 | EndGlobalSection 24 | GlobalSection(SolutionProperties) = preSolution 25 | HideSolutionNode = FALSE 26 | EndGlobalSection 27 | EndGlobal 28 | -------------------------------------------------------------------------------- /Game/src/launcher/Lux.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/launcher/Lux.ico -------------------------------------------------------------------------------- /Game/src/launcher/Main.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #pragma once 21 | -------------------------------------------------------------------------------- /Game/src/launcher/background.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/launcher/background.jpg -------------------------------------------------------------------------------- /Game/src/launcher/glut32.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/launcher/glut32.lib -------------------------------------------------------------------------------- /Game/src/launcher/launcherCz.fl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/Game/src/launcher/launcherCz.fl -------------------------------------------------------------------------------- /Game/src/launcher/resource.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | //{{NO_DEPENDENCIES}} 21 | // Microsoft Visual C++ generated include file. 22 | // Used by Launcher.rc 23 | // 24 | #define IDI_ICON1 103 25 | 26 | // Next default values for new objects 27 | // 28 | #ifdef APSTUDIO_INVOKED 29 | #ifndef APSTUDIO_READONLY_SYMBOLS 30 | #define _APS_NEXT_RESOURCE_VALUE 104 31 | #define _APS_NEXT_COMMAND_VALUE 40001 32 | #define _APS_NEXT_CONTROL_VALUE 1001 33 | #define _APS_NEXT_SYMED_VALUE 101 34 | #endif 35 | #endif 36 | -------------------------------------------------------------------------------- /HPL2/core/HPL2_0.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 8.00 2 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HPL2_0", "HPL2_0.vcproj", "{0780DEC5-A930-4721-9364-17A49D2A4E60}" 3 | ProjectSection(ProjectDependencies) = postProject 4 | EndProjectSection 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfiguration) = preSolution 8 | Debug = Debug 9 | Release = Release 10 | EndGlobalSection 11 | GlobalSection(ProjectConfiguration) = postSolution 12 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Debug.ActiveCfg = Release|Win32 13 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Debug.Build.0 = Release|Win32 14 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Release.ActiveCfg = Release|Win32 15 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Release.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(ExtensibilityGlobals) = postSolution 18 | EndGlobalSection 19 | GlobalSection(ExtensibilityAddIns) = postSolution 20 | EndGlobalSection 21 | EndGlobal 22 | -------------------------------------------------------------------------------- /HPL2/core/SDLMain.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | /* SDLMain.m - main entry point for our Cocoa-ized SDL app 21 | Initial Version: Darrell Walisser 22 | Non-NIB-Code & other changes: Max Horn 23 | 24 | Feel free to customize this file to suit your needs 25 | */ 26 | 27 | #ifndef _SDLMain_h_ 28 | #define _SDLMain_h_ 29 | 30 | #import 31 | 32 | @interface SDLMain : NSObject 33 | @end 34 | 35 | #endif /* _SDLMain_h_ */ 36 | -------------------------------------------------------------------------------- /HPL2/core/_HPL2_2010.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "_HPL2_2010", "_HPL2_2010.vcxproj", "{0780DEC5-A930-4721-9364-17A49D2A4E60}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release_NoHPLMain|Win32 = Release_NoHPLMain|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Debug|Win32.Build.0 = Debug|Win32 14 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Release_NoHPLMain|Win32.ActiveCfg = Release_NoHPLMain|Win32 15 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Release_NoHPLMain|Win32.Build.0 = Release_NoHPLMain|Win32 16 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Release|Win32.ActiveCfg = Release|Win32 17 | {0780DEC5-A930-4721-9364-17A49D2A4E60}.Release|Win32.Build.0 = Release|Win32 18 | EndGlobalSection 19 | GlobalSection(SolutionProperties) = preSolution 20 | HideSolutionNode = FALSE 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /HPL2/core/buildcounterinput.txt: -------------------------------------------------------------------------------- 1 | AppName HPL2_0 2 | LocalPath ../core 3 | ProjectIncludePath include 4 | OutHeaderPath . 5 | OutSourcePath sources -------------------------------------------------------------------------------- /HPL2/core/include/BuildID_HPL2_0.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | 25 | #ifndef BUILDID_HPL2_0_H 26 | #define BUILDID_HPL2_0_H 27 | 28 | const char* GetBuildID_HPL2_0(); 29 | 30 | 31 | #endif //BUILDID_HPL2_0_H 32 | -------------------------------------------------------------------------------- /HPL2/core/include/ai/AI.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_AI_H 21 | #define HPL_AI_H 22 | 23 | #include "system/SystemTypes.h" 24 | #include "engine/EngineTypes.h" 25 | 26 | #include "engine/Updateable.h" 27 | 28 | namespace hpl { 29 | 30 | class cAINodeGenerator; 31 | 32 | class cAI : public iUpdateable 33 | { 34 | public: 35 | cAI(); 36 | ~cAI(); 37 | 38 | void Reset(); 39 | void Update(float afTimeStep); 40 | 41 | void Init(); 42 | 43 | cAINodeGenerator *GetNodeGenerator(){ return mpAINodeGenerator;} 44 | 45 | private: 46 | cAINodeGenerator *mpAINodeGenerator; 47 | }; 48 | 49 | }; 50 | #endif // HPL_AI_H 51 | -------------------------------------------------------------------------------- /HPL2/core/include/generate/Generate.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_GENERATE_H 21 | #define HPL_GENERATE_H 22 | 23 | #include "system/SystemTypes.h" 24 | #include "math/MathTypes.h" 25 | #include "graphics/GraphicsTypes.h" 26 | #include "generate/GenerateTypes.h" 27 | 28 | namespace hpl { 29 | 30 | //------------------------------------- 31 | 32 | class cGraphics; 33 | class cResources; 34 | 35 | class cVoxelMap; 36 | 37 | //------------------------------------- 38 | 39 | class cGenerate 40 | { 41 | public: 42 | cGenerate(); 43 | ~cGenerate(); 44 | 45 | void Init(cResources *apResources, cGraphics *apGraphics); 46 | 47 | cVoxelMap* CreateVoxelMap(const cVector3l& avSize); 48 | void DestroyVoxelMap(cVoxelMap* apMap); 49 | 50 | private: 51 | cResources *mpResources; 52 | cGraphics *mpGraphics; 53 | }; 54 | 55 | }; 56 | #endif // HPL_GENERATE_H 57 | -------------------------------------------------------------------------------- /HPL2/core/include/graphics/BoneState.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_BONE_STATE_H 21 | #define HPL_BONE_STATE_H 22 | 23 | #include "scene/Node3D.h" 24 | 25 | namespace hpl { 26 | 27 | class iPhysicsBody; 28 | 29 | class cBoneState : public cNode3D 30 | { 31 | public: 32 | cBoneState(const tString &asName, bool abAutoDeleteChildren); 33 | 34 | void SetBody(iPhysicsBody *apBody); 35 | iPhysicsBody* GetBody(); 36 | 37 | void SetColliderBody(iPhysicsBody *apBody); 38 | iPhysicsBody* GetColliderBody(); 39 | 40 | void SetBodyMatrix(const cMatrixf &a_mtxBody); 41 | const cMatrixf& GetBodyMatrix(); 42 | const cMatrixf& GetInvBodyMatrix(); 43 | 44 | private: 45 | iPhysicsBody *mpBody; 46 | cMatrixf m_mtxBody; 47 | cMatrixf m_mtxInvBody; 48 | 49 | iPhysicsBody *mpColliderBody; 50 | }; 51 | 52 | }; 53 | #endif // HPL_BONE_STATE_H 54 | -------------------------------------------------------------------------------- /HPL2/core/include/graphics/FrameBase.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_FRAMEBASE_H 21 | #define HPL_FRAMEBASE_H 22 | 23 | #include "math/MathTypes.h" 24 | 25 | namespace hpl { 26 | 27 | class iFrameBase 28 | { 29 | public: 30 | iFrameBase(){ 31 | mlPicCount = 0; 32 | } 33 | ~iFrameBase() { } 34 | 35 | void SetPicCount(int alPicCount){mlPicCount=alPicCount;} 36 | void DecPicCount(){if(mlPicCount>0)mlPicCount--;} 37 | int GetPicCount(){return mlPicCount;} 38 | bool IsEmpty() {return mlPicCount<=0;} 39 | 40 | protected: 41 | int mlPicCount; 42 | }; 43 | 44 | }; 45 | #endif // HPL_FRAMEBASE_H 46 | -------------------------------------------------------------------------------- /HPL2/core/include/graphics/FrameTexture.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_FRAMETEXTURE_H 21 | #define HPL_FRAMETEXTURE_H 22 | 23 | #include "graphics/FrameBase.h" 24 | 25 | namespace hpl { 26 | 27 | class iTexture; 28 | class cFrameSubImage; 29 | class cImageManager; 30 | 31 | class cFrameTexture : public iFrameBase 32 | { 33 | public: 34 | cFrameTexture(iTexture *pTex, int alHandle,cImageManager *apImageManager, bool abIsCustom); 35 | ~cFrameTexture(); 36 | 37 | iTexture* GetTexture(); 38 | int GetHandle(){return mlHandle;} 39 | 40 | inline bool IsCustom(){ return mbIsCustom;} 41 | 42 | /** 43 | * Creates a subimage in frame at pos and with size messured in pixel. Only works on custom frames! 44 | */ 45 | cFrameSubImage* CreateCustomImage(const cVector2l& avPixelPos,const cVector2l& avPixelSize); 46 | 47 | private: 48 | 49 | 50 | iTexture *mpTexture; 51 | int mlHandle; 52 | 53 | bool mbIsCustom; 54 | 55 | cImageManager *mpImageManager; 56 | }; 57 | 58 | }; 59 | #endif // HPL_FRAMETEXTURE_H 60 | -------------------------------------------------------------------------------- /HPL2/core/include/graphics/OcclusionQuery.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_OCCLUSION_QUERY_H 21 | #define HPL_OCCLUSION_QUERY_H 22 | 23 | namespace hpl { 24 | 25 | class iOcclusionQuery 26 | { 27 | public: 28 | virtual ~iOcclusionQuery(){} 29 | 30 | /** 31 | * Starts the query. Must be followed by an End(). 32 | */ 33 | virtual void Begin()=0; 34 | /** 35 | * Ends the current query. Must have been started with a Begin() 36 | */ 37 | virtual void End()=0; 38 | 39 | /** 40 | * Fetches the result of he query. Should not be done until all is rendered. 41 | */ 42 | virtual bool FetchResults()=0; 43 | 44 | /** 45 | * Get the number of samples that passed stencil and depth test in the query begin/end. 46 | */ 47 | virtual unsigned int GetSampleCount()=0; 48 | }; 49 | 50 | }; 51 | #endif // HPL_OCCLUSION_QUERY_H 52 | -------------------------------------------------------------------------------- /HPL2/core/include/graphics/RendererWireFrame.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_RENDERER_WIRE_FRAME_H 21 | #define HPL_RENDERER_WIRE_FRAME_H 22 | 23 | #include "graphics/Renderer.h" 24 | 25 | namespace hpl { 26 | 27 | //--------------------------------------------- 28 | 29 | class iFrameBuffer; 30 | class iDepthStencilBuffer; 31 | class iTexture; 32 | class iLight; 33 | 34 | //--------------------------------------------- 35 | 36 | class cRendererWireFrame : public iRenderer 37 | { 38 | public: 39 | cRendererWireFrame(cGraphics *apGraphics,cResources* apResources); 40 | ~cRendererWireFrame(); 41 | 42 | bool LoadData(); 43 | void DestroyData(); 44 | 45 | private: 46 | void CopyToFrameBuffer(); 47 | void SetupRenderList(); 48 | void RenderObjects(); 49 | }; 50 | 51 | //--------------------------------------------- 52 | 53 | }; 54 | #endif // HPL_RENDERER_WIRE_FRAME_H 55 | -------------------------------------------------------------------------------- /HPL2/core/include/gui/GuiMaterial.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_GUI_MATERIAL_H 21 | #define HPL_GUI_MATERIAL_H 22 | 23 | #include "system/SystemTypes.h" 24 | 25 | 26 | namespace hpl { 27 | 28 | class iLowLevelGraphics; 29 | 30 | class iGuiMaterial 31 | { 32 | public: 33 | iGuiMaterial(const tString &asName,iLowLevelGraphics *apLowLevelGraphics) : 34 | msName(asName), mpLowLevelGraphics(apLowLevelGraphics) {} 35 | virtual ~iGuiMaterial(){} 36 | 37 | virtual void BeforeRender()=0; 38 | virtual void AfterRender()=0; 39 | 40 | const tString& GetName() const {return msName;} 41 | 42 | protected: 43 | tString msName; 44 | iLowLevelGraphics *mpLowLevelGraphics; 45 | }; 46 | 47 | }; 48 | #endif // HPL_GUI_MATERIAL_H 49 | -------------------------------------------------------------------------------- /HPL2/core/include/gui/WidgetDummy.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_WIDGET_DUMMY_H 21 | #define HPL_WIDGET_DUMMY_H 22 | 23 | #include "gui/Widget.h" 24 | 25 | namespace hpl { 26 | 27 | class cWidgetDummy : public iWidget 28 | { 29 | public: 30 | cWidgetDummy(cGuiSet *apSet, cGuiSkin *apSkin); 31 | virtual ~cWidgetDummy(); 32 | 33 | void SetEncloseChildren(bool abX); 34 | 35 | void OnChildUpdate(iWidget* apChild); 36 | 37 | protected: 38 | bool mbEncloseChildren; 39 | }; 40 | 41 | }; 42 | #endif // HPL_WIDGET_H 43 | -------------------------------------------------------------------------------- /HPL2/core/include/gui/WidgetListBox.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_WIDGET_LIST_BOX_H 21 | #define HPL_WIDGET_LIST_BOX_H 22 | 23 | #include "gui/Widget.h" 24 | #include "gui/WidgetListBoxBase.h" 25 | #include "gui/WidgetBaseClasses.h" 26 | 27 | namespace hpl { 28 | 29 | class cGuiSkinFont; 30 | 31 | class cWidgetSlider; 32 | 33 | class cWidgetListBox : public iWidgetListBoxBase 34 | { 35 | public: 36 | cWidgetListBox(cGuiSet *apSet, cGuiSkin *apSkin); 37 | virtual ~cWidgetListBox(); 38 | protected: 39 | ///////////////////////// 40 | // Own functions 41 | 42 | ///////////////////////// 43 | // Implemented iWidgetListBoxBase functions 44 | void DrawItems(float afTimeStep, cGuiClipRegion* apClipRegion); 45 | ///////////////////////// 46 | // Implemented functions 47 | 48 | 49 | ///////////////////////// 50 | // Data 51 | }; 52 | 53 | }; 54 | #endif // HPL_WIDGET_LIST_BOX_H 55 | -------------------------------------------------------------------------------- /HPL2/core/include/haptic/Haptic.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_HAPTIC_H 21 | #define HPL_HAPTIC_H 22 | 23 | #include "engine/Updateable.h" 24 | #include "haptic/HapticTypes.h" 25 | 26 | namespace hpl { 27 | 28 | class iLowLevelHaptic; 29 | class cResources; 30 | 31 | class cHaptic : public iUpdateable 32 | { 33 | public: 34 | cHaptic(iLowLevelHaptic *apLowLevelHaptic); 35 | ~cHaptic(); 36 | 37 | static void SetIsUsed(bool abX){ mbIsUsed = abX;} 38 | static bool GetIsUsed(){ return mbIsUsed;} 39 | 40 | void Init(cResources *apResources); 41 | 42 | void Update(float afTimeStep); 43 | 44 | iLowLevelHaptic * GetLowLevel(){ return mpLowLevelHaptic;} 45 | 46 | private: 47 | iLowLevelHaptic *mpLowLevelHaptic; 48 | 49 | static bool mbIsUsed; 50 | }; 51 | 52 | }; 53 | #endif // HPL_HAPTIC_H 54 | -------------------------------------------------------------------------------- /HPL2/core/include/haptic/HapticForce.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_HAPTIC_FORCE_H 21 | #define HPL_HAPTIC_FORCE_H 22 | 23 | #include "math/MathTypes.h" 24 | #include "haptic/HapticTypes.h" 25 | 26 | namespace hpl { 27 | 28 | class iHapticForce 29 | { 30 | public: 31 | iHapticForce(eHapticForceType aType) : mType(aType){} 32 | virtual ~iHapticForce(){} 33 | 34 | eHapticForceType GetType(){ return mType;} 35 | 36 | virtual void SetActive(bool abX)=0; 37 | virtual bool IsActive()=0; 38 | 39 | virtual void SetForce(const cVector3f &avForce)=0; 40 | virtual void SetRelativeForce(const cVector3f &avForce)=0; 41 | 42 | virtual void SetDirection(const cVector3f &avDir)=0; 43 | virtual void SetFreq(float afFreq)=0; 44 | virtual void SetAmp(float afAmp)=0; 45 | 46 | virtual void SetTimeControl(bool abLoop,float afTime,float afIdleTime, 47 | float afFadeInTime, float afFadeOutTime)=0; 48 | 49 | protected: 50 | eHapticForceType mType; 51 | }; 52 | 53 | }; 54 | #endif // HPL_HAPTIC_FORCE_H 55 | -------------------------------------------------------------------------------- /HPL2/core/include/haptic/HapticSurface.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_HAPTIC_SURFACE_H 21 | #define HPL_HAPTIC_SURFACE_H 22 | 23 | #include "system/SystemTypes.h" 24 | #include "math/MathTypes.h" 25 | #include "haptic/HapticTypes.h" 26 | 27 | namespace hpl { 28 | 29 | class iHapticSurface 30 | { 31 | public: 32 | iHapticSurface(const tString& asName, eHapticSurfaceType aType) : mType(aType){} 33 | virtual ~iHapticSurface(){} 34 | 35 | eHapticSurfaceType GetType(){ return mType;} 36 | tString& GetName(){ return msName; } 37 | 38 | private: 39 | eHapticSurfaceType mType; 40 | tString msName; 41 | }; 42 | 43 | }; 44 | #endif // HPL_HAPTIC_SURFACE_H 45 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/BitmapLoaderDevil.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_BITMAP_LOADER_DEVIL_H 21 | #define HPL_BITMAP_LOADER_DEVIL_H 22 | 23 | #include "resources/BitmapLoader.h" 24 | 25 | #include 26 | 27 | namespace hpl { 28 | 29 | 30 | class iBitmapLoaderDevil : public iBitmapLoader 31 | { 32 | public: 33 | iBitmapLoaderDevil(); 34 | virtual ~iBitmapLoaderDevil(); 35 | 36 | bool SaveBitmap(cBitmap* apBitmap,const tWString& asFile, tBitmapSaveFlag aFlags); 37 | 38 | protected: 39 | void Initialize(); 40 | 41 | bool LoadDevilImageW(const tWString& asFile); 42 | 43 | ePixelFormat DevilPixelFormatToHPL(int alFormat); 44 | ILenum HPLPixelFormatToDevil(ePixelFormat aFormat); 45 | ILenum FileNameToDevilTypeW(const tWString& asFile); 46 | 47 | static bool mbIsInitialized; 48 | }; 49 | 50 | }; 51 | #endif // HPL_BITMAP_LOADER_DEVIL_H 52 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/BitmapLoaderDevilDDS.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_BITMAP_LOADER_DEVIL_DDS_H 21 | #define HPL_BITMAP_LOADER_DEVIL_DDS_H 22 | 23 | #include "impl/BitmapLoaderDevil.h" 24 | 25 | namespace hpl { 26 | 27 | class cBitmapLoaderDevilDDS : public iBitmapLoaderDevil 28 | { 29 | public: 30 | cBitmapLoaderDevilDDS(); 31 | ~cBitmapLoaderDevilDDS(); 32 | 33 | cBitmap* LoadBitmap(const tWString& asFile, tBitmapLoadFlag aFlags); 34 | 35 | 36 | protected: 37 | ePixelFormat GetPixelFormatFromILDXT(int alDxtFormat); 38 | }; 39 | 40 | }; 41 | #endif // HPL_BITMAP_LOADER_DEVIL_DDS_H 42 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/BitmapLoaderDevilMisc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_BITMAP_LOADER_DEVIL_MISC_H 21 | #define HPL_BITMAP_LOADER_DEVIL_MISC_H 22 | 23 | #include "impl/BitmapLoaderDevil.h" 24 | 25 | namespace hpl { 26 | 27 | class cBitmapLoaderDevilMisc : public iBitmapLoaderDevil 28 | { 29 | public: 30 | cBitmapLoaderDevilMisc(); 31 | ~cBitmapLoaderDevilMisc(); 32 | 33 | cBitmap* LoadBitmap(const tWString& asFile, tBitmapLoadFlag aFlags); 34 | 35 | protected: 36 | }; 37 | 38 | }; 39 | #endif // HPL_BITMAP_LOADER_DEVIL_MISC_H 40 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/CGProgram.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_CGPROGRAM_H 21 | #define HPL_CGPROGRAM_H 22 | 23 | //#include 24 | 25 | #include "system/SystemTypes.h" 26 | #include "math/MathTypes.h" 27 | #include "graphics/GPUShader.h" 28 | 29 | #include "graphics/GPUProgram.h" 30 | 31 | namespace hpl { 32 | 33 | class cCGProgram : public iGpuProgram 34 | { 35 | public: 36 | cCGProgram(); 37 | 38 | bool Link(); 39 | 40 | void Bind(); 41 | void UnBind(); 42 | 43 | protected: 44 | }; 45 | }; 46 | #endif // HPL_CGPROGRAM_H 47 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/CharacterBodyNewton.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_CHARACTER_BODY_NEWTON_H 21 | #define HPL_CHARACTER_BODY_NEWTON_H 22 | 23 | #include "physics/CharacterBody.h" 24 | #if defined(__linux__) || defined(__APPLE__) 25 | #include 26 | #endif 27 | #include 28 | 29 | namespace hpl { 30 | 31 | class iPhysicsWorld; 32 | 33 | class cCharacterBodyNewton : public iCharacterBody 34 | { 35 | public: 36 | cCharacterBodyNewton(const tString &asName,iPhysicsWorld *apWorld, const cVector3f avSize); 37 | ~cCharacterBodyNewton(); 38 | 39 | private: 40 | }; 41 | }; 42 | #endif // HPL_CHARACTER_BODY_NEWTON_H 43 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/FmodSoundData.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_FMOD_SOUND_DATA_H 21 | #define HPL_FMOD_SOUND_DATA_H 22 | 23 | #include "sound/SoundData.h" 24 | 25 | #include 26 | 27 | namespace hpl { 28 | 29 | class cFmodSoundData : public iSoundData 30 | { 31 | public: 32 | cFmodSoundData(const tString& asName, bool abStream); 33 | ~cFmodSoundData(); 34 | 35 | bool CreateFromFile(const tWString &asFile); 36 | 37 | iSoundChannel* CreateChannel(int alPriority); 38 | 39 | bool IsStream(){ return mbStream;} 40 | 41 | bool IsStereo(){ return false;} 42 | 43 | //FMOD Specific 44 | FSOUND_SAMPLE *GetSample(){ return mpSample;} 45 | FSOUND_STREAM *GetStream(){ return mpStream;} 46 | 47 | private: 48 | FSOUND_SAMPLE * mpSample; 49 | FSOUND_STREAM * mpStream; 50 | }; 51 | }; 52 | #endif // HPL_FMOD_SOUND_DATA_H 53 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/LowLevelPhysicsNewton.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_LOWLEVELPHYSICS_NEWTON_H 21 | #define HPL_LOWLEVELPHYSICS_NEWTON_H 22 | 23 | #include "physics/LowLevelPhysics.h" 24 | #if defined(__linux__) || defined(__APPLE__) 25 | #include 26 | #endif 27 | #include 28 | 29 | namespace hpl { 30 | 31 | class cLowLevelPhysicsNewton : public iLowLevelPhysics 32 | { 33 | public: 34 | cLowLevelPhysicsNewton(); 35 | ~cLowLevelPhysicsNewton(); 36 | 37 | iPhysicsWorld* CreateWorld(); 38 | }; 39 | }; 40 | #endif // HPL_LOWLEVELPHYSICS_NEWTON_H 41 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/LowLevelResourcesSDL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_LOWLEVELRESOURCES_SDL_H 21 | #define HPL_LOWLEVELRESOURCES_SDL_H 22 | 23 | #include "resources/LowLevelResources.h" 24 | #include "system/SystemTypes.h" 25 | 26 | namespace hpl { 27 | 28 | //---------------------------------------- 29 | 30 | class iLowLevelGraphics; 31 | 32 | //---------------------------------------- 33 | 34 | class cLowLevelResourcesSDL : public iLowLevelResources 35 | { 36 | public: 37 | cLowLevelResourcesSDL(iLowLevelGraphics *apLowLevelGraphics); 38 | ~cLowLevelResourcesSDL(); 39 | 40 | void AddBitmapLoaders(cBitmapLoaderHandler* apHandler); 41 | void AddMeshLoaders(cMeshLoaderHandler* apHandler); 42 | void AddVideoLoaders(cVideoLoaderHandler* apHandler); 43 | 44 | iXmlDocument* CreateXmlDocument(const tString& asName=""); 45 | 46 | private: 47 | iLowLevelGraphics *mpLowLevelGraphics; 48 | }; 49 | }; 50 | #endif // HPL_LOWLEVELRESOURCES_SDL_H 51 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/MutexSDL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_MUTEX_SDL_H 21 | #define HPL_MUTEX_SDL_H 22 | 23 | #include "system/Mutex.h" 24 | 25 | struct SDL_mutex; 26 | 27 | namespace hpl { 28 | 29 | class cMutexSDL : public iMutex 30 | { 31 | public: 32 | 33 | cMutexSDL(); 34 | ~cMutexSDL(); 35 | 36 | bool Lock(); 37 | bool Unlock(); 38 | 39 | private: 40 | SDL_mutex* mpMutexHandle; 41 | 42 | }; 43 | 44 | }; 45 | #endif // HPL_MUTEX_SDL_H 46 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/MutexWin32.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_MUTEX_WIN32_H 21 | #define HPL_MUTEX_WIN32_H 22 | 23 | #include "system/Mutex.h" 24 | 25 | #include 26 | 27 | namespace hpl { 28 | 29 | class cMutexWin32 : public iMutex 30 | { 31 | public: 32 | 33 | cMutexWin32(); 34 | ~cMutexWin32(); 35 | 36 | bool Lock(); 37 | bool Unlock(); 38 | 39 | private: 40 | HANDLE mpMutexHandle; 41 | 42 | }; 43 | 44 | }; 45 | #endif // HPL_MUTEX_WIN32_H 46 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/OcclusionQueryOGL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_OCCLUSION_QUERY_OGL_H 21 | #define HPL_OCCLUSION_QUERY_OGL_H 22 | 23 | #include "graphics/OcclusionQuery.h" 24 | 25 | namespace hpl { 26 | 27 | class cOcclusionQueryOGL : public iOcclusionQuery 28 | { 29 | public: 30 | cOcclusionQueryOGL(); 31 | ~cOcclusionQueryOGL(); 32 | 33 | void Begin(); 34 | void End(); 35 | bool FetchResults(); 36 | unsigned int GetSampleCount(); 37 | 38 | public: 39 | bool mbResultsAreFetched; 40 | int mlLastSampleCount; 41 | unsigned int mlQueryId; 42 | }; 43 | 44 | }; 45 | #endif // HPL_OCCLUSION_QUERY_H 46 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/OpenALSoundData.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_OPENAL_SOUND_DATA_H 21 | #define HPL_OPENAL_SOUND_DATA_H 22 | 23 | #include "sound/SoundData.h" 24 | 25 | #ifdef USE_OALWRAPPER 26 | # include "OALWrapper/OAL_Funcs.h" 27 | #else 28 | # include "OpenAL/OAL_Funcs.h" 29 | #endif 30 | 31 | namespace hpl { 32 | 33 | class cOpenALSoundData : public iSoundData 34 | { 35 | public: 36 | cOpenALSoundData(const tString& asName, bool abStream); 37 | ~cOpenALSoundData(); 38 | 39 | bool CreateFromFile(const tWString &asFile); 40 | 41 | iSoundChannel* CreateChannel(int alPriority); 42 | 43 | bool IsStream(){ return mbStream;} 44 | 45 | bool IsStereo(); 46 | 47 | cOAL_Sample* GetSample(){ return ( mpSample ); } //static_cast (mpSoundData));} 48 | cOAL_Stream* GetStream(){ return ( mpStream ); } //static_cast (mpSoundData));} 49 | 50 | private: 51 | cOAL_Sample* mpSample; 52 | cOAL_Stream* mpStream; 53 | 54 | //iOAL_Loadable* mpSoundData; 55 | }; 56 | }; 57 | #endif // HPL_OPENAL_SOUND_DATA_H 58 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/PhysicsControllerNewton.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_PHYSICS_CONTROLLER_NEWTON_H 21 | #define HPL_PHYSICS_CONTROLLER_NEWTON_H 22 | 23 | #include "physics/PhysicsController.h" 24 | 25 | namespace hpl { 26 | 27 | class iPhysicsWorld; 28 | 29 | class cPhysicsControllerNewton : public iPhysicsController 30 | { 31 | public: 32 | cPhysicsControllerNewton(const tString &asName, iPhysicsWorld *apWorld); 33 | ~cPhysicsControllerNewton(); 34 | }; 35 | }; 36 | #endif // HPL_PHYSICS_CONTROLLER_NEWTON_H 37 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/PhysicsJointBallNewton.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_PHYSICS_JOINT_BALL_NEWTON_H 21 | #define HPL_PHYSICS_JOINT_BALL_NEWTON_H 22 | 23 | #include "physics/PhysicsJointBall.h" 24 | #include "impl/PhysicsJointNewton.h" 25 | 26 | namespace hpl { 27 | 28 | class cPhysicsJointBallNewton : public iPhysicsJointNewton 29 | { 30 | public: 31 | cPhysicsJointBallNewton(const tString &asName, iPhysicsBody *apParentBody, iPhysicsBody *apChildBody, 32 | iPhysicsWorld *apWorld, const cVector3f &avPivotPoint, const cVector3f &avPinDir); 33 | ~cPhysicsJointBallNewton(); 34 | 35 | void SetConeLimits(float afMaxConeAngle, float afMaxTwistAngle); 36 | cVector3f GetAngles(); 37 | 38 | cVector3f GetVelocity(); 39 | cVector3f GetAngularVelocity(); 40 | float GetForceSize(); 41 | 42 | float GetDistance(); 43 | float GetAngle(); 44 | 45 | private: 46 | }; 47 | }; 48 | #endif // HPL_PHYSICS_JOINT_BALL_NEWTON_H 49 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/PhysicsRopeNewton.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_PHYSICS_ROPE_NEWTON_H 21 | #define HPL_PHYSICS_ROPE_NEWTON_H 22 | 23 | #include "physics/PhysicsRope.h" 24 | 25 | namespace hpl { 26 | 27 | //------------------------------------------ 28 | 29 | class cPhysicsRopeNewton : public iPhysicsRope 30 | { 31 | public: 32 | cPhysicsRopeNewton(const tString &asName, iPhysicsWorld *apWorld, const cVector3f &avStartPos, const cVector3f &avEndPos); 33 | virtual ~cPhysicsRopeNewton(); 34 | }; 35 | }; 36 | #endif // HPL_PHYSICS_ROPE_NEWTON_H 37 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/SDLFontData.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_SDL_FONTDATA_H 21 | #define HPL_SDL_FONTDATA_H 22 | 23 | #include "graphics/FontData.h" 24 | 25 | //#include 26 | //#include 27 | 28 | namespace hpl { 29 | 30 | class cSDLFontData : public iFontData 31 | { 32 | public: 33 | cSDLFontData(const tString &asName, iLowLevelGraphics* apLowLevelGraphics); 34 | cSDLFontData(); 35 | 36 | bool CreateFromFontFile(const tWString &asFileName, int alSize,unsigned short alFirstChar, 37 | unsigned short alLastChar); 38 | bool CreateFromBitmapFile(const tWString &asFileName); 39 | 40 | private: 41 | //cGlyph* RenderGlyph(TTF_Font* apFont,unsigned short aChar, int alFontSize); 42 | 43 | }; 44 | 45 | }; 46 | #endif // HPL_FONTDATA_H 47 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/SqScript.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_SQ_SCRIPT_H 21 | #define HPL_SQ_SCRIPT_H 22 | 23 | #include "system/Script.h" 24 | #include "impl/LowLevelSystemSDL.h" 25 | #include 26 | 27 | 28 | namespace hpl { 29 | 30 | class cSqScript : public iScript 31 | { 32 | public: 33 | cSqScript(const tString& asName, asIScriptEngine *apScriptEngine,cScriptOutput *apScriptOutput, int alHandle); 34 | ~cSqScript(); 35 | 36 | bool CreateFromFile(const tWString& asFileName, tString *apCompileMessages=NULL); 37 | 38 | void AddArg(const tString& asArg); 39 | 40 | bool Run(const tString& asFuncLine); 41 | //bool Run(int alHandle); 42 | 43 | private: 44 | asIScriptEngine *mpScriptEngine; 45 | cScriptOutput *mpScriptOutput; 46 | 47 | asIScriptContext *mpContext; 48 | asIScriptModule *mpModule; 49 | 50 | int mlHandle; 51 | tString msModuleName; 52 | 53 | char* LoadCharBuffer(const tWString& asFileName, int& alLength); 54 | }; 55 | }; 56 | #endif // HPL_SCRIPT_H 57 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/TaskKeyHook.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | //////////////////////////////////////////////////////////////// 21 | // MSDN Magazine -- September 2002 22 | // If this code works, it was written by Paul DiLascia. 23 | // If not, I don't know who wrote it. 24 | // Compiles with Visual Studio 6.0 and Visual Studio .NET on Windows XP. 25 | // 26 | #define DLLIMPORT __declspec(dllimport) 27 | 28 | DLLIMPORT BOOL DisableTaskKeys(BOOL bEnable, BOOL bBeep); 29 | DLLIMPORT BOOL AreTaskKeysDisabled(); 30 | 31 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/ThreadSDL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_THREAD_SDL_H 21 | #define HPL_THREAD_SDL_H 22 | 23 | #include "system/Thread.h" 24 | 25 | struct SDL_Thread; 26 | 27 | namespace hpl { 28 | 29 | class cThreadSDL : public iThread 30 | { 31 | public: 32 | 33 | cThreadSDL(); 34 | ~cThreadSDL(); 35 | 36 | void Start(); 37 | void Stop(); 38 | void Sleep(unsigned int alSleepTime); 39 | void SetPriority(eThreadPrio aPrio); 40 | 41 | protected: 42 | int TranslateEnginePrio(eThreadPrio aPrio); 43 | 44 | private: 45 | SDL_Thread* mpThreadHandle; 46 | 47 | }; 48 | 49 | }; 50 | #endif // HPL_THREAD_SDL_H 51 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/ThreadWin32.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_THREAD_WIN32_H 21 | #define HPL_THREAD_WIN32_H 22 | 23 | #include "system/Thread.h" 24 | 25 | #include 26 | 27 | namespace hpl { 28 | 29 | class cThreadWin32 : public iThread 30 | { 31 | public: 32 | 33 | cThreadWin32(); 34 | ~cThreadWin32(); 35 | 36 | void Start(); 37 | void Stop(); 38 | void Sleep(unsigned int alSleepTime); 39 | 40 | void SetPriority(eThreadPrio aPrio); 41 | 42 | private: 43 | int TranslateEnginePrio(eThreadPrio aPrio); 44 | HANDLE mpThreadHandle; 45 | 46 | }; 47 | 48 | }; 49 | #endif // HPL_THREAD_WIN32_H 50 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/TimerSDL.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_TIMER_SDL_H 21 | #define HPL_TIMER_SDL_H 22 | 23 | #include "system/Timer.h" 24 | 25 | #ifdef WIN32 // Windows system specific 26 | #include 27 | #else // Unix based system specific 28 | #include 29 | #endif 30 | 31 | namespace hpl { 32 | 33 | class cTimerSDL : public iTimer 34 | { 35 | public: 36 | 37 | cTimerSDL(); 38 | ~cTimerSDL(); 39 | 40 | void Start(); 41 | void Stop(); 42 | 43 | double GetTimeInMicroSec(); 44 | private: 45 | double mfStartTimeInMicroSec; 46 | double mfEndTimeInMicroSec; 47 | bool mbStopped; 48 | 49 | #ifdef WIN32 50 | LARGE_INTEGER mFrequency; 51 | LARGE_INTEGER mStartCount; 52 | LARGE_INTEGER mEndCount; 53 | #else 54 | double mFrequency; 55 | timeval mStartCount; 56 | timeval mEndCount; 57 | #endif 58 | }; 59 | 60 | }; 61 | #endif // HPL_TIMER_SDL_H 62 | -------------------------------------------------------------------------------- /HPL2/core/include/impl/XmlDocumentTiny.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_XML_DOCUMENT_TINY_H 21 | #define HPL_XML_DOCUMENT_TINY_H 22 | 23 | #include "resources/XmlDocument.h" 24 | 25 | class TiXmlDocument; 26 | class TiXmlElement; 27 | 28 | namespace hpl { 29 | 30 | class cXmlDocumentTiny : public iXmlDocument 31 | { 32 | public: 33 | cXmlDocumentTiny(const tString &asName) : iXmlDocument(asName) {} 34 | 35 | void SaveToString(tString *apDestData); 36 | bool CreateFromString(const tString& asData); 37 | 38 | private: 39 | bool LoadDataFromFile(const tWString& asPath); 40 | bool SaveDataToFile(const tWString& asPath); 41 | 42 | void LoadFromTinyXMLData(TiXmlElement* apTinyElem, cXmlElement *apDestElem); 43 | void SaveToTinyXMLData(TiXmlElement* apTinyElem, cXmlElement *apSrcElem); 44 | 45 | bool CreateTinyXMLFromFile(TiXmlDocument* pDoc,const tWString& asPath); 46 | bool SaveTinyXMLToFile(TiXmlDocument* pDoc,const tWString& asPath); 47 | }; 48 | 49 | }; 50 | #endif // HPL_XML_DOCUMENT_TINY_H 51 | -------------------------------------------------------------------------------- /HPL2/core/include/input/ActionGamepadAxis.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_ACTIONGAMEPADAXIS_H 21 | #define HPL_ACTIONGAMEPADAXIS_H 22 | 23 | #include "input/InputTypes.h" 24 | #include "input/Action.h" 25 | 26 | namespace hpl { 27 | 28 | class cInput; 29 | 30 | class cActionGamepadAxis : public iSubAction 31 | { 32 | public: 33 | cActionGamepadAxis(cInput* apInput, int alPadIndex, eGamepadAxis aAxis, eGamepadAxisRange aRange, float afMinThreshold, float afMaxThreshold); 34 | 35 | bool IsTriggerd(); 36 | float GetValue(); 37 | 38 | tString GetInputName(); 39 | 40 | tString GetInputType(){return "GamepadAxis";} 41 | 42 | eGamepadAxis GetAxis() { return mAxis;} 43 | eGamepadAxisRange GetRange() { return mRange; } 44 | private: 45 | int mlPadIndex; 46 | eGamepadAxis mAxis; 47 | eGamepadAxisRange mRange; 48 | 49 | float mfMinThreshold; 50 | float mfMaxThreshold; 51 | cInput *mpInput; 52 | }; 53 | 54 | }; 55 | #endif // HPL_ACTIONGAMEPADAXIS_H 56 | -------------------------------------------------------------------------------- /HPL2/core/include/input/ActionGamepadButton.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_ACTIONGAMEPADBUTTON_H 21 | #define HPL_ACTIONGAMEPADBUTTON_H 22 | 23 | 24 | #include "input/InputTypes.h" 25 | #include "input/Action.h" 26 | 27 | namespace hpl { 28 | 29 | class cInput; 30 | 31 | class cActionGamepadButton : public iSubAction 32 | { 33 | public: 34 | cActionGamepadButton(cInput* apInput, int alPadIndex, eGamepadButton aButton); 35 | 36 | bool IsTriggerd(); 37 | float GetValue(); 38 | 39 | tString GetInputName(); 40 | 41 | tString GetInputType(){return "GamepadButton";} 42 | 43 | eGamepadButton GetButton(){ return mButton;} 44 | private: 45 | int mlPadIndex; 46 | eGamepadButton mButton; 47 | cInput *mpInput; 48 | }; 49 | 50 | }; 51 | #endif // HPL_ACTIONGAMEPADBUTTON_H 52 | -------------------------------------------------------------------------------- /HPL2/core/include/input/ActionGamepadHat.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_ACTIONGAMEPADHAT_H 21 | #define HPL_ACTIONGAMEPADHAT_H 22 | 23 | 24 | #include "input/InputTypes.h" 25 | #include "input/Action.h" 26 | 27 | namespace hpl { 28 | 29 | class cInput; 30 | 31 | class cActionGamepadHat : public iSubAction 32 | { 33 | public: 34 | cActionGamepadHat(cInput* apInput, int alPadIndex, eGamepadHat aHat, eGamepadHatState aHatState); 35 | 36 | bool IsTriggerd(); 37 | float GetValue(); 38 | 39 | tString GetInputName(); 40 | 41 | tString GetInputType(){return "GamepadHat";} 42 | 43 | eGamepadHat GetHat(){ return mHat;} 44 | eGamepadHatState GetHatState(){ return mHatState;} 45 | private: 46 | int mlPadIndex; 47 | eGamepadHat mHat; 48 | eGamepadHatState mHatState; 49 | cInput *mpInput; 50 | }; 51 | 52 | }; 53 | #endif // HPL_ACTIONGAMEPADHAT_H 54 | -------------------------------------------------------------------------------- /HPL2/core/include/input/ActionHaptic.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_ACTION_HAPTIC_H 21 | #define HPL_ACTION_HAPTIC_H 22 | 23 | #include "input/InputTypes.h" 24 | #include "input/Action.h" 25 | #include "haptic/Haptic.h" 26 | 27 | namespace hpl { 28 | 29 | class cHaptic; 30 | 31 | class cActionHaptic : public iSubAction 32 | { 33 | public: 34 | cActionHaptic(cHaptic *apHaptic, int mlButton); 35 | 36 | bool IsTriggerd(); 37 | float GetValue(); 38 | 39 | tString GetInputName(); 40 | 41 | tString GetInputType(){return "HapticDeviceButton";} 42 | 43 | int GetButton(){ return mlButton;} 44 | private: 45 | int mlButton; 46 | cHaptic *mpHaptic; 47 | }; 48 | 49 | }; 50 | #endif // HPL_ACTIONMOUSEBUTTON_H 51 | -------------------------------------------------------------------------------- /HPL2/core/include/input/ActionKeyboard.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_ACTIONKEYBOARD_H 21 | #define HPL_ACTIONKEYBOARD_H 22 | 23 | 24 | #include "input/InputTypes.h" 25 | #include "input/Action.h" 26 | 27 | namespace hpl { 28 | 29 | class cInput; 30 | 31 | class cActionKeyboard : public iSubAction 32 | { 33 | public: 34 | cActionKeyboard(cInput* apInput, eKey mKey); 35 | 36 | bool IsTriggerd(); 37 | float GetValue(); 38 | 39 | tString GetInputName(); 40 | 41 | tString GetInputType(){return "Keyboard";} 42 | 43 | eKey GetKey(){ return mKey;} 44 | 45 | private: 46 | eKey mKey; 47 | cInput *mpInput; 48 | }; 49 | 50 | }; 51 | #endif // HPL_ACTIONKEYBOARD_H 52 | -------------------------------------------------------------------------------- /HPL2/core/include/input/ActionMouseButton.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_ACTIONMOUSEBUTTON_H 21 | #define HPL_ACTIONMOUSEBUTTON_H 22 | 23 | 24 | #include "input/InputTypes.h" 25 | #include "input/Action.h" 26 | 27 | namespace hpl { 28 | 29 | class cInput; 30 | 31 | class cActionMouseButton : public iSubAction 32 | { 33 | public: 34 | cActionMouseButton(cInput* apInput, eMouseButton mButton); 35 | 36 | bool IsTriggerd(); 37 | float GetValue(); 38 | 39 | tString GetInputName(); 40 | 41 | tString GetInputType(){return "MouseButton";} 42 | 43 | eMouseButton GetButton(){ return mButton;} 44 | private: 45 | eMouseButton mButton; 46 | cInput *mpInput; 47 | }; 48 | 49 | }; 50 | #endif // HPL_ACTIONMOUSEBUTTON_H 51 | -------------------------------------------------------------------------------- /HPL2/core/include/input/InputDevice.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_INPUTDEVICE_H 21 | #define HPL_INPUTDEVICE_H 22 | 23 | #include "system/SystemTypes.h" 24 | #include "input/InputTypes.h" 25 | 26 | namespace hpl { 27 | 28 | class iInputDevice 29 | { 30 | public: 31 | iInputDevice(tString asName,eInputDeviceType aType); 32 | virtual ~iInputDevice(){} 33 | 34 | /** 35 | * 36 | * \return name of the device 37 | */ 38 | tString GetName(); 39 | 40 | /** 41 | * 42 | * \return type of device. 43 | */ 44 | eInputDeviceType GetType(); 45 | 46 | /** 47 | * Update the device, called by cInput 48 | */ 49 | virtual void Update()=0; 50 | 51 | private: 52 | tString msName; 53 | eInputDeviceType mType; 54 | }; 55 | 56 | }; 57 | #endif // HPL_INPUTDEVICE_H 58 | -------------------------------------------------------------------------------- /HPL2/core/include/math/Spring.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_SPRING_H 21 | #define HPL_SPRING_H 22 | 23 | #include "math/MathTypes.h" 24 | 25 | namespace hpl { 26 | 27 | template 28 | class cSpring 29 | { 30 | public: 31 | float k; 32 | float b; 33 | 34 | ////////////////////////////////////////// 35 | // Constructors 36 | ///////////////////////////////////////// 37 | cSpring(){} 38 | 39 | cSpring(float afK, float afB) 40 | { 41 | k = afK; b = afB; 42 | } 43 | 44 | ////////////////////////////////////////// 45 | // Public 46 | ///////////////////////////////////////// 47 | 48 | T Output(T aError, T aV) 49 | { 50 | return aError * k - aV * b; 51 | } 52 | }; 53 | 54 | //--------------------------------- 55 | 56 | typedef cSpring cSpringf; 57 | typedef cSpring cSpringVec3; 58 | }; 59 | #endif // HPL_SPRING_H 60 | -------------------------------------------------------------------------------- /HPL2/core/include/physics/CollideData.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_COLLIDE_DATA_H 21 | #define HPL_COLLIDE_DATA_H 22 | 23 | #include "math/MathTypes.h" 24 | #include "system/SystemTypes.h" 25 | 26 | namespace hpl { 27 | 28 | class cCollidePoint 29 | { 30 | public: 31 | cVector3f mvPoint; 32 | cVector3f mvNormal; 33 | float mfDepth; 34 | }; 35 | 36 | typedef std::vector tCollidePointVec; 37 | typedef tCollidePointVec::iterator tCollidePointVecIt; 38 | 39 | class cCollideData 40 | { 41 | public: 42 | tCollidePointVec mvContactPoints; 43 | int mlNumOfPoints; 44 | 45 | void SetMaxSize(int alSize){ 46 | mvContactPoints.resize(alSize); 47 | } 48 | }; 49 | 50 | }; 51 | #endif // HPL_COLLIDE_DATA_H 52 | -------------------------------------------------------------------------------- /HPL2/core/include/physics/LowLevelPhysics.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_LOWLEVELPHYSICS_H 21 | #define HPL_LOWLEVELPHYSICS_H 22 | 23 | #include "system/SystemTypes.h" 24 | #include "math/MathTypes.h" 25 | 26 | namespace hpl { 27 | 28 | class iPhysicsWorld; 29 | 30 | 31 | class iLowLevelPhysics 32 | { 33 | public: 34 | virtual ~iLowLevelPhysics(){} 35 | 36 | virtual iPhysicsWorld* CreateWorld()=0; 37 | }; 38 | }; 39 | #endif // HPL_LOWLEVELPHYSICS_H 40 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/AnimationManager.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_ANIMATION_MANAGER_H 21 | #define HPL_ANIMATION_MANAGER_H 22 | 23 | #include "resources/ResourceManager.h" 24 | 25 | namespace hpl { 26 | 27 | class cGraphics; 28 | class cResources; 29 | class cAnimation; 30 | 31 | class cAnimationManager : public iResourceManager 32 | { 33 | public: 34 | cAnimationManager(cGraphics* apGraphics,cResources *apResources); 35 | ~cAnimationManager(); 36 | 37 | cAnimation* CreateAnimation(const tString& asName); 38 | 39 | void Destroy(iResourceBase* apResource); 40 | void Unload(iResourceBase* apResource); 41 | 42 | private: 43 | cGraphics* mpGraphics; 44 | cResources* mpResources; 45 | }; 46 | 47 | }; 48 | #endif // HPL_ANIMATION_MANAGER_H 49 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/BitmapLoader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_BITMAP_LOADER_H 21 | #define HPL_BITMAP_LOADER_H 22 | 23 | #include "resources/ResourceLoader.h" 24 | 25 | #include "math/MathTypes.h" 26 | #include "graphics/GraphicsTypes.h" 27 | #include "resources/ResourcesTypes.h" 28 | 29 | namespace hpl { 30 | 31 | class iLowLevelGraphics; 32 | class cBitmap; 33 | 34 | class iBitmapLoader : public iResourceLoader 35 | { 36 | friend class cBitmapLoaderHandler; 37 | public: 38 | virtual ~iBitmapLoader() {} 39 | 40 | virtual cBitmap* LoadBitmap(const tWString& asFile, tBitmapLoadFlag aFlags)=0; 41 | virtual bool SaveBitmap(cBitmap* apBitmap,const tWString& asFile, tBitmapLoadFlag aFlags)=0; 42 | 43 | protected: 44 | iLowLevelGraphics *mpLowLevelGraphics; 45 | }; 46 | 47 | }; 48 | #endif // HPL_BITMAP_LOADER_H 49 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/LowLevelResources.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_LOWLEVELRESOURCES_H 21 | #define HPL_LOWLEVELRESOURCES_H 22 | 23 | #include "system/SystemTypes.h" 24 | 25 | namespace hpl { 26 | 27 | class cMeshLoaderHandler; 28 | class cBitmapLoaderHandler; 29 | class cVideoLoaderHandler; 30 | class iXmlDocument; 31 | 32 | class iLowLevelResources 33 | { 34 | public: 35 | virtual ~iLowLevelResources(){} 36 | 37 | virtual void AddBitmapLoaders(cBitmapLoaderHandler* apHandler)=0; 38 | virtual void AddMeshLoaders(cMeshLoaderHandler* apHandler)=0; 39 | virtual void AddVideoLoaders(cVideoLoaderHandler* apHandler)=0; 40 | 41 | virtual iXmlDocument* CreateXmlDocument(const tString& asName="")=0; 42 | }; 43 | }; 44 | #endif // HPL_LOWLEVELRESOURCES_H 45 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/ResourceLoader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_RESOURCE_LOADER_H 21 | #define HPL_RESOURCE_LOADER_H 22 | 23 | #include "system/SystemTypes.h" 24 | #include "resources/ResourcesTypes.h" 25 | 26 | namespace hpl { 27 | 28 | class iResourceLoader 29 | { 30 | friend class iResourceLoaderHandler; 31 | public: 32 | virtual ~iResourceLoader() {} 33 | 34 | bool IsSupported(const tString& asFileExt); 35 | 36 | void AddSupportedExtension(const tString& asExt); 37 | 38 | protected: 39 | tStringList mlstExtensions; 40 | }; 41 | 42 | }; 43 | #endif // HPL_RESOURCE_LOADER_H 44 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/ResourceLoaderHandler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_RESOURCE_LOADER_HANDLER_H 21 | #define HPL_RESOURCE_LOADER_HANDLER_H 22 | 23 | #include "system/SystemTypes.h" 24 | 25 | namespace hpl { 26 | 27 | class iResourceLoader; 28 | 29 | typedef std::list tResourceLoaderList; 30 | typedef tResourceLoaderList::iterator tResourceLoaderListIt; 31 | 32 | //------------------------------------ 33 | 34 | class iResourceLoaderHandler 35 | { 36 | public: 37 | virtual ~iResourceLoaderHandler(); 38 | 39 | void AddLoader(iResourceLoader *apLoader); 40 | 41 | tStringVec* GetSupportedTypes(){ return &mvSupportedTypes;} 42 | 43 | iResourceLoader* GetLoaderForFile(const tString& asFileName); 44 | iResourceLoader* GetLoaderForFile(const tWString& asFileName); 45 | 46 | protected: 47 | virtual void SetupLoader(iResourceLoader *apLoader)=0; 48 | 49 | tStringVec mvSupportedTypes; 50 | 51 | tResourceLoaderList mlstLoaders; 52 | }; 53 | 54 | }; 55 | #endif // HPL_RESOURCE_LOADER_HANDLER_H 56 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/ScriptManager.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_SCRIPT_MANAGER_H 21 | #define HPL_SCRIPT_MANAGER_H 22 | 23 | #include "resources/ResourceManager.h" 24 | 25 | namespace hpl { 26 | 27 | class cSystem; 28 | class cResources; 29 | class iScript; 30 | 31 | class cScriptManager : public iResourceManager 32 | { 33 | public: 34 | cScriptManager(cSystem* apSystem,cResources *apResources); 35 | ~cScriptManager(); 36 | 37 | /** 38 | * Create a new script. 39 | * \param asName name of the script. 40 | * \return 41 | */ 42 | iScript* CreateScript(const tString& asName, tString *apCompileMessages=NULL); 43 | 44 | void Destroy(iResourceBase* apResource); 45 | void Unload(iResourceBase* apResource); 46 | 47 | private: 48 | cSystem* mpSystem; 49 | cResources *mpResources; 50 | }; 51 | 52 | }; 53 | #endif // HPL_SCRIPT_MANAGER_H 54 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/SoundEntityManager.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_SOUND_ENTITY_MANAGER_H 21 | #define HPL_SOUND_ENTITY_MANAGER_H 22 | 23 | #include "resources/ResourceManager.h" 24 | 25 | namespace hpl { 26 | 27 | class cSound; 28 | class cResources; 29 | class cSoundEntityData; 30 | 31 | class cSoundEntityManager : public iResourceManager 32 | { 33 | public: 34 | cSoundEntityManager(cSound* apSound,cResources *apResources); 35 | ~cSoundEntityManager(); 36 | 37 | void Preload(const tString& asFile); 38 | 39 | cSoundEntityData* CreateSoundEntity(const tString& asName); 40 | 41 | void Destroy(iResourceBase* apResource); 42 | void Unload(iResourceBase* apResource); 43 | 44 | private: 45 | cSound* mpSound; 46 | cResources* mpResources; 47 | }; 48 | 49 | }; 50 | #endif // HPL_SOUND_ENTITY_MANAGER_H 51 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/VideoLoader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_VIDEO_LOADER_H 21 | #define HPL_VIDEO_LOADER_H 22 | 23 | #include "resources/ResourceLoader.h" 24 | 25 | namespace hpl { 26 | 27 | class iVideoStream; 28 | class iLowLevelGraphics; 29 | 30 | //---------------------------------------- 31 | 32 | class iVideoLoader : public iResourceLoader 33 | { 34 | friend class cVideoLoaderHandler; 35 | public: 36 | virtual ~iVideoLoader() { } 37 | virtual iVideoStream* LoadVideo(const tWString& asFile)=0; 38 | 39 | protected: 40 | iLowLevelGraphics *mpLowLevelGraphics; 41 | }; 42 | 43 | }; 44 | #endif // HPL_VIDEO_LOADER_H 45 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/VideoLoaderHandler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_VIDEO_LOADER_HANDLER_H 21 | #define HPL_VIDEO_LOADER_HANDLER_H 22 | 23 | #include "resources/ResourceLoaderHandler.h" 24 | 25 | #include "system/SystemTypes.h" 26 | 27 | namespace hpl { 28 | 29 | class cResources; 30 | class cGraphics; 31 | class iVideoStream; 32 | 33 | //-------------------------------- 34 | 35 | class cVideoLoaderHandler : public iResourceLoaderHandler 36 | { 37 | public: 38 | cVideoLoaderHandler(cResources* apResources,cGraphics *apGraphics); 39 | ~cVideoLoaderHandler(); 40 | 41 | iVideoStream* LoadVideo(const tWString& asFile); 42 | 43 | private: 44 | void SetupLoader(iResourceLoader *apLoader); 45 | 46 | cGraphics *mpGraphics; 47 | cResources* mpResources; 48 | }; 49 | 50 | }; 51 | #endif // HPL_VIDEO_LOADER_HANDLER_H 52 | -------------------------------------------------------------------------------- /HPL2/core/include/resources/WorldLoader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_WORLD_LOADER_H 21 | #define HPL_WORLD_LOADER_H 22 | 23 | #include "resources/ResourceLoader.h" 24 | 25 | namespace hpl { 26 | 27 | class cScene; 28 | class cWorld; 29 | class cPhysics; 30 | class cGraphics; 31 | class cResources; 32 | 33 | //---------------------------------------- 34 | 35 | class iWorldLoader : public iResourceLoader 36 | { 37 | friend class cWorldLoaderHandler; 38 | public: 39 | virtual ~iWorldLoader() {} 40 | virtual cWorld* LoadWorld(const tWString& asFile, tWorldLoadFlag aFlags)=0; 41 | 42 | protected: 43 | 44 | cScene *mpScene; 45 | cGraphics *mpGraphics; 46 | cResources *mpResources; 47 | cPhysics *mpPhysics; 48 | }; 49 | 50 | }; 51 | #endif // HPL_MESH_LOADER_H 52 | -------------------------------------------------------------------------------- /HPL2/core/include/scene/LightBox.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_LIGHT_BOX_H 21 | #define HPL_LIGHT_BOX_H 22 | 23 | #include "scene/Light.h" 24 | #include "scene/SceneTypes.h" 25 | 26 | namespace hpl { 27 | 28 | //------------------------------------------ 29 | 30 | class cLightBox : public iLight 31 | { 32 | public: 33 | cLightBox(tString asName, cResources *apResources); 34 | 35 | void SetSize(const cVector3f& avSize); 36 | inline const cVector3f& GetSize(){ return mvSize;} 37 | 38 | void SetBlendFunc(eLightBoxBlendFunc aFunc){ mBlendFunc = aFunc; } 39 | eLightBoxBlendFunc GetBlendFunc(){ return mBlendFunc; } 40 | 41 | bool IsVisible(); 42 | 43 | void SetBoxLightPrio(int alX){ mlBoxLightPrio = alX;} 44 | inline int GetBoxLightPrio()const{ return mlBoxLightPrio;} 45 | 46 | private: 47 | void UpdateBoundingVolume(); 48 | 49 | cVector3f mvSize; 50 | eLightBoxBlendFunc mBlendFunc; 51 | int mlBoxLightPrio; 52 | }; 53 | 54 | }; 55 | #endif // HPL_LIGHT_BOX_H 56 | -------------------------------------------------------------------------------- /HPL2/core/include/scene/LightPoint.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_LIGHT_POINT_H 21 | #define HPL_LIGHT_POINT_H 22 | 23 | #include "scene/Light.h" 24 | 25 | namespace hpl { 26 | 27 | //------------------------------------------ 28 | 29 | class cLightPoint : public iLight 30 | { 31 | #ifdef __GNUC__ 32 | typedef iLight __super; 33 | #endif 34 | public: 35 | cLightPoint(tString asName, cResources *apResources); 36 | 37 | private: 38 | void UpdateBoundingVolume(); 39 | }; 40 | 41 | }; 42 | #endif // HPL_LIGHT_POINT_H 43 | -------------------------------------------------------------------------------- /HPL2/core/include/scene/NodeState.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_NODE_STATE_H 21 | #define HPL_NODE_STATE_H 22 | 23 | #include "math/MathTypes.h" 24 | #include "system/SystemTypes.h" 25 | #include "scene/Node3D.h" 26 | 27 | namespace hpl { 28 | 29 | class cNodeState 30 | { 31 | public: 32 | cNodeState(const tString& asName); 33 | ~cNodeState(); 34 | 35 | private: 36 | }; 37 | 38 | }; 39 | #endif // HPL_NODE_STATE_H 40 | -------------------------------------------------------------------------------- /HPL2/core/include/sound/SoundEnvironment.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_SOUNDENVIRONMENT_H 21 | #define HPL_SOUNDENVIRONMENT_H 22 | 23 | #include "system/String.h" 24 | 25 | namespace hpl 26 | { 27 | class cSoundManager; 28 | 29 | class iSoundEnvironment 30 | { 31 | public: 32 | iSoundEnvironment ( ){} 33 | virtual ~iSoundEnvironment () {} 34 | 35 | virtual bool CreateFromFile(const tString &asFile){ return false;} 36 | 37 | tString& GetName() { return mstrName; } 38 | tString& GetFileName() { return msFileName; } 39 | void SetFileName(const tString & asFileName){ msFileName = asFileName; } 40 | 41 | protected: 42 | tString mstrName; 43 | tString msFileName; 44 | }; 45 | 46 | } 47 | 48 | 49 | #endif // HPL_SOUNDENVIRONMENT_H 50 | 51 | -------------------------------------------------------------------------------- /HPL2/core/include/sound/SoundTypes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_SOUND_TYPES_H 21 | #define HPL_SOUND_TYPES_H 22 | 23 | 24 | namespace hpl { 25 | 26 | //--------------------------------------- 27 | 28 | enum eSoundEntityType 29 | { 30 | eSoundEntityType_Main, 31 | eSoundEntityType_Start, 32 | eSoundEntityType_Stop, 33 | eSoundEntityType_LastEnum 34 | }; 35 | 36 | //--------------------------------------- 37 | 38 | class iSoundEntryCallback 39 | { 40 | public: 41 | virtual ~iSoundEntryCallback() {} 42 | virtual void OnPriorityRelease()=0; 43 | }; 44 | 45 | //--------------------------------------- 46 | }; 47 | 48 | #endif // HPL_SOUND_TYPES_H 49 | -------------------------------------------------------------------------------- /HPL2/core/include/system/Mutex.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_MUTEX_H 21 | #define HPL_MUTEX_H 22 | 23 | 24 | namespace hpl { 25 | 26 | class iMutex 27 | { 28 | public: 29 | iMutex(); 30 | virtual ~iMutex(){} 31 | 32 | virtual bool Lock()=0; 33 | virtual bool Unlock()=0; 34 | 35 | protected: 36 | private: 37 | }; 38 | }; 39 | #endif // HPL_MUTEX_H 40 | -------------------------------------------------------------------------------- /HPL2/core/include/system/System.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_SYSTEM_H 21 | #define HPL_SYSTEM_H 22 | 23 | namespace hpl { 24 | 25 | class iLowLevelSystem; 26 | class cLogicTimer; 27 | 28 | class cSystem 29 | { 30 | public: 31 | cSystem(iLowLevelSystem *apLowLevelSystem); 32 | ~cSystem(); 33 | 34 | iLowLevelSystem* GetLowLevel(); 35 | 36 | /** 37 | * Creates a logic timer. 38 | * \param alUpdatesPerSec Frequency of the timer. 39 | * \return 40 | */ 41 | cLogicTimer * CreateLogicTimer(unsigned int alUpdatesPerSec); 42 | 43 | private: 44 | iLowLevelSystem *mpLowLevelSystem; 45 | }; 46 | 47 | }; 48 | #endif // HPL_SYSTEM_H 49 | -------------------------------------------------------------------------------- /HPL2/core/include/system/Timer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPL_TIMER_H 21 | #define HPL_TIMER_H 22 | 23 | 24 | namespace hpl { 25 | 26 | class iTimer 27 | { 28 | public: 29 | virtual ~iTimer(){} 30 | 31 | virtual void Start()=0; 32 | virtual void Stop()=0; 33 | 34 | virtual double GetTimeInMicroSec()=0; 35 | double GetTimeInMilliSec(){ return GetTimeInMicroSec()* 0.001;} 36 | double GetTimeInSec(){ return GetTimeInMicroSec()* 0.000001;} 37 | }; 38 | 39 | }; 40 | #endif // HPL_TIMER_H 41 | -------------------------------------------------------------------------------- /HPL2/core/sources/BuildID_HPL2_0_Win32.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | #include "./BuildID_HPL2_0.h" 25 | 26 | static char gsBuildID[16] = "20200827145552"; 27 | 28 | const char* GetBuildID_HPL2_0() 29 | { 30 | return gsBuildID; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /HPL2/core/sources/generate/GenerateTypes.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "generate/GenerateTypes.h" 21 | -------------------------------------------------------------------------------- /HPL2/core/sources/graphics/LowLevelGraphics.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "graphics/LowLevelGraphics.h" 21 | 22 | namespace hpl { 23 | 24 | ////////////////////////////////////////////////////////////////////////// 25 | // STATIC DATA 26 | ////////////////////////////////////////////////////////////////////////// 27 | 28 | //----------------------------------------------------------------------- 29 | 30 | bool iLowLevelGraphics::mbForceShaderModel3And4Off = false; 31 | 32 | //----------------------------------------------------------------------- 33 | } 34 | -------------------------------------------------------------------------------- /HPL2/core/sources/impl/SDLFragmentProgram.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "impl/SDLFragmentProgram.h" 21 | 22 | namespace hpl { 23 | 24 | ////////////////////////////////////////////////////////////////////////// 25 | // CONSTRUCTORS 26 | ////////////////////////////////////////////////////////////////////////// 27 | 28 | //----------------------------------------------------------------------- 29 | 30 | cSDLFragmentProgram::cSDLFragmentProgram() 31 | { 32 | } 33 | 34 | cSDLFragmentProgram::~cSDLFragmentProgram() 35 | { 36 | } 37 | 38 | //----------------------------------------------------------------------- 39 | 40 | ////////////////////////////////////////////////////////////////////////// 41 | // PUBLIC METHODS 42 | ////////////////////////////////////////////////////////////////////////// 43 | 44 | //----------------------------------------------------------------------- 45 | 46 | //----------------------------------------------------------------------- 47 | 48 | } 49 | -------------------------------------------------------------------------------- /HPL2/core/sources/impl/SDLVertexProgram.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "impl/SDLVertexProgram.h" 21 | 22 | namespace hpl { 23 | 24 | ////////////////////////////////////////////////////////////////////////// 25 | // CONSTRUCTORS 26 | ////////////////////////////////////////////////////////////////////////// 27 | 28 | //----------------------------------------------------------------------- 29 | 30 | cSDLVertexProgram::cSDLVertexProgram() 31 | { 32 | } 33 | 34 | cSDLVertexProgram::~cSDLVertexProgram() 35 | { 36 | } 37 | 38 | //----------------------------------------------------------------------- 39 | 40 | ////////////////////////////////////////////////////////////////////////// 41 | // PUBLIC METHODS 42 | ////////////////////////////////////////////////////////////////////////// 43 | 44 | //----------------------------------------------------------------------- 45 | 46 | //----------------------------------------------------------------------- 47 | 48 | } 49 | -------------------------------------------------------------------------------- /HPL2/core/sources/math/MathTypes.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "math/MathTypes.h" 21 | 22 | namespace hpl { 23 | template <> 24 | const cMatrixf cMatrixf::Identity(1,0,0,0, 25 | 0,1,0,0, 26 | 0,0,1,0, 27 | 0,0,0,1); 28 | template <> 29 | const cMatrixf cMatrixf::Zero(0,0,0,0, 30 | 0,0,0,0, 31 | 0,0,0,0, 32 | 0,0,0,0); 33 | } 34 | -------------------------------------------------------------------------------- /HPL2/core/sources/math/MeshTypes.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | 21 | -------------------------------------------------------------------------------- /HPL2/core/sources/math/Spring.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "math/Spring.h" 21 | -------------------------------------------------------------------------------- /HPL2/core/sources/physics/PhysicsJointBall.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "physics/PhysicsJointBall.h" 21 | 22 | #include "scene/World.h" 23 | #include "scene/Scene.h" 24 | #include "engine/Engine.h" 25 | 26 | #include "physics/PhysicsBody.h" 27 | #include "physics/PhysicsWorld.h" 28 | 29 | #include "system/LowLevelSystem.h" 30 | 31 | namespace hpl { 32 | 33 | 34 | //----------------------------------------------------------------------- 35 | 36 | 37 | //----------------------------------------------------------------------- 38 | } 39 | -------------------------------------------------------------------------------- /HPL2/core/sources/physics/PhysicsJointHinge.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "physics/PhysicsJointHinge.h" 21 | 22 | #include "scene/World.h" 23 | #include "scene/Scene.h" 24 | #include "engine/Engine.h" 25 | 26 | #include "physics/PhysicsBody.h" 27 | #include "physics/PhysicsWorld.h" 28 | 29 | namespace hpl { 30 | 31 | //----------------------------------------------------------------------- 32 | 33 | 34 | 35 | //----------------------------------------------------------------------- 36 | } 37 | -------------------------------------------------------------------------------- /HPL2/core/sources/physics/PhysicsJointScrew.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "physics/PhysicsJointScrew.h" 21 | 22 | #include "scene/World.h" 23 | #include "scene/Scene.h" 24 | #include "engine/Engine.h" 25 | 26 | #include "physics/PhysicsBody.h" 27 | #include "physics/PhysicsWorld.h" 28 | 29 | namespace hpl { 30 | 31 | //----------------------------------------------------------------------- 32 | 33 | 34 | 35 | //----------------------------------------------------------------------- 36 | } 37 | -------------------------------------------------------------------------------- /HPL2/core/sources/physics/PhysicsJointSlider.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "physics/PhysicsJointSlider.h" 21 | 22 | #include "scene/World.h" 23 | #include "scene/Scene.h" 24 | #include "engine/Engine.h" 25 | 26 | #include "physics/PhysicsBody.h" 27 | #include "physics/PhysicsWorld.h" 28 | 29 | namespace hpl { 30 | 31 | //---------------------------------------------------------------- 32 | 33 | //---------------------------------------------------------------- 34 | } 35 | -------------------------------------------------------------------------------- /HPL2/dependencies.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/HPL2/dependencies.zip -------------------------------------------------------------------------------- /HPL2/tools/HplLangTool/App.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/HPL2/tools/HplLangTool/App.ico -------------------------------------------------------------------------------- /HPL2/tools/HplLangTool/HpLangTool.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 8.00 2 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HplLangTool", "HplLangTool.csproj", "{7277E5EA-18F4-4F4D-BD8F-5F94B90FB52E}" 3 | ProjectSection(ProjectDependencies) = postProject 4 | EndProjectSection 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfiguration) = preSolution 8 | Debug = Debug 9 | Release = Release 10 | EndGlobalSection 11 | GlobalSection(ProjectConfiguration) = postSolution 12 | {7277E5EA-18F4-4F4D-BD8F-5F94B90FB52E}.Debug.ActiveCfg = Debug|.NET 13 | {7277E5EA-18F4-4F4D-BD8F-5F94B90FB52E}.Debug.Build.0 = Debug|.NET 14 | {7277E5EA-18F4-4F4D-BD8F-5F94B90FB52E}.Release.ActiveCfg = Release|.NET 15 | {7277E5EA-18F4-4F4D-BD8F-5F94B90FB52E}.Release.Build.0 = Release|.NET 16 | EndGlobalSection 17 | GlobalSection(ExtensibilityGlobals) = postSolution 18 | EndGlobalSection 19 | GlobalSection(ExtensibilityAddIns) = postSolution 20 | EndGlobalSection 21 | EndGlobal 22 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/Editor.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "../common/Editor.h" 21 | 22 | iEditor::iEditor(const tWString& asName, const tWString& asCaption) : iUpdateable(cString::To8Char(asName)) 23 | { 24 | msName = asName; 25 | msCaption = asCaption; 26 | } 27 | 28 | iEditor::~iEditor(void) 29 | { 30 | } 31 | 32 | void iEditor::SetUpDirectories(void) 33 | { 34 | } 35 | 36 | 37 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/EditorActionArea.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "EditorActionArea.h" 21 | #include "EntityWrapperArea.h" 22 | 23 | cEditorActionAreaSetType::cEditorActionAreaSetType(iEditorWorld* apWorld, int alID, const tString& asType) : iEditorActionWorldModifier("Set area type", apWorld) 24 | { 25 | mlID = alID; 26 | msNewType = asType; 27 | 28 | cEntityWrapperArea* pArea = (cEntityWrapperArea*) apWorld->GetEntity(alID); 29 | msOldType = pArea->GetAreaType(); 30 | pArea->GetClass()->SaveValuesToMap(mmapOldValues); 31 | } 32 | 33 | void cEditorActionAreaSetType::DoModify() 34 | { 35 | cEntityWrapperArea* pArea = (cEntityWrapperArea*) mpEditorWorld->GetEntity(mlID); 36 | pArea->SetAreaType(msNewType); 37 | pArea->GetClass()->LoadValuesFromMap(mmapOldValues); 38 | } 39 | 40 | void cEditorActionAreaSetType::UndoModify() 41 | { 42 | cEntityWrapperArea* pArea = (cEntityWrapperArea*) mpEditorWorld->GetEntity(mlID); 43 | pArea->SetAreaType(msOldType); 44 | pArea->GetClass()->LoadValuesFromMap(mmapOldValues); 45 | } 46 | 47 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/EditorActionDynamicEntity.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "EditorActionDynamicEntity.h" 21 | #include "EntityWrapperEntity.h" 22 | 23 | cEditorActionEntitySetFilename::cEditorActionEntitySetFilename(iEditorWorld* apWorld, int alID, const tString& asX) : iEditorActionWorldModifier("Set entity File", apWorld) 24 | { 25 | mlID = alID; 26 | msNewFile = asX; 27 | 28 | cEntityWrapperEntity* pEnt = (cEntityWrapperEntity*) apWorld->GetEntity(alID); 29 | msOldFile = pEnt->GetFilename(); 30 | pEnt->GetClass()->SaveValuesToMap(mmapOldValues); 31 | } 32 | 33 | void cEditorActionEntitySetFilename::DoModify() 34 | { 35 | Apply(msNewFile); 36 | } 37 | 38 | void cEditorActionEntitySetFilename::UndoModify() 39 | { 40 | Apply(msOldFile); 41 | } 42 | 43 | void cEditorActionEntitySetFilename::Apply(const tString& asX) 44 | { 45 | cEntityWrapperEntity* pEnt = (cEntityWrapperEntity*) mpEditorWorld->GetEntity(mlID); 46 | pEnt->SetFilename(asX); 47 | pEnt->GetClass()->LoadValuesFromMap(mmapOldValues); 48 | 49 | pEnt->UpdateEntity(); 50 | } 51 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/EditorClipPlane.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPLEDITOR_EDITOR_CLIP_PLANE_H 21 | #define HPLEDITOR_EDITOR_CLIP_PLANE_H 22 | 23 | #include "EditorAxisAlignedPlane.h" 24 | 25 | class iEditorWorld; 26 | 27 | 28 | 29 | class cEditorClipPlane : public iEditorAxisAlignedPlane 30 | { 31 | public: 32 | cEditorClipPlane(iEditorWorld* apWorld); 33 | 34 | bool PointIsOnCullingSide(const cVector3f& avPos); 35 | 36 | void SetCullingOnPositiveSide(bool abX); 37 | bool GetCullingOnPositiveSide() { return mbCullingOnPositiveSide; } 38 | 39 | void Draw(cRendererCallbackFunctions* apFunctions, const cVector3f& avPos); 40 | 41 | void SetActive(bool abX); 42 | bool IsActive() { return mbActive; } 43 | 44 | void Load(cXmlElement* apElement); 45 | void Save(cXmlElement* apElement); 46 | 47 | protected: 48 | void OnPlaneModified(); 49 | 50 | iEditorWorld* mpWorld; 51 | bool mbCullingOnPositiveSide; 52 | bool mbActive; 53 | }; 54 | 55 | #endif // HPLEDITOR_EDITOR_CLIP_PLANE_H 56 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/EditorEditModeDummy.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPLEDITOR_EDIT_MODE_DUMMY_H 21 | #define HPLEDITOR_EDIT_MODE_DUMMY_H 22 | 23 | #include "EditorEditMode.h" 24 | 25 | class iEditorBase; 26 | 27 | class cEditorEditModeDummy : public iEditorEditMode 28 | { 29 | public: 30 | cEditorEditModeDummy(iEditorBase* apEditor) : iEditorEditMode(apEditor, "Dummy") {} 31 | }; 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/EditorEditModeFogAreas.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPLEDITOR_EDITOR_EDIT_MODE_FOG_AREAS_H 21 | #define HPLEDITOR_EDITOR_EDIT_MODE_FOG_AREAS_H 22 | 23 | #include "../common/StdAfx.h" 24 | 25 | using namespace hpl; 26 | 27 | #include "EditorEditMode.h" 28 | #include "EditorTypes.h" 29 | 30 | //------------------------------------------------------------------------------ 31 | 32 | class cEditorEditModeFogAreas : public iEditorEditModeObjectCreator 33 | { 34 | public: 35 | cEditorEditModeFogAreas(iEditorBase* apEditor, 36 | iEditorWorld* apEditorWorld); 37 | protected: 38 | bool SetUpCreationData(iEntityWrapperData* apData); 39 | 40 | iEditorWindow* CreateSpecificWindow(); 41 | void CreateTypes(); 42 | }; 43 | 44 | //------------------------------------------------------------------------------ 45 | 46 | #endif //HPLEDITOR_EDITOR_EDIT_MODE_FOG_AREAS_H 47 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/EditorWindowInputWorldName.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPLEDITOR_EDITOR_WINDOW_INPUT_WORLD_NAME_H 21 | #define HPLEDITOR_EDITOR_WINDOW_INPUT_WORLD_NAME_H 22 | 23 | //----------------------------------------------------------------- 24 | 25 | #include "EditorWindow.h" 26 | 27 | //----------------------------------------------------------------- 28 | 29 | class cEditorWindowInputWorldName : public iEditorWindowPopUp 30 | { 31 | public: 32 | cEditorWindowInputWorldName(iEditorBase* apEditor); 33 | ~cEditorWindowInputWorldName(); 34 | protected: 35 | 36 | void OnInitLayout(); 37 | void OnUpdate(); 38 | 39 | bool InputCallback(iWidget* apWidget, const cGuiMessageData& aData); 40 | kGuiCallbackDeclarationEnd(InputCallback); 41 | 42 | cWidgetLabel* mpLabelName; 43 | cWidgetTextBox* mpInputName; 44 | 45 | cWidgetButton* mvButtons[2]; 46 | }; 47 | 48 | //----------------------------------------------------------------- 49 | 50 | #endif // HPLEDITOR_EDITOR_WINDOW_INPUT_WORLD_NAME_H 51 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/EditorWindowSounds.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef HPLEDITOR_EDITOR_WINDOW_SOUNDS_H 21 | #define HPLEDITOR_EDITOR_WINDOW_SOUNDS_H 22 | 23 | #include "EditorWindow.h" 24 | 25 | //---------------------------------------------------------- 26 | 27 | class cEditorEditModeSounds; 28 | 29 | //---------------------------------------------------------- 30 | 31 | class cEditorWindowSounds : public iEditModeObjectCreatorWindow 32 | { 33 | public: 34 | cEditorWindowSounds(cEditorEditModeSounds* apEditMode); 35 | 36 | const tWString& GetSoundFile() { return mpInpSound->GetFullPath(); } 37 | protected: 38 | void OnInit(){} 39 | void OnInitLayout(); 40 | 41 | void OnLoadLevel(){} 42 | void OnUpdate(float afTimeStep){} 43 | 44 | //////////////////////////////////////////////////// 45 | // Data 46 | cEditorInputFile* mpInpSound; 47 | }; 48 | 49 | //---------------------------------------------------------- 50 | 51 | #endif // HPLEDITOR_EDITOR_WINDOW_SOUNDS_H 52 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/EntityWrapperBodyShape.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FrictionalGames/AmnesiaAMachineForPigs/88f378f158cdd702e110335818e3b397e4c14ae2/HPL2/tools/editors/common/EntityWrapperBodyShape.cpp -------------------------------------------------------------------------------- /HPL2/tools/editors/common/StdAfx.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "StdAfx.h" 21 | -------------------------------------------------------------------------------- /HPL2/tools/editors/common/StdAfx.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef EDITOR_STDAFX_H 21 | #define EDITOR_STDAFX_H 22 | 23 | #include "hpl.h" 24 | 25 | #endif // EDITOR_STDAFX_H 26 | -------------------------------------------------------------------------------- /HPL2/tools/editors/leveleditor/BuildID_LevelEditor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | 25 | #ifndef BUILDID_LEVELEDITOR_H 26 | #define BUILDID_LEVELEDITOR_H 27 | 28 | const char* GetBuildID_LevelEditor(); 29 | 30 | 31 | #endif //BUILDID_LEVELEDITOR_H 32 | -------------------------------------------------------------------------------- /HPL2/tools/editors/leveleditor/BuildID_LevelEditor_Win32.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | #include "./BuildID_LevelEditor.h" 25 | 26 | static char gsBuildID[16] = "20111115201641"; 27 | 28 | const char* GetBuildID_LevelEditor() 29 | { 30 | return gsBuildID; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /HPL2/tools/editors/leveleditor/LevelEditorTypes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef LEVEL_EDITOR_TYPES_H 21 | #define LEVEL_EDITOR_TYPES_H 22 | 23 | class cLevelEditorGroup; 24 | 25 | 26 | typedef std::map tGroupMap; 27 | typedef tGroupMap::iterator tGroupMapIt; 28 | 29 | 30 | #endif // LEVEL_EDITOR_TYPES_H 31 | -------------------------------------------------------------------------------- /HPL2/tools/editors/leveleditor/LevelEditorWindow.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef LEVEL_EDITOR_WINDOW_H 21 | #define LEVEL_EDITOR_WINDOW_H 22 | 23 | #include "../common/StdAfx.h" 24 | 25 | using namespace hpl; 26 | 27 | #include "../common/EditorWindow.h" 28 | 29 | //------------------------------------------------------- 30 | 31 | class cLevelEditor; 32 | 33 | //------------------------------------------------------- 34 | 35 | class iLevelEditorWindow : public iEditorWindow 36 | { 37 | public: 38 | iLevelEditorWindow(cLevelEditor* apEditor, const tString& asName); 39 | virtual ~iLevelEditorWindow(); 40 | 41 | protected: 42 | /////////////////////////// 43 | // Own functions 44 | 45 | /////////////////////////// 46 | // Data 47 | cLevelEditor* mpEditor; 48 | }; 49 | 50 | //------------------------------------------------------- 51 | 52 | #endif // LEVEL_EDITOR_WINDOW_H 53 | -------------------------------------------------------------------------------- /HPL2/tools/editors/leveleditor/buildcounterinput.txt: -------------------------------------------------------------------------------- 1 | AppName LevelEditor 2 | OutHeaderPath . 3 | OutSourcePath . -------------------------------------------------------------------------------- /HPL2/tools/editors/leveleditor/leveleditor.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "leveleditor", "leveleditor.vcxproj", "{847113B7-FF3A-43DF-A726-221E2F4AC83C}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release|Win32 = Release|Win32 9 | EndGlobalSection 10 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 11 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Debug|Win32.ActiveCfg = Debug|Win32 12 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Debug|Win32.Build.0 = Debug|Win32 13 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Release|Win32.ActiveCfg = Release|Win32 14 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Release|Win32.Build.0 = Release|Win32 15 | EndGlobalSection 16 | GlobalSection(SolutionProperties) = preSolution 17 | HideSolutionNode = FALSE 18 | EndGlobalSection 19 | EndGlobal 20 | -------------------------------------------------------------------------------- /HPL2/tools/editors/materialeditor/BuildID_MaterialEditor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | 25 | #ifndef BUILDID_MATERIALEDITOR_H 26 | #define BUILDID_MATERIALEDITOR_H 27 | 28 | const char* GetBuildID_MaterialEditor(); 29 | 30 | 31 | #endif //BUILDID_MATERIALEDITOR_H 32 | -------------------------------------------------------------------------------- /HPL2/tools/editors/materialeditor/BuildID_MaterialEditor_Win32.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | #include "./BuildID_MaterialEditor.h" 25 | 26 | static char gsBuildID[16] = "20100917115138"; 27 | 28 | const char* GetBuildID_MaterialEditor() 29 | { 30 | return gsBuildID; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /HPL2/tools/editors/materialeditor/MaterialEditorTypes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef MATERIAL_EDITOR_TYPES_H 21 | #define MATERIAL_EDITOR_TYPES_H 22 | 23 | #endif // MATERIAL_EDITOR_TYPES_H 24 | -------------------------------------------------------------------------------- /HPL2/tools/editors/materialeditor/buildcounterinput.txt: -------------------------------------------------------------------------------- 1 | AppName MaterialEditor 2 | OutHeaderPath . 3 | OutSourcePath . -------------------------------------------------------------------------------- /HPL2/tools/editors/materialeditor/materialeditor.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "materialeditor", "materialeditor.vcxproj", "{847113B7-FF3A-43DF-A726-221E2F4AC83C}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release|Win32 = Release|Win32 9 | EndGlobalSection 10 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 11 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Debug|Win32.ActiveCfg = Debug|Win32 12 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Debug|Win32.Build.0 = Debug|Win32 13 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Release|Win32.ActiveCfg = Release|Win32 14 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Release|Win32.Build.0 = Release|Win32 15 | EndGlobalSection 16 | GlobalSection(SolutionProperties) = preSolution 17 | HideSolutionNode = FALSE 18 | EndGlobalSection 19 | EndGlobal 20 | -------------------------------------------------------------------------------- /HPL2/tools/editors/modeleditor/BuildID_ModelEditor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | 25 | #ifndef BUILDID_MODELEDITOR_H 26 | #define BUILDID_MODELEDITOR_H 27 | 28 | const char* GetBuildID_ModelEditor(); 29 | 30 | 31 | #endif //BUILDID_MODELEDITOR_H 32 | -------------------------------------------------------------------------------- /HPL2/tools/editors/modeleditor/BuildID_ModelEditor_Win32.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | #include "./BuildID_ModelEditor.h" 25 | 26 | static char gsBuildID[16] = "20100917115135"; 27 | 28 | const char* GetBuildID_ModelEditor() 29 | { 30 | return gsBuildID; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /HPL2/tools/editors/modeleditor/ModelEditorMain.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "../common/StdAfx.h" 21 | using namespace hpl; 22 | 23 | #include "ModelEditor.h" 24 | 25 | #ifdef WIN32 26 | #define WIN32_LEAN_AND_MEAN 27 | #include 28 | #endif 29 | 30 | int hplMain(const tString& asCommandLine) 31 | { 32 | ////////////////////////// 33 | // Init BlackBox 34 | #ifdef WIN32 35 | HINSTANCE hBlackBoxLib = LoadLibrary( "BlackBox.dll" ); 36 | #endif 37 | 38 | //cMemoryManager::SetLogCreation(true); 39 | 40 | cModelEditor* pEditor = hplNew(cModelEditor, ()); 41 | 42 | cEngine* pEngine = pEditor->Init(NULL, false); 43 | 44 | pEngine->Run(); 45 | 46 | hplDelete(pEditor); 47 | 48 | DestroyHPLEngine(pEngine); 49 | 50 | cMemoryManager::LogResults(); 51 | 52 | ////////////////////////// 53 | // Exit BlackBox 54 | #ifdef WIN32 55 | if(hBlackBoxLib) FreeLibrary(hBlackBoxLib); 56 | #endif 57 | 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /HPL2/tools/editors/modeleditor/ModelEditorTypes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef MODEL_EDITOR_TYPES_H 21 | #define MODEL_EDITOR_TYPES_H 22 | 23 | enum eModelEditorEditMode 24 | { 25 | eModelEditorEditMode_Select, 26 | eModelEditorEditMode_Bodies, 27 | eModelEditorEditMode_Joints, 28 | eModelEditorEditMode_Lights, 29 | eModelEditorEditMode_Billboards, 30 | eModelEditorEditMode_ParticleSystems, 31 | eModelEditorEditMode_Sounds, 32 | 33 | eModelEditorEditMode_LastEnum, 34 | }; 35 | 36 | //---------------------------------------------------------- 37 | 38 | #endif //MODEL_EDITOR_TYPES_H 39 | -------------------------------------------------------------------------------- /HPL2/tools/editors/modeleditor/buildcounterinput.txt: -------------------------------------------------------------------------------- 1 | AppName ModelEditor 2 | OutHeaderPath . 3 | OutSourcePath . -------------------------------------------------------------------------------- /HPL2/tools/editors/modeleditor/modeleditor.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "modeleditor", "modeleditor.vcxproj", "{847113B7-FF3A-43DF-A726-221E2F4AC83C}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release|Win32 = Release|Win32 9 | EndGlobalSection 10 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 11 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Debug|Win32.ActiveCfg = Debug|Win32 12 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Debug|Win32.Build.0 = Debug|Win32 13 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Release|Win32.ActiveCfg = Release|Win32 14 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Release|Win32.Build.0 = Release|Win32 15 | EndGlobalSection 16 | GlobalSection(SolutionProperties) = preSolution 17 | HideSolutionNode = FALSE 18 | EndGlobalSection 19 | EndGlobal 20 | -------------------------------------------------------------------------------- /HPL2/tools/editors/particleeditor/BuildID_ParticleEditor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | 25 | #ifndef BUILDID_PARTICLEEDITOR_H 26 | #define BUILDID_PARTICLEEDITOR_H 27 | 28 | const char* GetBuildID_ParticleEditor(); 29 | 30 | 31 | #endif //BUILDID_PARTICLEEDITOR_H 32 | -------------------------------------------------------------------------------- /HPL2/tools/editors/particleeditor/BuildID_ParticleEditor_Win32.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | ////////////////////////////////////////////////// 21 | // File autogenerated by buildcounter 22 | // Do not hand edit! (preferably) 23 | ////////////////////////////////////////////////// 24 | #include "./BuildID_ParticleEditor.h" 25 | 26 | static char gsBuildID[16] = "20100917115133"; 27 | 28 | const char* GetBuildID_ParticleEditor() 29 | { 30 | return gsBuildID; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /HPL2/tools/editors/particleeditor/ParticleEditorActions.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "ParticleEditorActions.h" 21 | #include "ParticleEditor.h" 22 | 23 | #include "../common/EditorEditModeSelect.h" 24 | #include "../common/EntityWrapper.h" 25 | 26 | #include "../common/EditorWorld.h" 27 | #include "../common/EditorSelection.h" 28 | 29 | //-------------------------------------------------------------------------------------- 30 | 31 | //-------------------------------------------------------------------------------------- 32 | //-------------------------------------------------------------------------------------- 33 | //-------------------------------------------------------------------------------------- 34 | -------------------------------------------------------------------------------- /HPL2/tools/editors/particleeditor/ParticleEditorMain.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #include "ParticleEditor.h" 21 | 22 | #ifdef WIN32 23 | #define WIN32_LEAN_AND_MEAN 24 | #include 25 | #endif 26 | 27 | 28 | ////////////////////////////////////////////////////////////////////////// 29 | // APP ENTRY POINT 30 | ////////////////////////////////////////////////////////////////////////// 31 | 32 | 33 | int hplMain(const tString& asCommandLine) 34 | { 35 | ////////////////////////// 36 | // Init BlackBox 37 | #ifdef WIN32 38 | HINSTANCE hBlackBoxLib = LoadLibrary( "BlackBox.dll" ); 39 | #endif 40 | 41 | cParticleEditor* pEditor = hplNew(cParticleEditor, ()); 42 | cEngine* pEngine = pEditor->Init(NULL, false); 43 | 44 | pEngine->Run(); 45 | 46 | hplDelete(pEditor); 47 | hplDelete(pEngine); 48 | 49 | cMemoryManager::LogResults(); 50 | 51 | ////////////////////////// 52 | // Exit BlackBox 53 | #ifdef WIN32 54 | if(hBlackBoxLib) FreeLibrary(hBlackBoxLib); 55 | #endif 56 | 57 | return 0; 58 | } 59 | 60 | -------------------------------------------------------------------------------- /HPL2/tools/editors/particleeditor/ParticleEditorTypes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #ifndef LEVEL_EDITOR_TYPES_H 21 | #define LEVEL_EDITOR_TYPES_H 22 | 23 | class cLevelEditorGroup; 24 | 25 | 26 | typedef std::map tGroupMap; 27 | typedef tGroupMap::iterator tGroupMapIt; 28 | 29 | 30 | #endif // LEVEL_EDITOR_TYPES_H 31 | -------------------------------------------------------------------------------- /HPL2/tools/editors/particleeditor/buildcounterinput.txt: -------------------------------------------------------------------------------- 1 | AppName ParticleEditor 2 | OutHeaderPath . 3 | OutSourcePath . -------------------------------------------------------------------------------- /HPL2/tools/editors/particleeditor/particleeditor.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "particleeditor", "particleeditor.vcxproj", "{847113B7-FF3A-43DF-A726-221E2F4AC83C}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release|Win32 = Release|Win32 9 | EndGlobalSection 10 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 11 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Debug|Win32.ActiveCfg = Debug|Win32 12 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Debug|Win32.Build.0 = Debug|Win32 13 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Release|Win32.ActiveCfg = Release|Win32 14 | {847113B7-FF3A-43DF-A726-221E2F4AC83C}.Release|Win32.Build.0 = Release|Win32 15 | EndGlobalSection 16 | GlobalSection(SolutionProperties) = preSolution 17 | HideSolutionNode = FALSE 18 | EndGlobalSection 19 | EndGlobal 20 | -------------------------------------------------------------------------------- /HPL2/tools/mapview/MapView.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #pragma once 21 | -------------------------------------------------------------------------------- /HPL2/tools/mapview/MapView.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MapView", "MapView.vcxproj", "{C6E72C29-38A3-4897-AA05-E87B0323AA71}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release|Win32 = Release|Win32 9 | EndGlobalSection 10 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 11 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.ActiveCfg = Debug|Win32 12 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.Build.0 = Debug|Win32 13 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.ActiveCfg = Release|Win32 14 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.Build.0 = Release|Win32 15 | EndGlobalSection 16 | GlobalSection(SolutionProperties) = preSolution 17 | HideSolutionNode = FALSE 18 | EndGlobalSection 19 | EndGlobal 20 | -------------------------------------------------------------------------------- /HPL2/tools/mapview/MapView.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | 14 | 15 | Source Files 16 | 17 | 18 | Source Files 19 | 20 | 21 | 22 | 23 | Header Files 24 | 25 | 26 | Header Files 27 | 28 | 29 | -------------------------------------------------------------------------------- /HPL2/tools/modelview/ModelView.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #pragma once 21 | -------------------------------------------------------------------------------- /HPL2/tools/modelview/ModelView.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ModelView", "ModelView.vcxproj", "{C6E72C29-38A3-4897-AA05-E87B0323AA71}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release_NoHPLMain|Win32 = Release_NoHPLMain|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.Build.0 = Debug|Win32 14 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release_NoHPLMain|Win32.ActiveCfg = Release|Win32 15 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release_NoHPLMain|Win32.Build.0 = Release|Win32 16 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.ActiveCfg = Release|Win32 17 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.Build.0 = Release|Win32 18 | EndGlobalSection 19 | GlobalSection(SolutionProperties) = preSolution 20 | HideSolutionNode = FALSE 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /HPL2/tools/mshconverter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required (VERSION 2.8) 2 | project(mshconverter) 3 | 4 | include_directories( 5 | ${HPL2_INCLUDE_DIR} 6 | ${DEP_INCLUDE_DIR} 7 | ) 8 | 9 | link_directories( 10 | ${DEP_LIB_DIR} 11 | ) 12 | 13 | AddTestTarget(mshconverter 14 | MshConverter.cpp 15 | MshConverter.h 16 | ) 17 | 18 | # vim: et ts=4 19 | -------------------------------------------------------------------------------- /HPL2/tools/mshconverter/MshConverter.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | -------------------------------------------------------------------------------- /HPL2/tools/mshconverter/MshConverter.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 8.00 2 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MshConverter", "MshConverter.vcproj", "{824433CE-9979-440F-9C99-6DEEE7253EE6}" 3 | ProjectSection(ProjectDependencies) = postProject 4 | EndProjectSection 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfiguration) = preSolution 8 | Debug = Debug 9 | Release = Release 10 | EndGlobalSection 11 | GlobalSection(ProjectConfiguration) = postSolution 12 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Debug.ActiveCfg = Release|Win32 13 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Debug.Build.0 = Release|Win32 14 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Release.ActiveCfg = Release|Win32 15 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Release.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(ExtensibilityGlobals) = postSolution 18 | EndGlobalSection 19 | GlobalSection(ExtensibilityAddIns) = postSolution 20 | EndGlobalSection 21 | EndGlobal 22 | -------------------------------------------------------------------------------- /HPL2/tools/particleview/ParticleView.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | #pragma once 21 | -------------------------------------------------------------------------------- /HPL2/tools/particleview/ParticleView.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ParticleView", "ParticleView.vcxproj", "{C6E72C29-38A3-4897-AA05-E87B0323AA71}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release|Win32 = Release|Win32 9 | EndGlobalSection 10 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 11 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.ActiveCfg = Release|Win32 12 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Debug|Win32.Build.0 = Release|Win32 13 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.ActiveCfg = Release|Win32 14 | {C6E72C29-38A3-4897-AA05-E87B0323AA71}.Release|Win32.Build.0 = Release|Win32 15 | EndGlobalSection 16 | GlobalSection(SolutionProperties) = preSolution 17 | HideSolutionNode = FALSE 18 | EndGlobalSection 19 | EndGlobal 20 | -------------------------------------------------------------------------------- /HPL2/tools/texconverter/TexConverter.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © 2011-2020 Frictional Games 3 | * 4 | * This file is part of Amnesia: A Machine For Pigs. 5 | * 6 | * Amnesia: A Machine For Pigs 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 | * Amnesia: A Machine For Pigs 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 Amnesia: A Machine For Pigs. If not, see . 18 | */ 19 | 20 | -------------------------------------------------------------------------------- /HPL2/tools/texconverter/TexConverter.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 8.00 2 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TexConverter", "TexConverter.vcproj", "{824433CE-9979-440F-9C99-6DEEE7253EE6}" 3 | ProjectSection(ProjectDependencies) = postProject 4 | EndProjectSection 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfiguration) = preSolution 8 | Debug = Debug 9 | Release = Release 10 | EndGlobalSection 11 | GlobalSection(ProjectConfiguration) = postSolution 12 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Debug.ActiveCfg = Release|Win32 13 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Debug.Build.0 = Release|Win32 14 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Release.ActiveCfg = Release|Win32 15 | {824433CE-9979-440F-9C99-6DEEE7253EE6}.Release.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(ExtensibilityGlobals) = postSolution 18 | EndGlobalSection 19 | GlobalSection(ExtensibilityAddIns) = postSolution 20 | EndGlobalSection 21 | EndGlobal 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Amnesia: A Machine For Pigs Source Code 2 | ======================= 3 | 4 | Currently the engine uses fbx sdk 2012 which isn't avalable anymore which means the engine wont compile. If you want to give a shot anyway you can find the sdk here: 5 | https://www.autodesk.com/fbx 6 | 7 | 8 | Other than that, here is almost everything you need to build Amnesia: A Machine For Pigs. Included are project files for Visual Studio 2010 and CMake for Linux & macOS. 9 | 10 | Contributing Code 11 | ----------------- 12 | We encourage everyone to contribute code to this project, so just sign up for a github account, create a fork and hack away at the codebase. 13 | 14 | License Information 15 | ------------------- 16 | All code is under the GPL Version 3 license. Read the LICENSE file for terms of use of the license. 17 | 18 | --------------------------------------------------------------------------------