├── CNAME ├── .gitignore ├── .travis.yml ├── .htmlhintrc ├── database.schema.json ├── game.json ├── game ├── shooter.json ├── sports.json ├── strategy.json ├── puzzle.json ├── adventure.json ├── roleplay.json ├── simulation.json ├── action.json ├── shooter │ ├── tps.json │ └── fps.json ├── simulation │ └── racing.json ├── platformer.json ├── adventure │ ├── puzzleadventure.json │ └── actionadventure.json ├── platformer │ └── puzzleplatform.json └── roleplay │ └── arpg.json ├── tech ├── graphics.json ├── cs.json ├── se.json ├── content.json ├── math.json ├── graphics │ ├── rendering │ │ ├── participating.json │ │ ├── lighting.json │ │ ├── shading.json │ │ ├── texture.json │ │ └── shadow.json │ ├── rendering.json │ ├── scene.json │ ├── api.json │ └── image.json ├── se │ ├── version.json │ ├── design.json │ └── testing.json ├── engine │ ├── unreal.json │ └── unity.json ├── cs │ ├── serialization.json │ ├── security.json │ ├── numerical.json │ ├── os.json │ ├── network.json │ ├── datastruct.json │ └── compression.json ├── tool.json ├── multiplayer.json ├── programming.json └── programming │ └── datatype.json ├── .eslintrc.json ├── tech.json ├── prettify.js ├── package.json ├── LICENSE ├── database.json ├── validate.js ├── graph.schema.json └── README.md /CNAME: -------------------------------------------------------------------------------- 1 | gamextech.org -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /node_modules 2 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: node_js 2 | node_js: 3 | - 15 4 | -------------------------------------------------------------------------------- /.htmlhintrc: -------------------------------------------------------------------------------- 1 | { 2 | "attr-lowercase": [ 3 | "viewBox" 4 | ] 5 | } -------------------------------------------------------------------------------- /database.schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "array", 3 | "items": { 4 | "type": "string" 5 | } 6 | } -------------------------------------------------------------------------------- /game.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Game" 5 | } 6 | ], 7 | "links": [] 8 | } -------------------------------------------------------------------------------- /game/shooter.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Shooter Game", 5 | "link": "https://en.wikipedia.org/wiki/Shooter_game" 6 | } 7 | ], 8 | "links": [ 9 | { 10 | "source": "Game", 11 | "target": "Shooter Game" 12 | } 13 | ] 14 | } -------------------------------------------------------------------------------- /game/sports.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Sports Game", 5 | "link": "https://en.wikipedia.org/wiki/Sports_video_game" 6 | } 7 | ], 8 | "links": [ 9 | { 10 | "source": "Game", 11 | "target": "Sports Game" 12 | } 13 | ] 14 | } -------------------------------------------------------------------------------- /game/strategy.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Strategy Game", 5 | "link": "https://en.wikipedia.org/wiki/Strategy_game" 6 | } 7 | ], 8 | "links": [ 9 | { 10 | "source": "Game", 11 | "target": "Strategy Game" 12 | } 13 | ] 14 | } -------------------------------------------------------------------------------- /game/puzzle.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Puzzle Game", 5 | "abbr": "PUZ", 6 | "link": "https://en.wikipedia.org/wiki/Puzzle_video_game" 7 | } 8 | ], 9 | "links": [ 10 | { 11 | "source": "Game", 12 | "target": "Puzzle Game" 13 | } 14 | ] 15 | } -------------------------------------------------------------------------------- /game/adventure.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Adventure Game", 5 | "abbr": "AVG", 6 | "link": "https://en.wikipedia.org/wiki/Adventure_game" 7 | } 8 | ], 9 | "links": [ 10 | { 11 | "source": "Game", 12 | "target": "Adventure Game" 13 | } 14 | ] 15 | } -------------------------------------------------------------------------------- /game/roleplay.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Role-playing Game", 5 | "abbr": "RPG", 6 | "link": "https://en.wikipedia.org/wiki/Role-playing_game" 7 | } 8 | ], 9 | "links": [ 10 | { 11 | "source": "Game", 12 | "target": "Role-playing Game" 13 | } 14 | ] 15 | } -------------------------------------------------------------------------------- /game/simulation.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Simulation Game", 5 | "abbr": "SIM", 6 | "link": "https://en.wikipedia.org/wiki/Simulation_video_game" 7 | } 8 | ], 9 | "links": [ 10 | { 11 | "source": "Game", 12 | "target": "Simulation Game" 13 | } 14 | ] 15 | } -------------------------------------------------------------------------------- /tech/graphics.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Computer Graphics", 5 | "abbr": "CG", 6 | "link": "https://en.wikipedia.org/wiki/Computer_graphics_(computer_science)" 7 | } 8 | ], 9 | "links": [ 10 | { 11 | "source": "Technology", 12 | "target": "Computer Graphics" 13 | } 14 | ] 15 | } -------------------------------------------------------------------------------- /.eslintrc.json: -------------------------------------------------------------------------------- 1 | { 2 | "env": { 3 | "browser": true, 4 | "commonjs": true, 5 | "es2021": true, 6 | "node": true 7 | }, 8 | "extends": [ 9 | "standard" 10 | ], 11 | "plugins": [ 12 | "html" 13 | ], 14 | "parserOptions": { 15 | "ecmaVersion": 12 16 | }, 17 | "rules": { 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /tech.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Technology" 5 | }, 6 | { 7 | "id": "Audio" 8 | }, 9 | { 10 | "id": "Gameplay" 11 | } 12 | ], 13 | "links": [ 14 | { 15 | "source": "Technology", 16 | "target": "Audio" 17 | }, 18 | { 19 | "source": "Technology", 20 | "target": "Gameplay" 21 | } 22 | ] 23 | } -------------------------------------------------------------------------------- /prettify.js: -------------------------------------------------------------------------------- 1 | const fs = require('fs') 2 | 3 | const prettify = (filename) => { 4 | const src = fs.readFileSync(filename, 'utf8') 5 | const json = JSON.parse(src) 6 | const dst = JSON.stringify(json, null, 2) 7 | if (src !== dst) { 8 | fs.writeFileSync(filename, dst) 9 | console.log(`Prettified ${filename}`) 10 | } 11 | return json 12 | } 13 | 14 | prettify('database.json').forEach(filename => prettify(filename)) 15 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "dependencies": { 3 | "chalk": "latest", 4 | "htmlhint": "^0.14.2", 5 | "jsonschema": "1.4.0" 6 | }, 7 | "scripts": { 8 | "start": "http-server .", 9 | "test": "npx htmlhint && npx eslint *.html *.js && node validate.js" 10 | }, 11 | "devDependencies": { 12 | "eslint": "^7.20.0", 13 | "eslint-config-standard": "^16.0.2", 14 | "eslint-plugin-html": "^6.1.1", 15 | "eslint-plugin-import": "^2.22.1", 16 | "eslint-plugin-node": "^11.1.0", 17 | "eslint-plugin-promise": "^4.3.1" 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /tech/cs.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Computer Science", 5 | "link": "https://en.wikipedia.org/wiki/Computer_science" 6 | }, 7 | { 8 | "id": "Computational Geometry" 9 | }, 10 | { 11 | "id": "Convex Hull", 12 | "link": "https://en.wikipedia.org/wiki/Convex_hull" 13 | } 14 | ], 15 | "links": [ 16 | { 17 | "source": "Technology", 18 | "target": "Computer Science" 19 | }, 20 | { 21 | "source": "Computer Science", 22 | "target": "Computational Geometry" 23 | }, 24 | { 25 | "source": "Computational Geometry", 26 | "target": "Convex Hull" 27 | } 28 | ] 29 | } -------------------------------------------------------------------------------- /game/action.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Action Game", 5 | "abbr": "ACT", 6 | "link": "https://en.wikipedia.org/wiki/Action_game" 7 | }, 8 | { 9 | "id": "For Honor", 10 | "organization": "Ubisoft", 11 | "link": "https://en.wikipedia.org/wiki/For_Honor", 12 | "year": 2017 13 | } 14 | ], 15 | "links": [ 16 | { 17 | "source": "Game", 18 | "target": "Action Game" 19 | }, 20 | { 21 | "source": "Action Game", 22 | "target": "For Honor" 23 | }, 24 | { 25 | "source": "For Honor", 26 | "target": "Motion Matching", 27 | "type": "first-use" 28 | } 29 | ] 30 | } -------------------------------------------------------------------------------- /game/shooter/tps.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Third-person Shooter", 5 | "abbr": "TPS" 6 | }, 7 | { 8 | "id": "Hitman: Codename 47", 9 | "organization": " IO Interactive", 10 | "link": "https://en.wikipedia.org/wiki/Hitman:_Codename_47", 11 | "year": 2000 12 | } 13 | ], 14 | "links": [ 15 | { 16 | "source": "Shooter Game", 17 | "target": "Third-person Shooter" 18 | }, 19 | { 20 | "source": "Third-person Shooter", 21 | "target": "Hitman: Codename 47" 22 | }, 23 | { 24 | "source": "Hitman: Codename 47", 25 | "target": "Hitman Character Physics" 26 | } 27 | ] 28 | } -------------------------------------------------------------------------------- /tech/se.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Software Engineering", 5 | "link": "https://en.wikipedia.org/wiki/Software_engineering" 6 | }, 7 | { 8 | "id": "Debugging", 9 | "link": "https://en.wikipedia.org/wiki/Debugging" 10 | }, 11 | { 12 | "id": "Profiling", 13 | "link": "https://en.wikipedia.org/wiki/Profiling_(computer_programming)" 14 | } 15 | ], 16 | "links": [ 17 | { 18 | "source": "Technology", 19 | "target": "Software Engineering" 20 | }, 21 | { 22 | "source": "Software Engineering", 23 | "target": "Debugging" 24 | }, 25 | { 26 | "source": "Software Engineering", 27 | "target": "Profiling" 28 | } 29 | ] 30 | } -------------------------------------------------------------------------------- /game/simulation/racing.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Racing Game", 5 | "link": "https://en.wikipedia.org/wiki/Racing_game" 6 | }, 7 | { 8 | "id": "Wreckless: The Yakuza Missions", 9 | "aka": "Double S.T.E.A.L.", 10 | "organization": "Bunkasha", 11 | "link": "https://en.wikipedia.org/wiki/Wreckless:_The_Yakuza_Missions", 12 | "year": 2002 13 | } 14 | ], 15 | "links": [ 16 | { 17 | "source": "Simulation Game", 18 | "target": "Racing Game" 19 | }, 20 | { 21 | "source": "Racing Game", 22 | "target": "Wreckless: The Yakuza Missions" 23 | }, 24 | { 25 | "source": "Wreckless: The Yakuza Missions", 26 | "target": "Kawase Blur", 27 | "type": "invent" 28 | } 29 | ] 30 | } -------------------------------------------------------------------------------- /game/platformer.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Platform Game", 5 | "aka": "Platformer", 6 | "link": "https://en.wikipedia.org/wiki/Platform_game" 7 | }, 8 | { 9 | "id": "Shrek", 10 | "organization": "Digital Illusions CE", 11 | "link": [ 12 | "https://sites.google.com/site/richgel99/home", 13 | "https://en.wikipedia.org/wiki/Shrek_(video_game)" 14 | ], 15 | "year": 2001 16 | } 17 | ], 18 | "links": [ 19 | { 20 | "source": "Game", 21 | "target": "Platform Game" 22 | }, 23 | { 24 | "source": "Platform Game", 25 | "target": "Shrek" 26 | }, 27 | { 28 | "source": "Shrek", 29 | "target": "Deferred Shading", 30 | "type": "first-use" 31 | } 32 | ] 33 | } -------------------------------------------------------------------------------- /game/adventure/puzzleadventure.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Puzzle-adventure Game", 5 | "link": "https://en.wikipedia.org/wiki/Puzzle-adventure_game" 6 | }, 7 | { 8 | "id": "Uru: Ages Beyond Myst", 9 | "organization": "Cyan Worlds", 10 | "link": "https://en.wikipedia.org/wiki/Uru:_Ages_Beyond_Myst", 11 | "year": 2003 12 | } 13 | ], 14 | "links": [ 15 | { 16 | "source": "Puzzle Game", 17 | "target": "Puzzle-adventure Game" 18 | }, 19 | { 20 | "source": "Adventure Game", 21 | "target": "Puzzle-adventure Game" 22 | }, 23 | { 24 | "source": "Puzzle-adventure Game", 25 | "target": "Uru: Ages Beyond Myst" 26 | }, 27 | { 28 | "source": "Uru: Ages Beyond Myst", 29 | "target": "Effective Water Simulation", 30 | "type": "use" 31 | } 32 | ] 33 | } -------------------------------------------------------------------------------- /game/platformer/puzzleplatform.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Puzzle-platform Game", 5 | "link": "https://en.wikipedia.org/wiki/Platform_game#Puzzle-platform_game" 6 | }, 7 | { 8 | "id": "Portal", 9 | "organization": "Valve", 10 | "link": "https://en.wikipedia.org/wiki/Portal_(video_game)", 11 | "year": 2007 12 | } 13 | ], 14 | "links": [ 15 | { 16 | "source": "Platform Game", 17 | "target": "Puzzle-platform Game" 18 | }, 19 | { 20 | "source": "Puzzle Game", 21 | "target": "Puzzle-platform Game" 22 | }, 23 | { 24 | "source": "Puzzle-platform Game", 25 | "target": "Portal" 26 | }, 27 | { 28 | "source": "Portal", 29 | "target": "Source" 30 | }, 31 | { 32 | "source": "Portal", 33 | "target": "Orange Box Motion Blur", 34 | "type": "use" 35 | } 36 | ] 37 | } -------------------------------------------------------------------------------- /game/roleplay/arpg.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Action Role-playing Game", 5 | "abbr": "ARPG", 6 | "aka": "Action RPG", 7 | "link": "https://en.wikipedia.org/wiki/Action_role-playing_game" 8 | }, 9 | { 10 | "id": "Final Fantasy XV", 11 | "organization": "Square Enix", 12 | "link": [ 13 | "https://finalfantasyxv.square-enix-games.com/", 14 | "https://en.wikipedia.org/wiki/Final_Fantasy_XV" 15 | ], 16 | "year": 2016 17 | } 18 | ], 19 | "links": [ 20 | { 21 | "source": "Role-playing Game", 22 | "target": "Action Role-playing Game" 23 | }, 24 | { 25 | "source": "Action Role-playing Game", 26 | "target": "Final Fantasy XV" 27 | }, 28 | { 29 | "source": "Final Fantasy XV", 30 | "target": "Final Fantasy XV Character Decision-Making System", 31 | "type": "use" 32 | } 33 | ] 34 | } -------------------------------------------------------------------------------- /game/adventure/actionadventure.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Action-adventure Game", 5 | "link": "https://en.wikipedia.org/wiki/Action-adventure_game" 6 | }, 7 | { 8 | "id": "Alice: Madness Returns", 9 | "organization": "Spicy Horse", 10 | "link": [ 11 | "https://www.ea.com/games/alice/alice-madness-returns", 12 | "https://en.wikipedia.org/wiki/Alice:_Madness_Returns" 13 | ], 14 | "year": 2011 15 | } 16 | ], 17 | "links": [ 18 | { 19 | "source": "Action Game", 20 | "target": "Action-adventure Game" 21 | }, 22 | { 23 | "source": "Adventure Game", 24 | "target": "Action-adventure Game" 25 | }, 26 | { 27 | "source": "Action-adventure Game", 28 | "target": "Alice: Madness Returns" 29 | }, 30 | { 31 | "source": "Alice: Madness Returns", 32 | "target": "Long Range Attachment", 33 | "type": "use" 34 | } 35 | ] 36 | } -------------------------------------------------------------------------------- /tech/content.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Content Creation" 5 | }, 6 | { 7 | "id": "Digital Content Creation", 8 | "abbr": "DCC" 9 | }, 10 | { 11 | "id": "Procedural Content Generation", 12 | "abbr": "PCG" 13 | }, 14 | { 15 | "id": "Photogrammetry" 16 | }, 17 | { 18 | "id": "Motion Capture", 19 | "abbr": "Mocap", 20 | "link": "https://en.wikipedia.org/wiki/Motion_capture" 21 | } 22 | ], 23 | "links": [ 24 | { 25 | "source": "Technology", 26 | "target": "Content Creation" 27 | }, 28 | { 29 | "source": "Content Creation", 30 | "target": "Digital Content Creation" 31 | }, 32 | { 33 | "source": "Content Creation", 34 | "target": "Procedural Content Generation" 35 | }, 36 | { 37 | "source": "Content Creation", 38 | "target": "Photogrammetry" 39 | }, 40 | { 41 | "source": "Content Creation", 42 | "target": "Motion Capture" 43 | } 44 | ] 45 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Milo Yip 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /tech/math.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Mathematics" 5 | }, 6 | { 7 | "id": "Algebra" 8 | }, 9 | { 10 | "id": "Linear Algebra" 11 | }, 12 | { 13 | "id": "Vector" 14 | }, 15 | { 16 | "id": "Matrix" 17 | }, 18 | { 19 | "id": "Quaternion" 20 | }, 21 | { 22 | "id": "Dual Quaternion" 23 | }, 24 | { 25 | "id": "Grasmann Algebra" 26 | }, 27 | { 28 | "id": "Calculus" 29 | }, 30 | { 31 | "id": "Vector Calculus" 32 | }, 33 | { 34 | "id": "Geometry" 35 | } 36 | ], 37 | "links": [ 38 | { 39 | "source": "Technology", 40 | "target": "Mathematics" 41 | }, 42 | { 43 | "source": "Mathematics", 44 | "target": "Algebra" 45 | }, 46 | { 47 | "source": "Algebra", 48 | "target": "Linear Algebra" 49 | }, 50 | { 51 | "source": "Linear Algebra", 52 | "target": "Vector" 53 | }, 54 | { 55 | "source": "Linear Algebra", 56 | "target": "Matrix" 57 | }, 58 | { 59 | "source": "Algebra", 60 | "target": "Grasmann Algebra" 61 | }, 62 | { 63 | "source": "Algebra", 64 | "target": "Quaternion" 65 | }, 66 | { 67 | "source": "Algebra", 68 | "target": "Dual Quaternion" 69 | }, 70 | { 71 | "source": "Mathematics", 72 | "target": "Calculus" 73 | }, 74 | { 75 | "source": "Calculus", 76 | "target": "Vector Calculus" 77 | }, 78 | { 79 | "source": "Mathematics", 80 | "target": "Geometry" 81 | } 82 | ] 83 | } -------------------------------------------------------------------------------- /database.json: -------------------------------------------------------------------------------- 1 | [ 2 | "game.json", 3 | "game/action.json", 4 | "game/adventure/actionadventure.json", 5 | "game/adventure/puzzleadventure.json", 6 | "game/adventure.json", 7 | "game/platformer.json", 8 | "game/platformer/puzzleplatform.json", 9 | "game/puzzle.json", 10 | "game/roleplay.json", 11 | "game/roleplay/arpg.json", 12 | "game/shooter.json", 13 | "game/shooter/fps.json", 14 | "game/shooter/tps.json", 15 | "game/simulation.json", 16 | "game/simulation/racing.json", 17 | "game/sports.json", 18 | "game/strategy.json", 19 | "tech.json", 20 | "tech/ai.json", 21 | "tech/content.json", 22 | "tech/cs.json", 23 | "tech/cs/algorithm.json", 24 | "tech/cs/comparch.json", 25 | "tech/cs/compression.json", 26 | "tech/cs/datastruct.json", 27 | "tech/cs/network.json", 28 | "tech/cs/numerical.json", 29 | "tech/cs/os.json", 30 | "tech/cs/security.json", 31 | "tech/cs/serialization.json", 32 | "tech/engine.json", 33 | "tech/engine/unity.json", 34 | "tech/engine/unreal.json", 35 | "tech/graphics.json", 36 | "tech/graphics/animation.json", 37 | "tech/graphics/api.json", 38 | "tech/graphics/image.json", 39 | "tech/graphics/modeling.json", 40 | "tech/graphics/rendering.json", 41 | "tech/graphics/rendering/camera.json", 42 | "tech/graphics/rendering/lighting.json", 43 | "tech/graphics/rendering/material.json", 44 | "tech/graphics/rendering/participating.json", 45 | "tech/graphics/rendering/shading.json", 46 | "tech/graphics/rendering/shadow.json", 47 | "tech/graphics/rendering/texture.json", 48 | "tech/graphics/scene.json", 49 | "tech/hci.json", 50 | "tech/math.json", 51 | "tech/multiplayer.json", 52 | "tech/physics.json", 53 | "tech/platform.json", 54 | "tech/programming.json", 55 | "tech/programming/datatype.json", 56 | "tech/se.json", 57 | "tech/se/design.json", 58 | "tech/se/pattern.json", 59 | "tech/se/testing.json", 60 | "tech/se/version.json", 61 | "tech/tool.json" 62 | ] -------------------------------------------------------------------------------- /tech/graphics/rendering/participating.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Participating Media Rendering" 5 | }, 6 | { 7 | "id": "Fog Rendering" 8 | }, 9 | { 10 | "id": "Distance Fog", 11 | "link": "https://en.wikipedia.org/wiki/Distance_fog" 12 | }, 13 | { 14 | "id": "Height Fog" 15 | }, 16 | { 17 | "id": "Volumetric Fog" 18 | }, 19 | { 20 | "id": "Atmosphere Rendering" 21 | }, 22 | { 23 | "id": "Cloud Rendering" 24 | }, 25 | { 26 | "id": "Volume Rendering", 27 | "link": "https://en.wikipedia.org/wiki/Volume_rendering" 28 | }, 29 | { 30 | "id": "Structured Volume Sampling", 31 | "author": [ 32 | "Huw Bowles", 33 | "Daniel Zimmermann", 34 | "Beibei Wang" 35 | ], 36 | "title": "A Novel Sampling Algorithm for Fast and Stable Real-Time Volume Rendering", 37 | "conference": "SIGGRAPH", 38 | "link": [ 39 | "http://advances.realtimerendering.com/s2015/siggraph15_volsampling.pptx", 40 | "https://github.com/huwb/volsample" 41 | ], 42 | "year": 2015 43 | } 44 | ], 45 | "links": [ 46 | { 47 | "source": "Rendering", 48 | "target": "Participating Media Rendering" 49 | }, 50 | { 51 | "source": "Participating Media Rendering", 52 | "target": "Fog Rendering" 53 | }, 54 | { 55 | "source": "Fog Rendering", 56 | "target": "Distance Fog" 57 | }, 58 | { 59 | "source": "Fog Rendering", 60 | "target": "Height Fog" 61 | }, 62 | { 63 | "source": "Fog Rendering", 64 | "target": "Volumetric Fog" 65 | }, 66 | { 67 | "source": "Participating Media Rendering", 68 | "target": "Atmosphere Rendering" 69 | }, 70 | { 71 | "source": "Participating Media Rendering", 72 | "target": "Cloud Rendering" 73 | }, 74 | { 75 | "source": "Participating Media Rendering", 76 | "target": "Volume Rendering" 77 | }, 78 | { 79 | "source": "Volume Rendering", 80 | "target": "Structured Volume Sampling" 81 | } 82 | ] 83 | } -------------------------------------------------------------------------------- /tech/se/version.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Version Control", 5 | "link": "https://en.wikipedia.org/wiki/Version_control" 6 | }, 7 | { 8 | "id": "Perforce Helix Core", 9 | "abbr": "P4", 10 | "organization": "Perforce", 11 | "link": [ 12 | "https://www.perforce.com/products/helix-core", 13 | "https://en.wikipedia.org/wiki/Perforce#Helix_Core" 14 | ], 15 | "year": 1995 16 | }, 17 | { 18 | "id": "Apache Subversion", 19 | "abbr": "SVN", 20 | "organization": "Apache", 21 | "link": [ 22 | "https://subversion.apache.org/", 23 | "https://en.wikipedia.org/wiki/Apache_Subversion" 24 | ], 25 | "year": 2000 26 | }, 27 | { 28 | "id": "TortoiseSVN", 29 | "author": "Tim Kemp", 30 | "link": [ 31 | "https://tortoisesvn.net/", 32 | "https://en.wikipedia.org/wiki/TortoiseSVN" 33 | ], 34 | "year": 2002 35 | }, 36 | { 37 | "id": "Git", 38 | "author": "Linus Torvalds", 39 | "link": [ 40 | "https://git-scm.com/", 41 | "https://en.wikipedia.org/wiki/Git" 42 | ], 43 | "year": 2005 44 | }, 45 | { 46 | "id": "TortoiseGit", 47 | "link": [ 48 | "https://tortoisegit.org/", 49 | "https://en.wikipedia.org/wiki/TortoiseGit" 50 | ], 51 | "year": 2008 52 | }, 53 | { 54 | "id": "Git Large File Storage", 55 | "abbr": "git-lfs", 56 | "link": [ 57 | "https://git-lfs.github.com/", 58 | "https://github.com/git-lfs/git-lfs" 59 | ], 60 | "year": 2013 61 | } 62 | ], 63 | "links": [ 64 | { 65 | "source": "Software Engineering", 66 | "target": "Version Control" 67 | }, 68 | { 69 | "source": "Version Control", 70 | "target": "Perforce Helix Core" 71 | }, 72 | { 73 | "source": "Version Control", 74 | "target": "Apache Subversion" 75 | }, 76 | { 77 | "source": "Apache Subversion", 78 | "target": "TortoiseSVN" 79 | }, 80 | { 81 | "source": "Version Control", 82 | "target": "Git" 83 | }, 84 | { 85 | "source": "Git", 86 | "target": "TortoiseGit" 87 | }, 88 | { 89 | "source": "Git", 90 | "target": "Git Large File Storage" 91 | } 92 | ] 93 | } -------------------------------------------------------------------------------- /validate.js: -------------------------------------------------------------------------------- 1 | const fs = require('fs') 2 | const chalk = require('chalk') 3 | const validate = require('jsonschema').validate 4 | 5 | const graphSchema = JSON.parse(fs.readFileSync('graph.schema.json', 'utf8')) 6 | const databaseSchema = JSON.parse(fs.readFileSync('database.schema.json', 'utf8')) 7 | 8 | process.exitCode = 0 9 | 10 | const logOk = (s) => console.log(chalk.green(s)) 11 | const logErr = (s) => { console.log(chalk.red(s)); process.exitCode = 1 } 12 | 13 | // Load and validate database 14 | const database = (() => { 15 | const filename = 'database.json' 16 | const database = JSON.parse(fs.readFileSync(filename, 'utf8')) 17 | const result = validate(database, databaseSchema) 18 | if (result.valid) { logOk(`Validate ${filename} OK.`) } else { logErr(`Validation ${filename} FAIL: ${result.errors}`) } 19 | return database 20 | })() 21 | 22 | // Terminate if database is invalid 23 | if (process.exitCode !== 0) { process.exit() } 24 | 25 | // Load and validate graphs in database 26 | const nodeIds = new Map() // maps node id to filename 27 | const links = new Map() // maps link to filename 28 | database.forEach(filename => { 29 | const graph = JSON.parse(fs.readFileSync(filename, 'utf8')) 30 | const result = validate(graph, graphSchema) 31 | if (result.valid) { logOk(`Validate ${filename} OK.`) } else { logErr(`Validation ${filename} FAIL: ${result.errors}`) } 32 | 33 | // Check if node ID is duplicated 34 | graph.nodes.forEach(n => { 35 | if (nodeIds.has(n.id)) { logErr(`Node "${n.id}" is duplicated in ${filename}.`) } else { nodeIds.set(n.id, filename) } 36 | }) 37 | 38 | // Check if links are duplicated 39 | graph.links.forEach(l => { 40 | if (links.has(l)) { logErr(`Link "${l}" is duplicated in ${filename}.`) } else { links.set(l, filename) } 41 | }) 42 | }) 43 | 44 | // Check if node id in links exist 45 | const linkedNodeIds = new Set() // and finding isolated nodes 46 | links.forEach((filename, l) => { 47 | if (!nodeIds.has(l.source)) { logErr(`Source node "${l.source}" does not exists in a link in ${filename}.`) } else { linkedNodeIds.add(l.source) } 48 | 49 | if (!nodeIds.has(l.target)) { logErr(`Target node "${l.target}" does not exists in a link in ${filename}.`) } else { linkedNodeIds.add(l.target) } 50 | }) 51 | 52 | nodeIds.forEach((filename, id) => { 53 | if (!linkedNodeIds.has(id)) { logErr(`Node "${id}" in ${filename} is isolated.`) } 54 | }) 55 | -------------------------------------------------------------------------------- /tech/graphics/rendering.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Rendering" 5 | }, 6 | { 7 | "id": "Non-Photorealistic Rendering", 8 | "abbr": "NPR" 9 | }, 10 | { 11 | "id": "Visibility" 12 | }, 13 | { 14 | "id": "Rasterization Stage Visibility" 15 | }, 16 | { 17 | "id": "Application Stage Visibility" 18 | }, 19 | { 20 | "id": "Back-face Culling" 21 | }, 22 | { 23 | "id": "Z-buffer" 24 | }, 25 | { 26 | "id": "Occlusion Query" 27 | }, 28 | { 29 | "id": "View Frustum Culling" 30 | }, 31 | { 32 | "id": "Occlusion Culling" 33 | }, 34 | { 35 | "id": "Contribution Culling" 36 | }, 37 | { 38 | "id": "Potentially Visible Set", 39 | "abbr": "PVS" 40 | } 41 | ], 42 | "links": [ 43 | { 44 | "source": "Computer Graphics", 45 | "target": "Rendering" 46 | }, 47 | { 48 | "source": "Rendering", 49 | "target": "Lighting" 50 | }, 51 | { 52 | "source": "Rendering", 53 | "target": "Image Processing" 54 | }, 55 | { 56 | "source": "Rendering", 57 | "target": "Non-Photorealistic Rendering" 58 | }, 59 | { 60 | "source": "Rendering", 61 | "target": "Visibility" 62 | }, 63 | { 64 | "source": "Visibility", 65 | "target": "Rasterization Stage Visibility" 66 | }, 67 | { 68 | "source": "Rasterization Stage Visibility", 69 | "target": "Back-face Culling" 70 | }, 71 | { 72 | "source": "Rasterization Stage Visibility", 73 | "target": "Z-buffer" 74 | }, 75 | { 76 | "source": "Rasterization Stage Visibility", 77 | "target": "Occlusion Query" 78 | }, 79 | { 80 | "source": "Visibility", 81 | "target": "Application Stage Visibility" 82 | }, 83 | { 84 | "source": "Application Stage Visibility", 85 | "target": "View Frustum Culling" 86 | }, 87 | { 88 | "source": "Application Stage Visibility", 89 | "target": "Occlusion Culling" 90 | }, 91 | { 92 | "source": "Application Stage Visibility", 93 | "target": "Contribution Culling" 94 | }, 95 | { 96 | "source": "Application Stage Visibility", 97 | "target": "Potentially Visible Set" 98 | } 99 | ] 100 | } -------------------------------------------------------------------------------- /game/shooter/fps.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "First-person Shooter", 5 | "abbr": "FPS" 6 | }, 7 | { 8 | "id": "Doom", 9 | "organization": "id Software", 10 | "link": "https://en.wikipedia.org/wiki/Doom_(1993_video_game)", 11 | "year": 1993 12 | }, 13 | { 14 | "id": "Quake", 15 | "organization": "id Software", 16 | "link": "https://en.wikipedia.org/wiki/Quake_(video_game)", 17 | "year": 1996 18 | }, 19 | { 20 | "id": "Half-Life 2", 21 | "organization": "Valve", 22 | "link": "https://en.wikipedia.org/wiki/Half-Life_2", 23 | "year": 2004 24 | }, 25 | { 26 | "id": "Halo 2", 27 | "organization": "Bungie", 28 | "link": "https://en.wikipedia.org/wiki/Halo_2", 29 | "year": 2004 30 | }, 31 | { 32 | "id": "F.E.A.R.", 33 | "organization": "Monolith Productions", 34 | "link": "https://en.wikipedia.org/wiki/F.E.A.R._(video_game)", 35 | "year": 2005 36 | } 37 | ], 38 | "links": [ 39 | { 40 | "source": "Shooter Game", 41 | "target": "First-person Shooter" 42 | }, 43 | { 44 | "source": "First-person Shooter", 45 | "target": "Doom" 46 | }, 47 | { 48 | "source": "Doom", 49 | "target": "Doom Engine", 50 | "type": "use" 51 | }, 52 | { 53 | "source": "First-person Shooter", 54 | "target": "Quake" 55 | }, 56 | { 57 | "source": "Quake", 58 | "target": "Quake Engine", 59 | "type": "first-use" 60 | }, 61 | { 62 | "source": "Quake", 63 | "target": "Light Map", 64 | "type": "first-use" 65 | }, 66 | { 67 | "source": "First-person Shooter", 68 | "target": "Half-Life 2" 69 | }, 70 | { 71 | "source": "Half-Life 2", 72 | "target": "Source", 73 | "type": "use" 74 | }, 75 | { 76 | "source": "Half-Life 2", 77 | "target": "Radiosity Normal Mapping", 78 | "type": "first-use" 79 | }, 80 | { 81 | "source": "First-person Shooter", 82 | "target": "Halo 2" 83 | }, 84 | { 85 | "source": "Halo 2", 86 | "target": "Halo 2 Behavior DAG", 87 | "type": "first-use" 88 | }, 89 | { 90 | "source": "First-person Shooter", 91 | "target": "F.E.A.R." 92 | }, 93 | { 94 | "source": "F.E.A.R.", 95 | "target": "Goal-Oriented Action Planning", 96 | "type": "first-use" 97 | } 98 | ] 99 | } -------------------------------------------------------------------------------- /tech/engine/unreal.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Unreal Engine", 5 | "abbr": "UE", 6 | "organization": "Epic Games", 7 | "link": [ 8 | "https://www.unrealengine.com/", 9 | "https://en.wikipedia.org/wiki/Unreal_Engine" 10 | ], 11 | "year": 1998 12 | }, 13 | { 14 | "id": "Unreal Engine 2", 15 | "abbr": "UE2", 16 | "organization": "Epic Games", 17 | "link": [ 18 | "https://www.unrealengine.com/", 19 | "https://en.wikipedia.org/wiki/Unreal_Engine" 20 | ], 21 | "year": 2002 22 | }, 23 | { 24 | "id": "Unreal Engine 3", 25 | "abbr": "UE3", 26 | "organization": "Epic Games", 27 | "link": [ 28 | "https://www.unrealengine.com/", 29 | "https://en.wikipedia.org/wiki/Unreal_Engine" 30 | ], 31 | "year": 2006 32 | }, 33 | { 34 | "id": "Unreal Engine 4", 35 | "abbr": "UE4", 36 | "organization": "Epic Games", 37 | "link": [ 38 | "https://www.unrealengine.com/", 39 | "https://en.wikipedia.org/wiki/Unreal_Engine" 40 | ], 41 | "year": 2014 42 | }, 43 | { 44 | "id": "Unreal Motion Graphics", 45 | "abbr": "UMG", 46 | "organization": "Epic Games", 47 | "link": "https://docs.unrealengine.com/en-US/InteractiveExperiences/UMG/index.html", 48 | "year": 2014 49 | }, 50 | { 51 | "id": "Unreal Engine 5", 52 | "abbr": "UE5", 53 | "organization": "Epic Games", 54 | "link": [ 55 | "https://www.unrealengine.com/", 56 | "https://en.wikipedia.org/wiki/Unreal_Engine" 57 | ], 58 | "year": 2021 59 | } 60 | ], 61 | "links": [ 62 | { 63 | "source": "Commercial Game Engine", 64 | "target": "Unreal Engine" 65 | }, 66 | { 67 | "source": "Unreal Engine", 68 | "target": "Unreal Engine 2", 69 | "type": "derive" 70 | }, 71 | { 72 | "source": "Unreal Engine 2", 73 | "target": "Unreal Engine 3", 74 | "type": "derive" 75 | }, 76 | { 77 | "source": "Unreal Engine 3", 78 | "target": "Unreal Engine 4", 79 | "type": "derive" 80 | }, 81 | { 82 | "source": "Unreal Engine 4", 83 | "target": "Unreal Motion Graphics" 84 | }, 85 | { 86 | "source": "Unreal Engine 4", 87 | "target": "Blueprint" 88 | }, 89 | { 90 | "source": "Unreal Engine 4", 91 | "target": "Unreal Engine 5", 92 | "type": "derive" 93 | } 94 | ] 95 | } -------------------------------------------------------------------------------- /tech/cs/serialization.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Serialization", 5 | "link": "https://en.wikipedia.org/wiki/Serialization" 6 | }, 7 | { 8 | "id": "Extensible Markup Language", 9 | "abbr": "XML", 10 | "link": [ 11 | "https://www.w3.org/TR/xml11/", 12 | "https://en.wikipedia.org/wiki/XML" 13 | ], 14 | "year": 1998 15 | }, 16 | { 17 | "id": "YAML", 18 | "author": [ 19 | "Clark Evans", 20 | "Ingy döt Net", 21 | "Oren Ben-Kiki" 22 | ], 23 | "link": "https://en.wikipedia.org/wiki/YAML", 24 | "year": 2001 25 | }, 26 | { 27 | "id": "JavaScript Object Notation", 28 | "abbr": "JSON", 29 | "author": "Douglas Crockford", 30 | "link": [ 31 | "https://www.json.org/", 32 | "https://www.ecma-international.org/publications-and-standards/standards/ecma-404/", 33 | "https://en.wikipedia.org/wiki/JSON" 34 | ], 35 | "year": 2006 36 | }, 37 | { 38 | "id": "Protocol Buffers", 39 | "abbr": "protobuf", 40 | "organization": "Google", 41 | "link": [ 42 | "https://developers.google.com/protocol-buffers/", 43 | "https://github.com/protocolbuffers/protobuf", 44 | "https://en.wikipedia.org/wiki/Protocol_Buffers" 45 | ], 46 | "year": 2008 47 | }, 48 | { 49 | "id": "MessagePack", 50 | "author": "Sadayuki Furuhashi", 51 | "link": [ 52 | "https://msgpack.org/", 53 | "https://github.com/msgpack", 54 | "https://en.wikipedia.org/wiki/MessagePack" 55 | ], 56 | "year": 2013 57 | }, 58 | { 59 | "id": "FlatBuffers", 60 | "author": "Wouter van Oortmerssen", 61 | "link": [ 62 | "https://google.github.io/flatbuffers/", 63 | "https://github.com/google/flatbuffers", 64 | "https://en.wikipedia.org/wiki/FlatBuffers" 65 | ], 66 | "year": 2014 67 | } 68 | ], 69 | "links": [ 70 | { 71 | "source": "Computer Science", 72 | "target": "Serialization" 73 | }, 74 | { 75 | "source": "Serialization", 76 | "target": "Extensible Markup Language" 77 | }, 78 | { 79 | "source": "Serialization", 80 | "target": "YAML" 81 | }, 82 | { 83 | "source": "Serialization", 84 | "target": "JavaScript Object Notation" 85 | }, 86 | { 87 | "source": "Serialization", 88 | "target": "Protocol Buffers" 89 | }, 90 | { 91 | "source": "Serialization", 92 | "target": "MessagePack" 93 | }, 94 | { 95 | "source": "Serialization", 96 | "target": "FlatBuffers" 97 | } 98 | ] 99 | } -------------------------------------------------------------------------------- /graph.schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "string_or_array_of_string": { 4 | "anyOf": [ 5 | { 6 | "type": "string" 7 | }, 8 | { 9 | "type": "array", 10 | "items": { 11 | "type": "string" 12 | } 13 | } 14 | ] 15 | } 16 | }, 17 | "type": "object", 18 | "properties": { 19 | "nodes": { 20 | "type": "array", 21 | "items": { 22 | "type": "object", 23 | "properties": { 24 | "id": { 25 | "type": "string" 26 | }, 27 | "abbr": { 28 | "$ref": "#/definitions/string_or_array_of_string" 29 | }, 30 | "aka": { 31 | "$ref": "#/definitions/string_or_array_of_string" 32 | }, 33 | "type": { 34 | "type": "string", 35 | "enum": [ 36 | "category", 37 | "technique", 38 | "game" 39 | ] 40 | }, 41 | "publicaiton": { 42 | "type": "string" 43 | }, 44 | "year": { 45 | "type": "integer" 46 | }, 47 | "synopsis": { 48 | "type": "string" 49 | }, 50 | "author": { 51 | "$ref": "#/definitions/string_or_array_of_string" 52 | }, 53 | "link": { 54 | "$ref": "#/definitions/string_or_array_of_string" 55 | }, 56 | "title": { 57 | "type": "string" 58 | }, 59 | "conference": { 60 | "type": "string" 61 | }, 62 | "journal": { 63 | "type": "string" 64 | }, 65 | "organization": { 66 | "$ref": "#/definitions/string_or_array_of_string" 67 | }, 68 | "contributor": { 69 | "$ref": "#/definitions/string_or_array_of_string" 70 | } 71 | }, 72 | "additionalProperties": false, 73 | "required": [ 74 | "id" 75 | ] 76 | } 77 | }, 78 | "links": { 79 | "type": "array", 80 | "items": { 81 | "type": "object", 82 | "properties": { 83 | "source": { 84 | "type": "string" 85 | }, 86 | "target": { 87 | "type": "string" 88 | }, 89 | "type": { 90 | "type": "string", 91 | "enum": [ 92 | "include", 93 | "derive", 94 | "use", 95 | "first-use", 96 | "invent" 97 | ] 98 | } 99 | }, 100 | "additionalProperties": false, 101 | "required": [ 102 | "source", 103 | "target" 104 | ] 105 | } 106 | } 107 | }, 108 | "additionalProperties": false, 109 | "required": [ 110 | "nodes", 111 | "links" 112 | ] 113 | } -------------------------------------------------------------------------------- /tech/engine/unity.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Unity", 5 | "organization": "Unity Technologies", 6 | "link": [ 7 | "https://unity.com/", 8 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 9 | ], 10 | "year": 2005 11 | }, 12 | { 13 | "id": "Unity 2", 14 | "organization": "Unity Technologies", 15 | "link": [ 16 | "https://unity.com/", 17 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 18 | ], 19 | "year": 2007 20 | }, 21 | { 22 | "id": "Unity 3", 23 | "organization": "Unity Technologies", 24 | "link": [ 25 | "https://unity.com/", 26 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 27 | ], 28 | "year": 2010 29 | }, 30 | { 31 | "id": "Unity 4", 32 | "organization": "Unity Technologies", 33 | "link": [ 34 | "https://unity.com/", 35 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 36 | ], 37 | "year": 2012 38 | }, 39 | { 40 | "id": "Unity 5", 41 | "organization": "Unity Technologies", 42 | "link": [ 43 | "https://unity.com/", 44 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 45 | ], 46 | "year": 2015 47 | }, 48 | { 49 | "id": "Unity 2017", 50 | "organization": "Unity Technologies", 51 | "link": [ 52 | "https://unity.com/", 53 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 54 | ], 55 | "year": 2017 56 | }, 57 | { 58 | "id": "Unity 2018", 59 | "organization": "Unity Technologies", 60 | "link": [ 61 | "https://unity.com/", 62 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 63 | ], 64 | "year": 2018 65 | }, 66 | { 67 | "id": "Unity 2019", 68 | "organization": "Unity Technologies", 69 | "link": [ 70 | "https://unity.com/", 71 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 72 | ], 73 | "year": 2019 74 | }, 75 | { 76 | "id": "Unity UI", 77 | "aka": "uGUI", 78 | "organization": "Unity Technologies", 79 | "link": "https://docs.unity3d.com/Manual/com.unity.ugui.html", 80 | "year": 2019 81 | }, 82 | { 83 | "id": "Unity 2020", 84 | "organization": "Unity Technologies", 85 | "link": [ 86 | "https://unity.com/", 87 | "https://en.wikipedia.org/wiki/Unity_(game_engine)" 88 | ], 89 | "year": 2020 90 | } 91 | ], 92 | "links": [ 93 | { 94 | "source": "Commercial Game Engine", 95 | "target": "Unity" 96 | }, 97 | { 98 | "source": "Unity", 99 | "target": "Unity 2", 100 | "type": "derive" 101 | }, 102 | { 103 | "source": "Unity 2", 104 | "target": "Unity 3", 105 | "type": "derive" 106 | }, 107 | { 108 | "source": "Unity 3", 109 | "target": "Unity 4", 110 | "type": "derive" 111 | }, 112 | { 113 | "source": "Unity 4", 114 | "target": "Unity 5", 115 | "type": "derive" 116 | }, 117 | { 118 | "source": "Unity 5", 119 | "target": "Unity 2017", 120 | "type": "derive" 121 | }, 122 | { 123 | "source": "Unity 2017", 124 | "target": "Unity 2018", 125 | "type": "derive" 126 | }, 127 | { 128 | "source": "Unity 2018", 129 | "target": "Unity 2019", 130 | "type": "derive" 131 | }, 132 | { 133 | "source": "Unity 2019", 134 | "target": "Unity UI" 135 | }, 136 | { 137 | "source": "Unity 2019", 138 | "target": "Unity 2020", 139 | "type": "derive" 140 | } 141 | ] 142 | } -------------------------------------------------------------------------------- /tech/graphics/scene.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Scene Management" 5 | }, 6 | { 7 | "id": "Scene Graph", 8 | "link": "https://en.wikipedia.org/wiki/Scene_graph" 9 | }, 10 | { 11 | "id": "Bounding Volume", 12 | "link": "https://en.wikipedia.org/wiki/Bounding_volume" 13 | }, 14 | { 15 | "id": "Bounding Sphere", 16 | "link": "https://en.wikipedia.org/wiki/Bounding_sphere" 17 | }, 18 | { 19 | "id": "Axis-aligned Bounding Box", 20 | "abbr": "AABB", 21 | "link": "https://en.wikipedia.org/wiki/Minimum_bounding_box" 22 | }, 23 | { 24 | "id": "Oriented Bounding Box", 25 | "abbr": "OBB", 26 | "link": "https://en.wikipedia.org/wiki/Minimum_bounding_box" 27 | }, 28 | { 29 | "id": "Discrete Oriented Polytope", 30 | "abbr": [ 31 | "DOP", 32 | "k-DOP" 33 | ] 34 | }, 35 | { 36 | "id": "Space Partitioning", 37 | "link": "https://en.wikipedia.org/wiki/Space_partitioning" 38 | }, 39 | { 40 | "id": "Bounding Volume Hierarchy", 41 | "abbr": "BVH", 42 | "link": "https://en.wikipedia.org/wiki/Bounding_volume_hierarchy" 43 | }, 44 | { 45 | "id": "Binary Space Partitioning", 46 | "abbr": "BSP", 47 | "link": "https://en.wikipedia.org/wiki/Binary_space_partitioning" 48 | }, 49 | { 50 | "id": "Quadtree", 51 | "link": "https://en.wikipedia.org/wiki/Quadtree" 52 | }, 53 | { 54 | "id": "Octree", 55 | "link": "https://en.wikipedia.org/wiki/Octree" 56 | }, 57 | { 58 | "id": "Loose Octree", 59 | "author": "Thatcher Ulrich", 60 | "title": "Loose Octrees", 61 | "journal": "Game Programming Gems", 62 | "year": 2000 63 | }, 64 | { 65 | "id": "k-d Tree", 66 | "link": "https://en.wikipedia.org/wiki/K-d_tree" 67 | } 68 | ], 69 | "links": [ 70 | { 71 | "source": "Computer Graphics", 72 | "target": "Scene Management" 73 | }, 74 | { 75 | "source": "Scene Management", 76 | "target": "Scene Graph" 77 | }, 78 | { 79 | "source": "Scene Management", 80 | "target": "Bounding Volume" 81 | }, 82 | { 83 | "source": "Bounding Volume", 84 | "target": "Bounding Sphere" 85 | }, 86 | { 87 | "source": "Bounding Volume", 88 | "target": "Axis-aligned Bounding Box" 89 | }, 90 | { 91 | "source": "Bounding Volume", 92 | "target": "Oriented Bounding Box" 93 | }, 94 | { 95 | "source": "Bounding Volume", 96 | "target": "Discrete Oriented Polytope" 97 | }, 98 | { 99 | "source": "Bounding Volume", 100 | "target": "Convex Hull" 101 | }, 102 | { 103 | "source": "Scene Management", 104 | "target": "Space Partitioning" 105 | }, 106 | { 107 | "source": "Space Partitioning", 108 | "target": "Bounding Volume Hierarchy" 109 | }, 110 | { 111 | "source": "Bounding Volume Hierarchy", 112 | "target": "Bounding Volume", 113 | "type": "use" 114 | }, 115 | { 116 | "source": "Space Partitioning", 117 | "target": "Binary Space Partitioning" 118 | }, 119 | { 120 | "source": "Space Partitioning", 121 | "target": "Quadtree" 122 | }, 123 | { 124 | "source": "Quadtree", 125 | "target": "Axis-aligned Bounding Box", 126 | "type": "use" 127 | }, 128 | { 129 | "source": "Space Partitioning", 130 | "target": "Octree" 131 | }, 132 | { 133 | "source": "Octree", 134 | "target": "Axis-aligned Bounding Box", 135 | "type": "use" 136 | }, 137 | { 138 | "source": "Octree", 139 | "target": "Loose Octree", 140 | "type": "derive" 141 | }, 142 | { 143 | "source": "Space Partitioning", 144 | "target": "k-d Tree" 145 | }, 146 | { 147 | "source": "k-d Tree", 148 | "target": "Axis-aligned Bounding Box", 149 | "type": "use" 150 | } 151 | ] 152 | } -------------------------------------------------------------------------------- /tech/cs/security.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Information Security", 5 | "link": "https://en.wikipedia.org/wiki/Information_security" 6 | }, 7 | { 8 | "id": "Authentication", 9 | "link": "https://en.wikipedia.org/wiki/Authentication" 10 | }, 11 | { 12 | "id": "Authentication Protocol", 13 | "link": "https://en.wikipedia.org/wiki/Authentication_protocol" 14 | }, 15 | { 16 | "id": "OpenID", 17 | "link": "https://en.wikipedia.org/wiki/OpenID" 18 | }, 19 | { 20 | "id": "OAuth", 21 | "link": "https://en.wikipedia.org/wiki/OAuth" 22 | }, 23 | { 24 | "id": "Cryptography", 25 | "link": "https://en.wikipedia.org/wiki/Cryptography" 26 | }, 27 | { 28 | "id": "Encryption", 29 | "link": "https://en.wikipedia.org/wiki/Encryption" 30 | }, 31 | { 32 | "id": "Symmetric Key", 33 | "link": "https://en.wikipedia.org/wiki/Symmetric-key_algorithm" 34 | }, 35 | { 36 | "id": "XOR Cipher", 37 | "link": "https://en.wikipedia.org/wiki/XOR_cipher" 38 | }, 39 | { 40 | "id": "Stream Cipher", 41 | "link": "https://en.wikipedia.org/wiki/Stream_cipher" 42 | }, 43 | { 44 | "id": "RC4", 45 | "link": "https://en.wikipedia.org/wiki/RC4" 46 | }, 47 | { 48 | "id": "Public Key", 49 | "aka": "Asymmetric Key", 50 | "link": "https://en.wikipedia.org/wiki/Public-key_cryptography" 51 | }, 52 | { 53 | "id": "Rivest-Shamir-Adleman", 54 | "abbr": "RSA" 55 | }, 56 | { 57 | "id": "Cryptographic Hash Function", 58 | "abbr": "CHF", 59 | "link": "https://en.wikipedia.org/wiki/Cryptographic_hash_function" 60 | }, 61 | { 62 | "id": "MD5", 63 | "link": "https://en.wikipedia.org/wiki/MD5" 64 | }, 65 | { 66 | "id": "SHA-1", 67 | "aka": "Secure Hash Algorithm 1", 68 | "link": "https://en.wikipedia.org/wiki/SHA-1" 69 | }, 70 | { 71 | "id": "Salt", 72 | "link": "https://en.wikipedia.org/wiki/Salt_(cryptography)" 73 | }, 74 | { 75 | "id": "Cryptography Library", 76 | "link": "https://en.wikipedia.org/wiki/Comparison_of_cryptography_libraries" 77 | } 78 | ], 79 | "links": [ 80 | { 81 | "source": "Computer Science", 82 | "target": "Information Security" 83 | }, 84 | { 85 | "source": "Information Security", 86 | "target": "Authentication" 87 | }, 88 | { 89 | "source": "Authentication", 90 | "target": "Authentication Protocol" 91 | }, 92 | { 93 | "source": "Authentication Protocol", 94 | "target": "OpenID" 95 | }, 96 | { 97 | "source": "Authentication Protocol", 98 | "target": "OAuth" 99 | }, 100 | { 101 | "source": "Information Security", 102 | "target": "Cryptography" 103 | }, 104 | { 105 | "source": "Cryptography", 106 | "target": "Encryption" 107 | }, 108 | { 109 | "source": "Encryption", 110 | "target": "Symmetric Key" 111 | }, 112 | { 113 | "source": "Symmetric Key", 114 | "target": "XOR Cipher" 115 | }, 116 | { 117 | "source": "Symmetric Key", 118 | "target": "Stream Cipher" 119 | }, 120 | { 121 | "source": "Stream Cipher", 122 | "target": "RC4" 123 | }, 124 | { 125 | "source": "Encryption", 126 | "target": "Public Key" 127 | }, 128 | { 129 | "source": "Public Key", 130 | "target": "Rivest-Shamir-Adleman" 131 | }, 132 | { 133 | "source": "Cryptography", 134 | "target": "Cryptographic Hash Function" 135 | }, 136 | { 137 | "source": "Cryptographic Hash Function", 138 | "target": "MD5" 139 | }, 140 | { 141 | "source": "Cryptographic Hash Function", 142 | "target": "SHA-1" 143 | }, 144 | { 145 | "source": "Cryptographic Hash Function", 146 | "target": "Salt" 147 | }, 148 | { 149 | "source": "Cryptography", 150 | "target": "Cryptography Library" 151 | } 152 | ] 153 | } -------------------------------------------------------------------------------- /tech/graphics/api.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Graphics API", 5 | "link": "https://en.wikipedia.org/wiki/List_of_3D_graphics_libraries" 6 | }, 7 | { 8 | "id": "Direct3D", 9 | "abbr": "D3D", 10 | "organization": "Microsoft", 11 | "link": [ 12 | "https://docs.microsoft.com/en-us/windows/win32/direct3d", 13 | "https://en.wikipedia.org/wiki/Direct3D" 14 | ], 15 | "year": 1996 16 | }, 17 | { 18 | "id": "OpenGL", 19 | "abbr": "OGL", 20 | "organization": "Khronos Group", 21 | "link": [ 22 | "https://www.opengl.org/", 23 | "https://en.wikipedia.org/wiki/OpenGL" 24 | ], 25 | "year": 1992 26 | }, 27 | { 28 | "id": "OpenGL ES", 29 | "abbr": "GLES", 30 | "organization": "Khronos Group", 31 | "link": [ 32 | "https://www.khronos.org/opengles/", 33 | "https://en.wikipedia.org/wiki/OpenGL_ES" 34 | ], 35 | "year": 2003 36 | }, 37 | { 38 | "id": "Vulkan", 39 | "organization": "Khronos Group", 40 | "link": [ 41 | "https://www.khronos.org/vulkan/", 42 | "https://en.wikipedia.org/wiki/Vulkan_(API)" 43 | ], 44 | "year": 2016 45 | }, 46 | { 47 | "id": "Metal", 48 | "organization": "Apple", 49 | "link": [ 50 | "https://developer.apple.com/metal/", 51 | "https://en.wikipedia.org/wiki/Metal_(API)" 52 | ], 53 | "year": 2014 54 | }, 55 | { 56 | "id": "WebGL", 57 | "organization": "Khronos Group", 58 | "link": [ 59 | "https://www.khronos.org/webgl/", 60 | "https://en.wikipedia.org/wiki/WebGL" 61 | ], 62 | "year": 2011 63 | }, 64 | { 65 | "id": "WebGPU", 66 | "organization": "W3C", 67 | "link": [ 68 | "https://www.w3.org/community/gpu/", 69 | "https://github.com/gpuweb/gpuweb", 70 | "https://en.wikipedia.org/wiki/WebGPU" 71 | ] 72 | }, 73 | { 74 | "id": "Glide", 75 | "organization": "3dfx interactive", 76 | "link": [ 77 | "http://glide.sourceforge.net/", 78 | "https://en.wikipedia.org/wiki/Glide_(API)" 79 | ], 80 | "year": 1997 81 | }, 82 | { 83 | "id": "Mantle", 84 | "organization": "AMD", 85 | "year": 2013 86 | } 87 | ], 88 | "links": [ 89 | { 90 | "source": "Computer Graphics", 91 | "target": "Graphics API" 92 | }, 93 | { 94 | "source": "Graphics API", 95 | "target": "Direct3D" 96 | }, 97 | { 98 | "source": "Direct3D", 99 | "target": "High-Level Shader Language", 100 | "type": "use" 101 | }, 102 | { 103 | "source": "Direct3D", 104 | "target": "DirectX Intermediate Language", 105 | "type": "use" 106 | }, 107 | { 108 | "source": "Graphics API", 109 | "target": "OpenGL" 110 | }, 111 | { 112 | "source": "OpenGL", 113 | "target": "OpenGL Shading Language", 114 | "type": "use" 115 | }, 116 | { 117 | "source": "OpenGL", 118 | "target": "OpenGL ES", 119 | "type": "derive" 120 | }, 121 | { 122 | "source": "OpenGL ES", 123 | "target": "OpenGL ES Shading Language", 124 | "type": "use" 125 | }, 126 | { 127 | "source": "Graphics API", 128 | "target": "Vulkan" 129 | }, 130 | { 131 | "source": "Vulkan", 132 | "target": "Standard Portable Intermediate Representation V", 133 | "type": "use" 134 | }, 135 | { 136 | "source": "Graphics API", 137 | "target": "Metal" 138 | }, 139 | { 140 | "source": "Metal", 141 | "target": "Metal Shading Language", 142 | "type": "use" 143 | }, 144 | { 145 | "source": "Graphics API", 146 | "target": "WebGL" 147 | }, 148 | { 149 | "source": "WebGL", 150 | "target": "OpenGL ES Shading Language", 151 | "type": "use" 152 | }, 153 | { 154 | "source": "Graphics API", 155 | "target": "WebGPU" 156 | }, 157 | { 158 | "source": "WebGPU", 159 | "target": "Standard Portable Intermediate Representation V", 160 | "type": "use" 161 | }, 162 | { 163 | "source": "Graphics API", 164 | "target": "Glide" 165 | }, 166 | { 167 | "source": "Graphics API", 168 | "target": "Mantle" 169 | } 170 | ] 171 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Game ⨯ Tech (beta) 2 | 3 | [![Build Status](https://travis-ci.org/miloyip/gamextech.svg?branch=main)](https://travis-ci.org/miloyip/gamextech) 4 | 5 | A web-based knowledge management system for visualizing game related technologies. 6 | 7 | This repository can be viewed at [gamextech.org](http://gamextech.org/). 8 | 9 | Currently the database is very limited. Please consider [contribution](#contribution). 10 | 11 | ## Target users 12 | 13 | * Game developers 14 | * Researchers 15 | * Students 16 | 17 | ## Features 18 | 19 | * Explore game and related technology, and their relationships 20 | * Chronological view mode 21 | * Share a view with URL 22 | * Search nodes with regular expression 23 | * Serverless for easy contribution and merging 24 | 25 | ## Dependinces 26 | 27 | * [https://d3js.org/](D3) 28 | * HTML/JavaScript/CSS/SVG/JSON 29 | 30 | ## Schema 31 | 32 | The database contains a set of graphs. 33 | 34 | The [database](database.json) and graphs are stored in [JSON](https://www.json.org/json-en.html) format. 35 | 36 | Each graph JSON is an object, with "nodes" and "links" array. 37 | 38 | ### Node 39 | 40 | Each node is an object with following keys (*required): 41 | 42 | | Key | Type | Description | 43 | | ----------- | ------------------------- | ------------------------------------------------------------ | 44 | | id* | string | Unique identifier in title case | 45 | | abbr | string | Abbreviation | 46 | | aka | string or array of string | Alternative names (also known as | 47 | | type | string | "category" (default) or "technique" or "game" | 48 | | year | number | Year of invention or publication | 49 | | synopsis | string | Concise description | 50 | | author | string or array of string | Inventor(s) or author(s) | 51 | | link | string or array of string | links of publication, wikipedia or other related information | 52 | | title | string | Title of the first publication which reveals this | 53 | | conference | string | Abbreviation of conference name, e.g. GDC, SIGGRAPH | 54 | | journal | string | Abbreviation of journal name, e.g. JCGT | 55 | | organization| string or array of string | Company, institute or other organization | 56 | | contributor | string or array of string | github usernames of whom contribute to this node | 57 | 58 | ### Link 59 | 60 | Each link is an object with following keys (*required): 61 | 62 | | Key | Type | Description | 63 | | --------- | -------- | ------------------------------- | 64 | | source* | string | Source node id | 65 | | target* | string | Target node id | 66 | | type | string | "include" (default) or "derive" or "use" or "first-use" or "invent" | 67 | 68 | ## Contribution 69 | 70 | Contributions are welcome. Please follow: 71 | 72 | 1. Fork this repository 73 | 2. Add nodes or links in related json files. Add "contributor" key optionally. 74 | 3. Testing 75 | 4. Make Pull request 76 | 77 | If there are too many nodes/links in a single file, you may extract them into a new JSON in a suitable directory, 78 | and add the JSON file into `/database.json`. 79 | 80 | If you want to add a lot of data or reorganize existing structure, you may create an GitHub issue for discussion. 81 | 82 | Adding new features and fixing bugs are welcome as well. 83 | 84 | ### Testing 85 | 86 | Run `npm install` and `npm test` to validate the database with schema and additional checks. 87 | 88 | Run `npm start` to start a local http server, and open one of the listed URL in the browser to view the local site. 89 | ``` 90 | Starting up http-server, serving . 91 | Available on: 92 | http://192.168.1.1:8080 93 | http://127.0.0.1:8080 94 | ``` 95 | 96 | For testing single(or several) JSON, you may use `?d=` in query string, such as `http://localhost:8000/?d=/tech/graphics/shadow.json&e=-1`. 97 | 98 | ## History 99 | 100 | * 2021/2/1: Initiate this project 101 | * 2021/2/21: Beta launch with 706 nodes and 812 links 102 | -------------------------------------------------------------------------------- /tech/se/design.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Software Design", 5 | "link": "https://en.wikipedia.org/wiki/Software_design" 6 | }, 7 | { 8 | "id": "Software Architecture", 9 | "link": "https://en.wikipedia.org/wiki/Software_architecture" 10 | }, 11 | { 12 | "id": "Unified Modeling Language", 13 | "abbr": "UML", 14 | "link": "https://en.wikipedia.org/wiki/Unified_Modeling_Language", 15 | "year": 1995 16 | }, 17 | { 18 | "id": "SOLID Principles", 19 | "link": "https://en.wikipedia.org/wiki/SOLID" 20 | }, 21 | { 22 | "id": "Single Responsibility Principle", 23 | "abbr": "SRP", 24 | "author": "Robert C. Martin", 25 | "title": "The Principles of OOD", 26 | "link": [ 27 | "https://en.wikipedia.org/wiki/Single-responsibility_principle", 28 | "http://www.butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod" 29 | ], 30 | "year": 2005 31 | }, 32 | { 33 | "id": "Open-closed Principle", 34 | "abbr": "OCP", 35 | "author": "Bertrand Meyer", 36 | "link": "https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle", 37 | "year": 1988 38 | }, 39 | { 40 | "id": "Liskov Substitution Principle", 41 | "abbr": "LSP", 42 | "author": [ 43 | "Barbara Liskov", 44 | "Jeannette Wing" 45 | ], 46 | "title": "A behavioral notion of subtyping", 47 | "journal": "ACM Transactions on Programming Languages and Systems", 48 | "link": "https://en.wikipedia.org/wiki/Liskov_substitution_principle", 49 | "year": 1994 50 | }, 51 | { 52 | "id": "Interface Segregation Principle", 53 | "abbr": "ISP", 54 | "author": "Robert C. Martin", 55 | "link": "https://en.wikipedia.org/wiki/Interface_segregation_principle" 56 | }, 57 | { 58 | "id": "Dependency Inversion Principle", 59 | "abbr": "DIP", 60 | "author": "Robert C. Martin", 61 | "title": "Object Oriented Design Quality Metrics: an analysis of dependencies", 62 | "link": [ 63 | "https://en.wikipedia.org/wiki/Dependency_inversion_principle", 64 | "https://linux.ime.usp.br/~joaomm/mac499/arquivos/referencias/oodmetrics.pdf" 65 | ], 66 | "year": 1994 67 | }, 68 | { 69 | "id": "Component-based Architecture", 70 | "link": "https://en.wikipedia.org/wiki/Component-based_software_engineering" 71 | }, 72 | { 73 | "id": "Event-driven Architecture", 74 | "link": "https://en.wikipedia.org/wiki/Event-driven_architecture" 75 | }, 76 | { 77 | "id": "Multitier Architecture", 78 | "aka": [ 79 | "n-tier Architecture", 80 | "Multilayered Architecture" 81 | ], 82 | "link": "https://en.wikipedia.org/wiki/Multitier_architecture" 83 | }, 84 | { 85 | "id": "Service Oriented Architecture", 86 | "abbr": "SOA", 87 | "link": "Service-oriented architecture" 88 | } 89 | ], 90 | "links": [ 91 | { 92 | "source": "Software Engineering", 93 | "target": "Software Design" 94 | }, 95 | { 96 | "source": "Software Design", 97 | "target": "Software Architecture" 98 | }, 99 | { 100 | "source": "Software Architecture", 101 | "target": "Component-based Architecture" 102 | }, 103 | { 104 | "source": "Software Architecture", 105 | "target": "Event-driven Architecture" 106 | }, 107 | { 108 | "source": "Software Architecture", 109 | "target": "Multitier Architecture" 110 | }, 111 | { 112 | "source": "Software Architecture", 113 | "target": "Service Oriented Architecture" 114 | }, 115 | { 116 | "source": "Software Architecture", 117 | "target": "Architectural Pattern" 118 | }, 119 | { 120 | "source": "Software Design", 121 | "target": "Unified Modeling Language" 122 | }, 123 | { 124 | "source": "Software Design", 125 | "target": "SOLID Principles" 126 | }, 127 | { 128 | "source": "SOLID Principles", 129 | "target": "Single Responsibility Principle" 130 | }, 131 | { 132 | "source": "SOLID Principles", 133 | "target": "Open-closed Principle" 134 | }, 135 | { 136 | "source": "SOLID Principles", 137 | "target": "Liskov Substitution Principle" 138 | }, 139 | { 140 | "source": "SOLID Principles", 141 | "target": "Interface Segregation Principle" 142 | }, 143 | { 144 | "source": "SOLID Principles", 145 | "target": "Dependency Inversion Principle" 146 | } 147 | ] 148 | } -------------------------------------------------------------------------------- /tech/cs/numerical.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Numerical Analysis", 5 | "aka": "Numerical Method", 6 | "link": "https://en.wikipedia.org/wiki/Numerical_analysis" 7 | }, 8 | { 9 | "id": "Root Finding", 10 | "link": "https://en.wikipedia.org/wiki/Root-finding_algorithms" 11 | }, 12 | { 13 | "id": "Bisection Method", 14 | "aka": [ 15 | "Interval Halving Method", 16 | "Binary search Method", 17 | "Dichotomy Method" 18 | ], 19 | "link": "https://en.wikipedia.org/wiki/Bisection_method" 20 | }, 21 | { 22 | "id": "Newton's Method", 23 | "aka": "Newton–Raphson method", 24 | "author": [ 25 | "Isaac Newton", 26 | "Joseph Raphson" 27 | ], 28 | "link": "https://en.wikipedia.org/wiki/Newton%27s_method", 29 | "year": 1669 30 | }, 31 | { 32 | "id": "Runge-Kutta Method", 33 | "author": [ 34 | "Carl David Tolmé Runge", 35 | "Martin Kutta" 36 | ], 37 | "link": "https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods", 38 | "year": 1895 39 | }, 40 | { 41 | "id": "Mathematical Optimization", 42 | "link": "https://en.wikipedia.org/wiki/Mathematical_optimization" 43 | }, 44 | { 45 | "id": "Gradient Descent", 46 | "abbr": "GD", 47 | "link": "https://en.wikipedia.org/wiki/Gradient_descent" 48 | }, 49 | { 50 | "id": "Stochastic Gradient Descent", 51 | "abbr": "SGD", 52 | "link": "https://en.wikipedia.org/wiki/Stochastic_gradient_descent" 53 | }, 54 | { 55 | "id": "Simulated Annealing", 56 | "abbr": "SA", 57 | "author": [ 58 | "Scott Kirkpatrick", 59 | "C. Daniel Gelatt", 60 | "Mario P. Vecchi" 61 | ], 62 | "title": "Optimization by Simulated Annealing", 63 | "link": [ 64 | "http://www2.stat.duke.edu/~scs/Courses/Stat376/Papers/TemperAnneal/KirkpatrickAnnealScience1983.pdf", 65 | "https://en.wikipedia.org/wiki/Simulated_annealing" 66 | ], 67 | "year": 1983 68 | }, 69 | { 70 | "id": "Numerical Integration" 71 | }, 72 | { 73 | "id": "Monte Carlo Integration", 74 | "link": "https://en.wikipedia.org/wiki/Monte_Carlo_integration" 75 | }, 76 | { 77 | "id": "Quasi-Monte Carlo Method", 78 | "link": "https://en.wikipedia.org/wiki/Quasi-Monte_Carlo_method" 79 | }, 80 | { 81 | "id": "Differential Equation Solving" 82 | }, 83 | { 84 | "id": "Euler Method", 85 | "author": "Leonhard Euler", 86 | "aka": "Forward Euler Method", 87 | "link": "https://en.wikipedia.org/wiki/Euler_method", 88 | "year": 1768 89 | }, 90 | { 91 | "id": "Verlet Integration" 92 | }, 93 | { 94 | "id": "Courant-Friedrichs-Lewy Condition", 95 | "abbr": "CFL Condition", 96 | "link": "https://en.wikipedia.org/wiki/Courant%E2%80%93Friedrichs%E2%80%93Lewy_condition" 97 | } 98 | ], 99 | "links": [ 100 | { 101 | "source": "Computer Science", 102 | "target": "Numerical Analysis" 103 | }, 104 | { 105 | "source": "Numerical Analysis", 106 | "target": "Root Finding" 107 | }, 108 | { 109 | "source": "Root Finding", 110 | "target": "Bisection Method" 111 | }, 112 | { 113 | "source": "Root Finding", 114 | "target": "Newton's Method" 115 | }, 116 | { 117 | "source": "Root Finding", 118 | "target": "Runge-Kutta Method" 119 | }, 120 | { 121 | "source": "Numerical Analysis", 122 | "target": "Mathematical Optimization" 123 | }, 124 | { 125 | "source": "Mathematical Optimization", 126 | "target": "Gradient Descent" 127 | }, 128 | { 129 | "source": "Mathematical Optimization", 130 | "target": "Simulated Annealing" 131 | }, 132 | { 133 | "source": "Gradient Descent", 134 | "target": "Stochastic Gradient Descent" 135 | }, 136 | { 137 | "source": "Numerical Analysis", 138 | "target": "Numerical Integration" 139 | }, 140 | { 141 | "source": "Numerical Integration", 142 | "target": "Monte Carlo Integration" 143 | }, 144 | { 145 | "source": "Numerical Integration", 146 | "target": "Quasi-Monte Carlo Method" 147 | }, 148 | { 149 | "source": "Numerical Analysis", 150 | "target": "Differential Equation Solving" 151 | }, 152 | { 153 | "source": "Differential Equation Solving", 154 | "target": "Euler Method" 155 | }, 156 | { 157 | "source": "Differential Equation Solving", 158 | "target": "Verlet Integration" 159 | }, 160 | { 161 | "source": "Differential Equation Solving", 162 | "target": "Courant-Friedrichs-Lewy Condition" 163 | } 164 | ] 165 | } -------------------------------------------------------------------------------- /tech/tool.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Tool Development" 5 | }, 6 | { 7 | "id": "GUI Toolkit", 8 | "aka": [ 9 | "Widget Toolkit", 10 | "Widget library", 11 | "UX library" 12 | ], 13 | "link": "https://en.wikipedia.org/wiki/Widget_toolkit" 14 | }, 15 | { 16 | "id": "Naitve GUI Toolkit" 17 | }, 18 | { 19 | "id": "Microsoft Foundation Class", 20 | "abbr": "MFC", 21 | "organization": "Microsoft", 22 | "link": "https://en.wikipedia.org/wiki/Microsoft_Foundation_Class_Library", 23 | "year": 1992 24 | }, 25 | { 26 | "id": "WxWidgets", 27 | "aka": "WxWindows", 28 | "author": "Julian Smart", 29 | "link": [ 30 | "https://wxwidgets.org/", 31 | "https://en.wikipedia.org/wiki/WxWidgets" 32 | ], 33 | "year": 1992 34 | }, 35 | { 36 | "id": "Qt", 37 | "link": [ 38 | "https://www.qt.io/", 39 | "https://en.wikipedia.org/wiki/Qt_(software)" 40 | ], 41 | "year": 1995 42 | }, 43 | { 44 | "id": "GTK", 45 | "link": [ 46 | "https://gtk.org/", 47 | "https://en.wikipedia.org/wiki/GTK" 48 | ], 49 | "year": 1998 50 | }, 51 | { 52 | "id": "Windows Template Library", 53 | "abbr": "WTL", 54 | "organization": "Microsoft", 55 | "link": [ 56 | "https://sourceforge.NET/projects/wtl/", 57 | "https://en.wikipedia.org/wiki/Windows_Template_Library" 58 | ], 59 | "year": 2004 60 | }, 61 | { 62 | "id": "Dear ImGui", 63 | "author": "Omar Cornut", 64 | "link": "https://github.com/ocornut/imgui", 65 | "year": 2014 66 | }, 67 | { 68 | "id": ".NET GUI Toolkit" 69 | }, 70 | { 71 | "id": "Windows Forms", 72 | "aka": "WinForms", 73 | "organization": ".NET Foundation", 74 | "link": [ 75 | "https://en.wikipedia.org/wiki/Windows_Forms", 76 | "https://docs.microsoft.com/en-us/dotnet/desktop/winforms/" 77 | ], 78 | "year": 2002 79 | }, 80 | { 81 | "id": "GtkSharp", 82 | "aka": "GTK#", 83 | "link": [ 84 | "https://www.mono-project.com/docs/gui/gtksharp/", 85 | "https://github.com/GtkSharp/GtkSharp" 86 | ], 87 | "year": 2005 88 | }, 89 | { 90 | "id": "Windows Presentation Foundation", 91 | "abbr": "WPF", 92 | "organization": ".NET Foundation", 93 | "link": [ 94 | "https://en.wikipedia.org/wiki/Windows_Presentation_Foundation", 95 | "https://docs.microsoft.com/en-us/dotnet/desktop/wpf/" 96 | ], 97 | "year": 2006 98 | }, 99 | { 100 | "id": "Web-based Software Framework" 101 | }, 102 | { 103 | "id": "Chromium Embedded Framework", 104 | "abbr": "CEF", 105 | "author": "Marshall Greenblatt", 106 | "link": [ 107 | "https://bitbucket.org/chromiumembedded/cef/", 108 | "https://en.wikipedia.org/wiki/Chromium_Embedded_Framework" 109 | ], 110 | "year": 2009 111 | }, 112 | { 113 | "id": "Electron", 114 | "link": [ 115 | "https://www.electronjs.org/", 116 | "https://en.wikipedia.org/wiki/Electron_(software_framework)" 117 | ], 118 | "year": 2013 119 | }, 120 | { 121 | "id": "NW.js", 122 | "aka": "node-webkit", 123 | "link": [ 124 | "https://nwjs.io/", 125 | "https://github.com/nwjs/nw.js" 126 | ], 127 | "year": 2013 128 | } 129 | ], 130 | "links": [ 131 | { 132 | "source": "Technology", 133 | "target": "Tool Development" 134 | }, 135 | { 136 | "source": "Tool Development", 137 | "target": "GUI Toolkit" 138 | }, 139 | { 140 | "source": "GUI Toolkit", 141 | "target": "Naitve GUI Toolkit" 142 | }, 143 | { 144 | "source": "Naitve GUI Toolkit", 145 | "target": "Microsoft Foundation Class" 146 | }, 147 | { 148 | "source": "Naitve GUI Toolkit", 149 | "target": "Qt" 150 | }, 151 | { 152 | "source": "Naitve GUI Toolkit", 153 | "target": "WxWidgets" 154 | }, 155 | { 156 | "source": "Naitve GUI Toolkit", 157 | "target": "GTK" 158 | }, 159 | { 160 | "source": "Naitve GUI Toolkit", 161 | "target": "Windows Template Library" 162 | }, 163 | { 164 | "source": "Naitve GUI Toolkit", 165 | "target": "Dear ImGui" 166 | }, 167 | { 168 | "source": "GUI Toolkit", 169 | "target": ".NET GUI Toolkit" 170 | }, 171 | { 172 | "source": ".NET GUI Toolkit", 173 | "target": "Windows Forms" 174 | }, 175 | { 176 | "source": ".NET GUI Toolkit", 177 | "target": "GtkSharp" 178 | }, 179 | { 180 | "source": "GTK", 181 | "target": "GtkSharp", 182 | "type": "derive" 183 | }, 184 | { 185 | "source": ".NET GUI Toolkit", 186 | "target": "Windows Presentation Foundation" 187 | }, 188 | { 189 | "source": "GUI Toolkit", 190 | "target": "Web-based Software Framework" 191 | }, 192 | { 193 | "source": "Web-based Software Framework", 194 | "target": "Chromium Embedded Framework" 195 | }, 196 | { 197 | "source": "Web-based Software Framework", 198 | "target": "Electron" 199 | }, 200 | { 201 | "source": "Web-based Software Framework", 202 | "target": "NW.js" 203 | } 204 | ] 205 | } -------------------------------------------------------------------------------- /tech/cs/os.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Operating System", 5 | "abbr": "OS", 6 | "link": "https://en.wikipedia.org/wiki/Operating_system" 7 | }, 8 | { 9 | "id": "Kernel", 10 | "link": "https://en.wikipedia.org/wiki/Kernel_(operating_system)" 11 | }, 12 | { 13 | "id": "Interrupt", 14 | "link": "https://en.wikipedia.org/wiki/Interrupt" 15 | }, 16 | { 17 | "id": "Protection Ring", 18 | "link": "https://en.wikipedia.org/wiki/Protection_ring" 19 | }, 20 | { 21 | "id": "Process Management", 22 | "link": "https://en.wikipedia.org/wiki/Process_management_(computing)" 23 | }, 24 | { 25 | "id": "Process", 26 | "link": "https://en.wikipedia.org/wiki/Process_(computing)" 27 | }, 28 | { 29 | "id": "Thread", 30 | "link": "https://en.wikipedia.org/wiki/Thread_(computing)" 31 | }, 32 | { 33 | "id": "Inter-process Communication", 34 | "abbr": "IPC", 35 | "link": "https://en.wikipedia.org/wiki/Inter-process_communication" 36 | }, 37 | { 38 | "id": "Network Socket", 39 | "link": "https://en.wikipedia.org/wiki/Network_socket" 40 | }, 41 | { 42 | "id": "Named Pipe", 43 | "link": "https://en.wikipedia.org/wiki/Named_pipe" 44 | }, 45 | { 46 | "id": "Anonymous Pipe", 47 | "link": "https://en.wikipedia.org/wiki/Anonymous_pipe" 48 | }, 49 | { 50 | "id": "Shared Memory", 51 | "link": "https://en.wikipedia.org/wiki/Shared_memory" 52 | }, 53 | { 54 | "id": "Memory Management", 55 | "link": "https://en.wikipedia.org/wiki/Memory_management_(operating_systems)" 56 | }, 57 | { 58 | "id": "Virtual Memory", 59 | "link": "https://en.wikipedia.org/wiki/Virtual_memory" 60 | }, 61 | { 62 | "id": "User Space", 63 | "link": "https://en.wikipedia.org/wiki/User_space" 64 | }, 65 | { 66 | "id": "File System", 67 | "link": "https://en.wikipedia.org/wiki/File_system" 68 | }, 69 | { 70 | "id": "Memory-mapped File", 71 | "link": "https://en.wikipedia.org/wiki/Memory-mapped_file" 72 | }, 73 | { 74 | "id": "Device Driver", 75 | "link": "https://en.wikipedia.org/wiki/Device_driver" 76 | }, 77 | { 78 | "id": "Open Source Operating System" 79 | }, 80 | { 81 | "id": "Commercial Operating System" 82 | } 83 | ], 84 | "links": [ 85 | { 86 | "source": "Computer Science", 87 | "target": "Operating System" 88 | }, 89 | { 90 | "source": "Operating System", 91 | "target": "Kernel" 92 | }, 93 | { 94 | "source": "Operating System", 95 | "target": "Interrupt" 96 | }, 97 | { 98 | "source": "Operating System", 99 | "target": "Protection Ring" 100 | }, 101 | { 102 | "source": "Operating System", 103 | "target": "Process Management" 104 | }, 105 | { 106 | "source": "Process Management", 107 | "target": "Process" 108 | }, 109 | { 110 | "source": "Process Management", 111 | "target": "Thread" 112 | }, 113 | { 114 | "source": "Operating System", 115 | "target": "Inter-process Communication" 116 | }, 117 | { 118 | "source": "Inter-process Communication", 119 | "target": "Network Socket" 120 | }, 121 | { 122 | "source": "Inter-process Communication", 123 | "target": "Named Pipe" 124 | }, 125 | { 126 | "source": "Inter-process Communication", 127 | "target": "Anonymous Pipe" 128 | }, 129 | { 130 | "source": "Inter-process Communication", 131 | "target": "Shared Memory" 132 | }, 133 | { 134 | "source": "Inter-process Communication", 135 | "target": "Memory-mapped File" 136 | }, 137 | { 138 | "source": "Operating System", 139 | "target": "Memory Management" 140 | }, 141 | { 142 | "source": "Memory Management", 143 | "target": "Virtual Memory" 144 | }, 145 | { 146 | "source": "Virtual Memory", 147 | "target": "User Space" 148 | }, 149 | { 150 | "source": "Virtual Memory", 151 | "target": "Memory-mapped File" 152 | }, 153 | { 154 | "source": "Operating System", 155 | "target": "File System" 156 | }, 157 | { 158 | "source": "File System", 159 | "target": "Memory-mapped File" 160 | }, 161 | { 162 | "source": "Operating System", 163 | "target": "Device Driver" 164 | }, 165 | { 166 | "source": "Operating System", 167 | "target": "Open Source Operating System" 168 | }, 169 | { 170 | "source": "Open Source Operating System", 171 | "target": "Linux" 172 | }, 173 | { 174 | "source": "Open Source Operating System", 175 | "target": "Android" 176 | }, 177 | { 178 | "source": "Open Source Operating System", 179 | "target": "Berkeley Software Distribution" 180 | }, 181 | { 182 | "source": "Operating System", 183 | "target": "Commercial Operating System" 184 | }, 185 | { 186 | "source": "Commercial Operating System", 187 | "target": "Windows" 188 | }, 189 | { 190 | "source": "Commercial Operating System", 191 | "target": "macOS" 192 | }, 193 | { 194 | "source": "Commercial Operating System", 195 | "target": "iOS" 196 | }, 197 | { 198 | "source": "Commercial Operating System", 199 | "target": "Chrome OS" 200 | }, 201 | { 202 | "source": "Commercial Operating System", 203 | "target": "Windows" 204 | } 205 | ] 206 | } -------------------------------------------------------------------------------- /tech/se/testing.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Software Testing", 5 | "link": "https://en.wikipedia.org/wiki/Software_testing" 6 | }, 7 | { 8 | "id": "Testing Approach", 9 | "link": "https://en.wikipedia.org/wiki/Software_testing#Testing_approach" 10 | }, 11 | { 12 | "id": "White-box Testing", 13 | "link": "https://en.wikipedia.org/wiki/White-box_testing" 14 | }, 15 | { 16 | "id": "Black-box Testing", 17 | "link": "https://en.wikipedia.org/wiki/Black-box_testing" 18 | }, 19 | { 20 | "id": "Grey-box Testing", 21 | "link": "https://en.wikipedia.org/wiki/Gray_box_testing" 22 | }, 23 | { 24 | "id": "Testing Level", 25 | "link": "https://en.wikipedia.org/wiki/Software_testing#Testing_levels" 26 | }, 27 | { 28 | "id": "Unit Testing", 29 | "link": "https://en.wikipedia.org/wiki/Unit_testing" 30 | }, 31 | { 32 | "id": "Integration Testing", 33 | "link": "https://en.wikipedia.org/wiki/Integration_testing" 34 | }, 35 | { 36 | "id": "System Testing", 37 | "link": "https://en.wikipedia.org/wiki/System_testing" 38 | }, 39 | { 40 | "id": "Acceptance Testing", 41 | "link": "https://en.wikipedia.org/wiki/Acceptance_testing" 42 | }, 43 | { 44 | "id": "Testing Technique", 45 | "link": "https://en.wikipedia.org/wiki/Software_testing#Testing_types,_techniques_and_tactics" 46 | }, 47 | { 48 | "id": "Installation Testing", 49 | "link": "https://en.wikipedia.org/wiki/Installation_testing" 50 | }, 51 | { 52 | "id": "Compatibility Testing", 53 | "link": "https://en.wikipedia.org/wiki/Compatibility_testing" 54 | }, 55 | { 56 | "id": "Smoke Testing", 57 | "link": "https://en.wikipedia.org/wiki/Smoke_testing_(software)" 58 | }, 59 | { 60 | "id": "Regression Testing", 61 | "link": "https://en.wikipedia.org/wiki/Regression_testing" 62 | }, 63 | { 64 | "id": "Performance Testing", 65 | "link": "https://en.wikipedia.org/wiki/Software_performance_testing" 66 | }, 67 | { 68 | "id": "Usability Testing", 69 | "link": "https://en.wikipedia.org/wiki/Usability_testing" 70 | }, 71 | { 72 | "id": "Security Testing", 73 | "link": "https://en.wikipedia.org/wiki/Security_testing" 74 | }, 75 | { 76 | "id": "A/B Testing", 77 | "link": "https://en.wikipedia.org/wiki/A/B_testing" 78 | }, 79 | { 80 | "id": "Test Automation", 81 | "link": "https://en.wikipedia.org/wiki/Test_automation" 82 | }, 83 | { 84 | "id": "Fuzzing", 85 | "aka": "Fuzz Testing", 86 | "link": "https://en.wikipedia.org/wiki/Fuzzing" 87 | }, 88 | { 89 | "id": "Static Program Analysis", 90 | "link": [ 91 | "https://en.wikipedia.org/wiki/Static_program_analysis", 92 | "https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis" 93 | ] 94 | }, 95 | { 96 | "id": "Lint", 97 | "aka": "Linter", 98 | "author": "Stephen C. Johnson", 99 | "link": "https://en.wikipedia.org/wiki/Lint_(software)", 100 | "year": 1978 101 | } 102 | ], 103 | "links": [ 104 | { 105 | "source": "Software Engineering", 106 | "target": "Software Testing" 107 | }, 108 | { 109 | "source": "Software Testing", 110 | "target": "Testing Approach" 111 | }, 112 | { 113 | "source": "Testing Approach", 114 | "target": "White-box Testing" 115 | }, 116 | { 117 | "source": "Testing Approach", 118 | "target": "Black-box Testing" 119 | }, 120 | { 121 | "source": "Testing Approach", 122 | "target": "Grey-box Testing" 123 | }, 124 | { 125 | "source": "Software Testing", 126 | "target": "Testing Level" 127 | }, 128 | { 129 | "source": "Testing Level", 130 | "target": "Unit Testing" 131 | }, 132 | { 133 | "source": "Testing Level", 134 | "target": "Integration Testing" 135 | }, 136 | { 137 | "source": "Testing Level", 138 | "target": "System Testing" 139 | }, 140 | { 141 | "source": "Testing Level", 142 | "target": "Acceptance Testing" 143 | }, 144 | { 145 | "source": "Software Testing", 146 | "target": "Testing Technique" 147 | }, 148 | { 149 | "source": "Testing Technique", 150 | "target": "Installation Testing" 151 | }, 152 | { 153 | "source": "Testing Technique", 154 | "target": "Compatibility Testing" 155 | }, 156 | { 157 | "source": "Testing Technique", 158 | "target": "Smoke Testing" 159 | }, 160 | { 161 | "source": "Testing Technique", 162 | "target": "Regression Testing" 163 | }, 164 | { 165 | "source": "Testing Technique", 166 | "target": "Performance Testing" 167 | }, 168 | { 169 | "source": "Testing Technique", 170 | "target": "Usability Testing" 171 | }, 172 | { 173 | "source": "Testing Technique", 174 | "target": "Security Testing" 175 | }, 176 | { 177 | "source": "Testing Technique", 178 | "target": "A/B Testing" 179 | }, 180 | { 181 | "source": "Software Testing", 182 | "target": "Test Automation" 183 | }, 184 | { 185 | "source": "Test Automation", 186 | "target": "Fuzzing" 187 | }, 188 | { 189 | "source": "Test Automation", 190 | "target": "Static Program Analysis" 191 | }, 192 | { 193 | "source": "Static Program Analysis", 194 | "target": "Lint" 195 | } 196 | ] 197 | } -------------------------------------------------------------------------------- /tech/cs/network.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Computer Network", 5 | "link": "https://en.wikipedia.org/wiki/Computer_network" 6 | }, 7 | { 8 | "id": "Network Topology", 9 | "link": "https://en.wikipedia.org/wiki/Network_topology" 10 | }, 11 | { 12 | "id": "Client-server", 13 | "abbr": "CS", 14 | "link": "https://en.wikipedia.org/wiki/Client%E2%80%93server_model" 15 | }, 16 | { 17 | "id": "Peer-to-Peer", 18 | "abbr": "P2P", 19 | "link": "https://en.wikipedia.org/wiki/Peer-to-peer" 20 | }, 21 | { 22 | "id": "Internet Protocol Suite", 23 | "aka": "TCP/IP", 24 | "link": "https://en.wikipedia.org/wiki/Internet_protocol_suite" 25 | }, 26 | { 27 | "id": "Link Layer", 28 | "link": "https://en.wikipedia.org/wiki/Link_layer" 29 | }, 30 | { 31 | "id": "Internet Layer", 32 | "link": "https://en.wikipedia.org/wiki/Internet_layer" 33 | }, 34 | { 35 | "id": "Internet Protocol", 36 | "abbr": "IP", 37 | "link": "https://en.wikipedia.org/wiki/Internet_Protocol", 38 | "year": 1974 39 | }, 40 | { 41 | "id": "Internet Protocol Version 4", 42 | "abbr": "IPv4", 43 | "link": [ 44 | "https://tools.ietf.org/html/rfc791", 45 | "https://en.wikipedia.org/wiki/IPv4" 46 | ], 47 | "year": 1981 48 | }, 49 | { 50 | "id": "Internet Protocol Version 6", 51 | "abbr": "IPv6", 52 | "link": [ 53 | "https://tools.ietf.org/html/rfc2460", 54 | "https://en.wikipedia.org/wiki/IPv6" 55 | ], 56 | "year": 1995 57 | }, 58 | { 59 | "id": "Transport Layer", 60 | "link": "https://en.wikipedia.org/wiki/Transport_layer" 61 | }, 62 | { 63 | "id": "Transmission Control Protocol", 64 | "abbr": "TCP", 65 | "link": [ 66 | "https://tools.ietf.org/html/rfc675", 67 | "https://en.wikipedia.org/wiki/Transmission_Control_Protocol" 68 | ], 69 | "year": 1974 70 | }, 71 | { 72 | "id": "User Datagram Protocol", 73 | "abbr": "UDP", 74 | "link": [ 75 | "https://tools.ietf.org/html/rfc768", 76 | "https://en.wikipedia.org/wiki/User_Datagram_Protocol" 77 | ], 78 | "year": 1980 79 | }, 80 | { 81 | "id": "Application Layer", 82 | "link": "https://en.wikipedia.org/wiki/Application_layer" 83 | }, 84 | { 85 | "id": "Domain Name System", 86 | "abbr": "DNS", 87 | "link": "https://en.wikipedia.org/wiki/Domain_Name_System", 88 | "year": 1985 89 | }, 90 | { 91 | "id": "Hypertext Transfer Protocol", 92 | "abbr": "HTTP", 93 | "link": "https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol", 94 | "year": 1991 95 | }, 96 | { 97 | "id": "Hypertext Transfer Protocol Secure", 98 | "abbr": "HTTPS", 99 | "link": "https://en.wikipedia.org/wiki/HTTPS", 100 | "year": 1994 101 | }, 102 | { 103 | "id": "Transport Layer Security", 104 | "abbr": "TLS", 105 | "link": "https://en.wikipedia.org/wiki/Transport_Layer_Security", 106 | "year": 1994 107 | }, 108 | { 109 | "id": "OpenSSL", 110 | "link": "https://en.wikipedia.org/wiki/OpenSSL", 111 | "year": 1998 112 | }, 113 | { 114 | "id": "KCP", 115 | "link": "https://github.com/skywind3000/kcp", 116 | "year": 2014 117 | }, 118 | { 119 | "id": "Network API" 120 | }, 121 | { 122 | "id": "Berkeley Sockets", 123 | "aka": "POSIX sockets", 124 | "link": "https://en.wikipedia.org/wiki/Berkeley_sockets", 125 | "year": 1983 126 | }, 127 | { 128 | "id": "Winsock", 129 | "organization": "Microsoft", 130 | "link": "https://en.wikipedia.org/wiki/Winsock", 131 | "year": 1992 132 | }, 133 | { 134 | "id": "Input/Output Completion Port", 135 | "organization": "Microsoft", 136 | "abbr": "IOCP", 137 | "year": 1994 138 | }, 139 | { 140 | "id": "epoll", 141 | "author": "Davide Libenzi", 142 | "link": "https://en.wikipedia.org/wiki/Epoll", 143 | "year": 2002 144 | }, 145 | { 146 | "id": "libevent", 147 | "author": [ 148 | "Azat Khuzhin", 149 | "Mark Ellzey", 150 | "Nick Mathewson", 151 | "Niels Provos" 152 | ], 153 | "link": [ 154 | "https://libevent.org/", 155 | "https://github.com/libevent/libevent", 156 | "https://en.wikipedia.org/wiki/Libevent" 157 | ], 158 | "year": 2002 159 | } 160 | ], 161 | "links": [ 162 | { 163 | "source": "Computer Science", 164 | "target": "Computer Network" 165 | }, 166 | { 167 | "source": "Computer Network", 168 | "target": "Network Topology" 169 | }, 170 | { 171 | "source": "Network Topology", 172 | "target": "Client-server" 173 | }, 174 | { 175 | "source": "Network Topology", 176 | "target": "Peer-to-Peer" 177 | }, 178 | { 179 | "source": "Computer Network", 180 | "target": "Internet Protocol Suite" 181 | }, 182 | { 183 | "source": "Internet Protocol Suite", 184 | "target": "Link Layer" 185 | }, 186 | { 187 | "source": "Internet Protocol Suite", 188 | "target": "Internet Layer" 189 | }, 190 | { 191 | "source": "Internet Layer", 192 | "target": "Internet Protocol" 193 | }, 194 | { 195 | "source": "Internet Protocol", 196 | "target": "Internet Protocol Version 4" 197 | }, 198 | { 199 | "source": "Internet Protocol Version 4", 200 | "target": "Internet Protocol Version 6", 201 | "type": "derive" 202 | }, 203 | { 204 | "source": "Internet Protocol Suite", 205 | "target": "Transport Layer" 206 | }, 207 | { 208 | "source": "Transport Layer", 209 | "target": "Transmission Control Protocol" 210 | }, 211 | { 212 | "source": "Transport Layer", 213 | "target": "User Datagram Protocol" 214 | }, 215 | { 216 | "source": "Internet Protocol Suite", 217 | "target": "Application Layer" 218 | }, 219 | { 220 | "source": "Application Layer", 221 | "target": "Domain Name System" 222 | }, 223 | { 224 | "source": "Application Layer", 225 | "target": "Hypertext Transfer Protocol" 226 | }, 227 | { 228 | "source": "Hypertext Transfer Protocol", 229 | "target": "Hypertext Transfer Protocol Secure", 230 | "type": "derive" 231 | }, 232 | { 233 | "source": "Hypertext Transfer Protocol Secure", 234 | "target": "Transport Layer Security", 235 | "type": "use" 236 | }, 237 | { 238 | "source": "Application Layer", 239 | "target": "Transport Layer Security" 240 | }, 241 | { 242 | "source": "Transport Layer Security", 243 | "target": "OpenSSL" 244 | }, 245 | { 246 | "source": "Application Layer", 247 | "target": "KCP" 248 | }, 249 | { 250 | "source": "Computer Network", 251 | "target": "Network API" 252 | }, 253 | { 254 | "source": "Network API", 255 | "target": "Berkeley Sockets" 256 | }, 257 | { 258 | "source": "Network API", 259 | "target": "Winsock" 260 | }, 261 | { 262 | "source": "Network API", 263 | "target": "Input/Output Completion Port" 264 | }, 265 | { 266 | "source": "Network API", 267 | "target": "epoll" 268 | }, 269 | { 270 | "source": "Network API", 271 | "target": "libevent" 272 | }, 273 | { 274 | "source": "Computer Network", 275 | "target": "Serialization" 276 | }, 277 | { 278 | "source": "Computer Network", 279 | "target": "Data Compression" 280 | }, 281 | { 282 | "source": "Computer Network", 283 | "target": "Information Security" 284 | } 285 | ] 286 | } -------------------------------------------------------------------------------- /tech/multiplayer.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Multiplayer", 5 | "link": "https://en.wikipedia.org/wiki/Multiplayer_video_game" 6 | }, 7 | { 8 | "id": "Voice Communication" 9 | }, 10 | { 11 | "id": "Video Communication" 12 | }, 13 | { 14 | "id": "Synchronization" 15 | }, 16 | { 17 | "id": "Lockstep Synchronization" 18 | }, 19 | { 20 | "id": "State Replication" 21 | }, 22 | { 23 | "id": "Interest Management" 24 | }, 25 | { 26 | "id": "Zone-based Interest Management" 27 | }, 28 | { 29 | "id": "Area of Interest", 30 | "abbr": "AOI" 31 | }, 32 | { 33 | "id": "Aura-based Interest Management" 34 | }, 35 | { 36 | "id": "Visibility-based Interest Management" 37 | }, 38 | { 39 | "id": "Class-based Interest Management" 40 | }, 41 | { 42 | "id": "Hybrid Interest Management" 43 | }, 44 | { 45 | "id": "Interest Management Survey 2014", 46 | "author": [ 47 | "Elvis S. Liu", 48 | "Georgios K. Theodoropoulos" 49 | ], 50 | "title": "Interest management for distributed virtual environments: A survey", 51 | "journal": "CSUR", 52 | "link": "https://dl.acm.org/doi/pdf/10.1145/2535417", 53 | "year": 2014 54 | }, 55 | { 56 | "id": "Client-side Prediction", 57 | "link": "https://en.wikipedia.org/wiki/Client-side_prediction" 58 | }, 59 | { 60 | "id": "Dead Reckoning", 61 | "link": "https://en.wikipedia.org/wiki/Dead_reckoning#For_networked_games" 62 | }, 63 | { 64 | "id": "Matchmaking" 65 | }, 66 | { 67 | "id": "Ranking" 68 | }, 69 | { 70 | "id": "Social Relationship" 71 | }, 72 | { 73 | "id": "Multiplayer Performance" 74 | }, 75 | { 76 | "id": "Concurrent Player" 77 | }, 78 | { 79 | "id": "Ping Time" 80 | }, 81 | { 82 | "id": "Lag", 83 | "aka": "Latency" 84 | }, 85 | { 86 | "id": "Anti-cheating" 87 | }, 88 | { 89 | "id": "Game Server" 90 | }, 91 | { 92 | "id": "Distributed Architecture" 93 | }, 94 | { 95 | "id": "Persistence", 96 | "link": "https://en.wikipedia.org/wiki/Persistence_(computer_science)" 97 | }, 98 | { 99 | "id": "Transaction" 100 | }, 101 | { 102 | "id": "Gateway Server" 103 | }, 104 | { 105 | "id": "Lobby Server" 106 | }, 107 | { 108 | "id": "World Server" 109 | }, 110 | { 111 | "id": "Dedicated Server", 112 | "abbr": "DS" 113 | }, 114 | { 115 | "id": "Cloud Computing" 116 | }, 117 | { 118 | "id": "Multiplayer Middleware" 119 | }, 120 | { 121 | "id": "Multiplayer API" 122 | }, 123 | { 124 | "id": "Xbox Live", 125 | "organization": "Microsoft", 126 | "link": [ 127 | "https://docs.microsoft.com/en-us/gaming/xbox-live/", 128 | "https://en.wikipedia.org/wiki/Xbox_Live" 129 | ], 130 | "year": 2002 131 | }, 132 | { 133 | "id": "Steamworks", 134 | "organization": "Valve", 135 | "link": [ 136 | "https://partner.steamgames.com/", 137 | "https://en.wikipedia.org/wiki/Steam_(service)#Steamworks" 138 | ], 139 | "year": 2008 140 | }, 141 | { 142 | "id": "Open Source Multiplayer Middleware" 143 | }, 144 | { 145 | "id": "RakNet", 146 | "organization": "Facebook", 147 | "link": [ 148 | "https://github.com/facebookarchive/RakNet", 149 | "http://www.raknet.com/", 150 | "https://en.wikipedia.org/wiki/RakNet" 151 | ], 152 | "year": 2001 153 | }, 154 | { 155 | "id": "Nakama", 156 | "organization": "Heroic Labs", 157 | "link": [ 158 | "https://heroiclabs.com/", 159 | "https://github.com/heroiclabs" 160 | ], 161 | "year": 2017 162 | }, 163 | { 164 | "id": "Commercial Multiplayer Middleware" 165 | }, 166 | { 167 | "id": "Photon Realtime", 168 | "link": "https://www.photonengine.com/en-US/Realtime" 169 | }, 170 | { 171 | "id": "SpatialOS", 172 | "organization": "Improbable", 173 | "link": "https://www.improbable.io/", 174 | "year": 2015 175 | } 176 | ], 177 | "links": [ 178 | { 179 | "source": "Technology", 180 | "target": "Multiplayer" 181 | }, 182 | { 183 | "source": "Multiplayer", 184 | "target": "Computer Network" 185 | }, 186 | { 187 | "source": "Multiplayer", 188 | "target": "Voice Communication" 189 | }, 190 | { 191 | "source": "Multiplayer", 192 | "target": "Video Communication" 193 | }, 194 | { 195 | "source": "Multiplayer", 196 | "target": "Synchronization" 197 | }, 198 | { 199 | "source": "Synchronization", 200 | "target": "State Replication" 201 | }, 202 | { 203 | "source": "Synchronization", 204 | "target": "Interest Management" 205 | }, 206 | { 207 | "source": "Interest Management", 208 | "target": "Zone-based Interest Management" 209 | }, 210 | { 211 | "source": "Zone-based Interest Management", 212 | "target": "Area of Interest" 213 | }, 214 | { 215 | "source": "Interest Management", 216 | "target": "Aura-based Interest Management" 217 | }, 218 | { 219 | "source": "Interest Management", 220 | "target": "Visibility-based Interest Management" 221 | }, 222 | { 223 | "source": "Interest Management", 224 | "target": "Class-based Interest Management" 225 | }, 226 | { 227 | "source": "Interest Management", 228 | "target": "Hybrid Interest Management" 229 | }, 230 | { 231 | "source": "Interest Management", 232 | "target": "Interest Management Survey 2014" 233 | }, 234 | { 235 | "source": "Synchronization", 236 | "target": "Client-side Prediction" 237 | }, 238 | { 239 | "source": "Synchronization", 240 | "target": "Dead Reckoning" 241 | }, 242 | { 243 | "source": "Synchronization", 244 | "target": "Lockstep Synchronization" 245 | }, 246 | { 247 | "source": "Multiplayer", 248 | "target": "Matchmaking" 249 | }, 250 | { 251 | "source": "Multiplayer", 252 | "target": "Ranking" 253 | }, 254 | { 255 | "source": "Multiplayer", 256 | "target": "Social Relationship" 257 | }, 258 | { 259 | "source": "Multiplayer", 260 | "target": "Multiplayer Performance" 261 | }, 262 | { 263 | "source": "Multiplayer Performance", 264 | "target": "Concurrent Player" 265 | }, 266 | { 267 | "source": "Multiplayer Performance", 268 | "target": "Ping Time" 269 | }, 270 | { 271 | "source": "Multiplayer Performance", 272 | "target": "Lag" 273 | }, 274 | { 275 | "source": "Multiplayer", 276 | "target": "Anti-cheating" 277 | }, 278 | { 279 | "source": "Multiplayer", 280 | "target": "Game Server" 281 | }, 282 | { 283 | "source": "Game Server", 284 | "target": "Distributed Architecture" 285 | }, 286 | { 287 | "source": "Game Server", 288 | "target": "Persistence" 289 | }, 290 | { 291 | "source": "Game Server", 292 | "target": "Transaction" 293 | }, 294 | { 295 | "source": "Game Server", 296 | "target": "Gateway Server" 297 | }, 298 | { 299 | "source": "Game Server", 300 | "target": "Lobby Server" 301 | }, 302 | { 303 | "source": "Game Server", 304 | "target": "World Server" 305 | }, 306 | { 307 | "source": "Game Server", 308 | "target": "Dedicated Server" 309 | }, 310 | { 311 | "source": "Game Server", 312 | "target": "Cloud Computing" 313 | }, 314 | { 315 | "source": "Multiplayer", 316 | "target": "Multiplayer Middleware" 317 | }, 318 | { 319 | "source": "Multiplayer Middleware", 320 | "target": "Multiplayer API" 321 | }, 322 | { 323 | "source": "Multiplayer API", 324 | "target": "Xbox Live" 325 | }, 326 | { 327 | "source": "Multiplayer API", 328 | "target": "Steamworks" 329 | }, 330 | { 331 | "source": "Multiplayer Middleware", 332 | "target": "Open Source Multiplayer Middleware" 333 | }, 334 | { 335 | "source": "Open Source Multiplayer Middleware", 336 | "target": "RakNet" 337 | }, 338 | { 339 | "source": "Open Source Multiplayer Middleware", 340 | "target": "Nakama" 341 | }, 342 | { 343 | "source": "Multiplayer Middleware", 344 | "target": "Commercial Multiplayer Middleware" 345 | }, 346 | { 347 | "source": "Commercial Multiplayer Middleware", 348 | "target": "Photon Realtime" 349 | }, 350 | { 351 | "source": "Commercial Multiplayer Middleware", 352 | "target": "SpatialOS" 353 | } 354 | ] 355 | } -------------------------------------------------------------------------------- /tech/graphics/rendering/lighting.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Lighting" 5 | }, 6 | { 7 | "id": "Light Attenuation" 8 | }, 9 | { 10 | "id": "Light Source" 11 | }, 12 | { 13 | "id": "Ambient Light" 14 | }, 15 | { 16 | "id": "Directional Light" 17 | }, 18 | { 19 | "id": "Punctual Light" 20 | }, 21 | { 22 | "id": "Point Light", 23 | "aka": [ 24 | "Omnidirectional Light", 25 | "Omni Light" 26 | ] 27 | }, 28 | { 29 | "id": "Spot Light" 30 | }, 31 | { 32 | "id": "Area Light" 33 | }, 34 | { 35 | "id": "Polygonal Light" 36 | }, 37 | { 38 | "id": "Linearly Transformed Cosines", 39 | "abbr": "LTCs", 40 | "author": [ 41 | "Eric Heitz", 42 | "Jonathan Dupuy", 43 | "Stephen Hill", 44 | "David Neubelt" 45 | ], 46 | "title": "Real-Time Polygonal-Light Shading with Linearly Transformed Cosines", 47 | "link": "https://eheitzresearch.wordpress.com/415-2/", 48 | "conference": "SIGGRAPH", 49 | "year": 2016 50 | }, 51 | { 52 | "id": "Photometric Light" 53 | }, 54 | { 55 | "id": "IES Profile" 56 | }, 57 | { 58 | "id": "Precomputed Lighting" 59 | }, 60 | { 61 | "id": "Light Map", 62 | "aka": [ 63 | "Lightmap", 64 | "Radiosity light map" 65 | ], 66 | "link": "https://en.wikipedia.org/wiki/Lightmap" 67 | }, 68 | { 69 | "id": "Radiosity Normal Mapping", 70 | "abbr": "RNM", 71 | "author": "Gary McTaggart", 72 | "conference": "GDC", 73 | "link": "https://drivers.amd.com/developer/gdc/D3DTutorial10_Half-Life2_Shading.pdf", 74 | "year": 2004 75 | }, 76 | { 77 | "id": "Precomputed Radiance Transfer", 78 | "abbr": "PRT" 79 | }, 80 | { 81 | "id": "Irradiance Volume", 82 | "author": [ 83 | "Gene Greger", 84 | "Peter Shirley", 85 | "Philip M. Hubbard", 86 | "Donald P. Greenb" 87 | ], 88 | "title": "The irradiance volume", 89 | "conference": "CG&A", 90 | "year": 1998 91 | }, 92 | { 93 | "id": "Image-based Lighting", 94 | "abbr": "IBL", 95 | "link": "https://en.wikipedia.org/wiki/Image-based_lighting" 96 | }, 97 | { 98 | "id": "Irradiance Environment Map", 99 | "author": [ 100 | "Ravi Ramamoorthi", 101 | "Pat Hanrahan" 102 | ], 103 | "title": "An efficient representation for irradiance environment maps", 104 | "conference": "SIGGRAPH", 105 | "link": [ 106 | "https://dl.acm.org/doi/pdf/10.1145/383259.383317", 107 | "https://en.wikipedia.org/wiki/Spherical_harmonic_lighting" 108 | ], 109 | "year": 2001 110 | }, 111 | { 112 | "id": "Spherical Harmonic Lighting", 113 | "aka": "SH Lighting", 114 | "author": [ 115 | "Jan Kautz", 116 | "John Snyder", 117 | "Peter-Pike J. Sloan" 118 | ], 119 | "title": "Fast Arbitrary BRDF Shading for Low-Frequency Lighting Using Spherical Harmonics", 120 | "link": [ 121 | "https://www.ppsloan.org/publications/shbrdf_final17.pdf", 122 | "https://en.wikipedia.org/wiki/Spherical_harmonic_lighting" 123 | ], 124 | "year": 2002 125 | }, 126 | { 127 | "id": "Ambient Occlusion", 128 | "abbr": "AO" 129 | }, 130 | { 131 | "id": "Global Illumination", 132 | "abbr": "GI" 133 | }, 134 | { 135 | "id": "Offline Global Illumination" 136 | }, 137 | { 138 | "id": "Realtime Global Illumination" 139 | }, 140 | { 141 | "id": "Ray Tracing", 142 | "author": "John Turner Whitted", 143 | "title": "An improved illumination model for shaded display.", 144 | "conference": "SIGGRAPH", 145 | "year": 1979 146 | }, 147 | { 148 | "id": "Distributed Ray Tracing", 149 | "author": [ 150 | "Robert L. Cook", 151 | "Thomas Porter", 152 | "Loren Carpenter" 153 | ], 154 | "conference": "SIGGRAPH", 155 | "link": "https://dl.acm.org/doi/pdf/10.1145/800031.808590", 156 | "year": 1984 157 | }, 158 | { 159 | "id": "Path Tracing" 160 | }, 161 | { 162 | "id": "Radiosity", 163 | "author": [ 164 | "Cindy M. Goral", 165 | "Kenneth E. Torrance", 166 | "Donald P. Greenberg", 167 | "Bennett Battaile" 168 | ], 169 | "title": "Modeling the interaction of light between diffuse surfaces", 170 | "conference": "SIGGRAPH", 171 | "link": [ 172 | "https://dl.acm.org/doi/pdf/10.1145/964965.808601", 173 | "https://en.wikipedia.org/wiki/Radiosity_(computer_graphics)" 174 | ], 175 | "year": 1984 176 | }, 177 | { 178 | "id": "Photon Mapping" 179 | }, 180 | { 181 | "id": "Realtime Ray Tracing" 182 | }, 183 | { 184 | "id": "Reflective Shadow Map", 185 | "abbr": "RSM", 186 | "author": [ 187 | "Carsten Dachsbacher", 188 | "Marc Stamminger" 189 | ], 190 | "title": "Reflective shadow maps", 191 | "conference": "I3D", 192 | "link": "https://dl.acm.org/doi/pdf/10.1145/1053427.1053460", 193 | "year": 2005 194 | }, 195 | { 196 | "id": "Light Propagation Volume", 197 | "abbr": "LPV", 198 | "author": "Anton Kaplanyan", 199 | "title": "Light propagation volumes in cryengine 3", 200 | "conference": "SIGGRAPH", 201 | "year": 2009 202 | }, 203 | { 204 | "id": "Cascaded Light Propagation Volume", 205 | "author": [ 206 | "Anton Kaplanyan", 207 | "Carsten Dachsbacher" 208 | ], 209 | "title": "Cascaded light propagation volumes for real-time indirect illumination", 210 | "conference": "I3D", 211 | "year": 2010 212 | }, 213 | { 214 | "id": "Voxel Cone Tracing", 215 | "abbr": "VCT", 216 | "author": "Cyril Crassin", 217 | "title": "Interactive indirect illumination using voxel cone tracing", 218 | "journal": "Computer Graphics Forum", 219 | "year": 2011 220 | }, 221 | { 222 | "id": "Dynamic Diffuse Global Illumination", 223 | "abbr": "DDGI", 224 | "author": [ 225 | "Zander Majercik", 226 | "Jean-Philippe Guertin", 227 | "Derek Nowrouzezahrai", 228 | "Morgan McGuire" 229 | ], 230 | "title": "Dynamic diffuse global illumination with ray-traced irradiance fields", 231 | "link": "http://cim.mcgill.ca/~derek/files/DDGI-lowres.pdf", 232 | "year": 2019 233 | } 234 | ], 235 | "links": [ 236 | { 237 | "source": "Rendering", 238 | "target": "Lighting" 239 | }, 240 | { 241 | "source": "Lighting", 242 | "target": "Light Attenuation" 243 | }, 244 | { 245 | "source": "Lighting", 246 | "target": "Light Source" 247 | }, 248 | { 249 | "source": "Light Source", 250 | "target": "Ambient Light" 251 | }, 252 | { 253 | "source": "Ambient Light", 254 | "target": "Ambient Occlusion" 255 | }, 256 | { 257 | "source": "Light Source", 258 | "target": "Directional Light" 259 | }, 260 | { 261 | "source": "Light Source", 262 | "target": "Punctual Light" 263 | }, 264 | { 265 | "source": "Punctual Light", 266 | "target": "Point Light" 267 | }, 268 | { 269 | "source": "Punctual Light", 270 | "target": "Spot Light" 271 | }, 272 | { 273 | "source": "Light Source", 274 | "target": "Area Light" 275 | }, 276 | { 277 | "source": "Area Light", 278 | "target": "Polygonal Light" 279 | }, 280 | { 281 | "source": "Polygonal Light", 282 | "target": "Linearly Transformed Cosines" 283 | }, 284 | { 285 | "source": "Light Source", 286 | "target": "Photometric Light" 287 | }, 288 | { 289 | "source": "Photometric Light", 290 | "target": "IES Profile" 291 | }, 292 | { 293 | "source": "Light Source", 294 | "target": "Projective Texture Mapping" 295 | }, 296 | { 297 | "source": "Lighting", 298 | "target": "Precomputed Lighting" 299 | }, 300 | { 301 | "source": "Precomputed Lighting", 302 | "target": "Light Map" 303 | }, 304 | { 305 | "source": "Precomputed Lighting", 306 | "target": "Radiosity Normal Mapping" 307 | }, 308 | { 309 | "source": "Precomputed Lighting", 310 | "target": "Precomputed Radiance Transfer" 311 | }, 312 | { 313 | "source": "Precomputed Lighting", 314 | "target": "Irradiance Volume" 315 | }, 316 | { 317 | "source": "Lighting", 318 | "target": "Image-based Lighting" 319 | }, 320 | { 321 | "source": "Image-based Lighting", 322 | "target": "Irradiance Environment Map" 323 | }, 324 | { 325 | "source": "Image-based Lighting", 326 | "target": "Spherical Harmonic Lighting" 327 | }, 328 | { 329 | "source": "Lighting", 330 | "target": "Global Illumination" 331 | }, 332 | { 333 | "source": "Global Illumination", 334 | "target": "Offline Global Illumination" 335 | }, 336 | { 337 | "source": "Offline Global Illumination", 338 | "target": "Ray Tracing" 339 | }, 340 | { 341 | "source": "Ray Tracing", 342 | "target": "Distributed Ray Tracing", 343 | "type": "derive" 344 | }, 345 | { 346 | "source": "Offline Global Illumination", 347 | "target": "Path Tracing" 348 | }, 349 | { 350 | "source": "Offline Global Illumination", 351 | "target": "Radiosity" 352 | }, 353 | { 354 | "source": "Offline Global Illumination", 355 | "target": "Photon Mapping" 356 | }, 357 | { 358 | "source": "Global Illumination", 359 | "target": "Realtime Global Illumination" 360 | }, 361 | { 362 | "source": "Realtime Global Illumination", 363 | "target": "Reflective Shadow Map" 364 | }, 365 | { 366 | "source": "Realtime Global Illumination", 367 | "target": "Imperfect Shadow Map" 368 | }, 369 | { 370 | "source": "Realtime Global Illumination", 371 | "target": "Light Propagation Volume" 372 | }, 373 | { 374 | "source": "Light Propagation Volume", 375 | "target": "Cascaded Light Propagation Volume", 376 | "type": "derive" 377 | }, 378 | { 379 | "source": "Realtime Global Illumination", 380 | "target": "Voxel Cone Tracing" 381 | }, 382 | { 383 | "source": "Realtime Global Illumination", 384 | "target": "Realtime Ray Tracing" 385 | }, 386 | { 387 | "source": "Ray Tracing", 388 | "target": "Realtime Ray Tracing", 389 | "type": "derive" 390 | }, 391 | { 392 | "source": "Realtime Global Illumination", 393 | "target": "Dynamic Diffuse Global Illumination" 394 | } 395 | ] 396 | } -------------------------------------------------------------------------------- /tech/cs/datastruct.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Data Structure", 5 | "link": "https://en.wikipedia.org/wiki/Data_structure" 6 | }, 7 | { 8 | "id": "Array Data Structure", 9 | "aka": "Array", 10 | "link": "https://en.wikipedia.org/wiki/Array_data_structure" 11 | }, 12 | { 13 | "id": "Dynamic Array", 14 | "aka": [ 15 | "Growable Array", 16 | "Resizable Array", 17 | "Dynamic Table", 18 | "Mutable Array", 19 | "Array List" 20 | ], 21 | "link": "https://en.wikipedia.org/wiki/Dynamic_array" 22 | }, 23 | { 24 | "id": "Sorted Array", 25 | "link": "https://en.wikipedia.org/wiki/Sorted_array" 26 | }, 27 | { 28 | "id": "Bit Array", 29 | "link": "https://en.wikipedia.org/wiki/Bit_array" 30 | }, 31 | { 32 | "id": "Circular Buffer", 33 | "link": "https://en.wikipedia.org/wiki/Circular_buffer" 34 | }, 35 | { 36 | "id": "Linked Data Structure", 37 | "link": "https://en.wikipedia.org/wiki/Linked_data_structure" 38 | }, 39 | { 40 | "id": "Linked List", 41 | "link": "https://en.wikipedia.org/wiki/Linked_list" 42 | }, 43 | { 44 | "id": "Singly Linked List", 45 | "link": "https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list" 46 | }, 47 | { 48 | "id": "Doubly Linked List", 49 | "link": "https://en.wikipedia.org/wiki/Doubly_linked_list" 50 | }, 51 | { 52 | "id": "Circular Linked List", 53 | "link": "https://en.wikipedia.org/wiki/Linked_list#Circularly_linked_list" 54 | }, 55 | { 56 | "id": "Free List", 57 | "link": "https://en.wikipedia.org/wiki/Free_list" 58 | }, 59 | { 60 | "id": "Tree Data Structure", 61 | "link": "https://en.wikipedia.org/wiki/Tree_(data_structure)" 62 | }, 63 | { 64 | "id": "Binary Tree", 65 | "link": "https://en.wikipedia.org/wiki/Binary_tree" 66 | }, 67 | { 68 | "id": "Binary Search Tree", 69 | "abbr": "BST", 70 | "link": "https://en.wikipedia.org/wiki/Binary_search_tree" 71 | }, 72 | { 73 | "id": "Self-balancing Binary Search Tree", 74 | "link": "https://en.wikipedia.org/wiki/Self-balancing_binary_search_tree" 75 | }, 76 | { 77 | "id": "AVL tree", 78 | "author": [ 79 | "Georgy Adelson-Velsky", 80 | "Evgenii Landis" 81 | ], 82 | "title": "An algorithm for the organization of information", 83 | "journal": "Proceedings of the USSR Academy of Sciences", 84 | "link": "https://en.wikipedia.org/wiki/AVL_tree", 85 | "year": 1962 86 | }, 87 | { 88 | "id": "Red-black Tree", 89 | "author": "Rudolf Bayer", 90 | "title": "Symmetric binary B-Trees: Data structure and maintenance algorithms", 91 | "journal": "Acta Informatica", 92 | "link": [ 93 | "https://docs.lib.purdue.edu/cgi/viewcontent.cgi?article=1457&context=cstech", 94 | "https://en.wikipedia.org/wiki/Red%E2%80%93black_tree" 95 | ], 96 | "year": 1972 97 | }, 98 | { 99 | "id": "Left-leaning red–black tree", 100 | "abbr": "LLRB", 101 | "author": "Robert Sedgewick", 102 | "title": "Left-Leaning Red–Black Trees", 103 | "link": [ 104 | "https://www.cs.princeton.edu/~rs/talks/LLRB/LLRB.pdf", 105 | "https://en.wikipedia.org/wiki/Left-leaning_red%E2%80%93black_tree" 106 | ], 107 | "year": 2008 108 | }, 109 | { 110 | "id": "Trie", 111 | "aka": [ 112 | "Digital Tree", 113 | "Prefix Tree" 114 | ], 115 | "author": "Axel Thue", 116 | "title": "Über die gegenseitige Lage gleicher Teile gewisser Zeichenreihen", 117 | "journal": "Skrifter udgivne af Videnskabs-Selskabet i Christiania", 118 | "link": "https://en.wikipedia.org/wiki/Trie", 119 | "year": 1912 120 | }, 121 | { 122 | "id": "Suffix Tree", 123 | "aka": "PAT tree", 124 | "author": "Peter Weiner", 125 | "title": "Linear pattern matching algorithms", 126 | "conference": "14th Annual IEEE Symposium on Switching and Automata Theory", 127 | "link": [ 128 | "https://cpsc.yale.edu/sites/default/files/files/technical-reports/TR17%20Linear%20Pattern%20Matching%20ALgorithms.pdf", 129 | "https://en.wikipedia.org/wiki/Suffix_tree" 130 | ], 131 | "year": 1973 132 | }, 133 | { 134 | "id": "Radix Tree", 135 | "aka": [ 136 | "Radix Trie", 137 | "Compact Prefix Tree" 138 | ], 139 | "link": "https://en.wikipedia.org/wiki/Radix_tree" 140 | }, 141 | { 142 | "id": "Heap Data Structure", 143 | "link": "https://en.wikipedia.org/wiki/Heap_(data_structure)" 144 | }, 145 | { 146 | "id": "Binary Heap", 147 | "author": "J. W. J. Williams", 148 | "title": "Algorithm 232 - Heapsort", 149 | "journal": " Communications of the ACM", 150 | "link": "https://en.wikipedia.org/wiki/Binary_heap", 151 | "year": 1964 152 | }, 153 | { 154 | "id": "Mergeable Heap", 155 | "link": "https://en.wikipedia.org/wiki/Mergeable_heap" 156 | }, 157 | { 158 | "id": "Binomial Heap", 159 | "author": "Jean Vuillemin", 160 | "title": "A data structure for manipulating priority queues", 161 | "journal": "Communications of the ACM", 162 | "link": [ 163 | "https://dl.acm.org/doi/pdf/10.1145/359460.359478", 164 | "https://en.wikipedia.org/wiki/Binomial_heap" 165 | ], 166 | "year": 1978 167 | }, 168 | { 169 | "id": "Fibonacci Heap", 170 | "author": [ 171 | "Michael L. Fredman", 172 | "Robert Endre Tarjan" 173 | ], 174 | "title": "Fibonacci heaps and their uses in improved network optimization algorithms", 175 | "journal": "Journal of ACM", 176 | "link": [ 177 | "http://bioinfo.ict.ac.cn/~dbu/AlgorithmCourses/Lectures/Fibonacci-Heap-Tarjan.pdf", 178 | "https://en.wikipedia.org/wiki/Fibonacci_heap" 179 | ], 180 | "year": 1984 181 | }, 182 | { 183 | "id": "Hash-based Structure" 184 | }, 185 | { 186 | "id": "Hash Table", 187 | "author": "Hans Peter Luhn", 188 | "link": "https://en.wikipedia.org/wiki/Hash_table", 189 | "year": 1953 190 | }, 191 | { 192 | "id": "Hash Function", 193 | "link": "https://en.wikipedia.org/wiki/Hash_function" 194 | }, 195 | { 196 | "id": "Perfect Hash Function", 197 | "link": "https://en.wikipedia.org/wiki/Perfect_hash_function" 198 | }, 199 | { 200 | "id": "Fowler–Noll–Vo Hash Function", 201 | "abbr": "FNV", 202 | "author": [ 203 | "Glenn Fowler", 204 | "Landon Curt Noll", 205 | "Kiem-Phong Vo" 206 | ], 207 | "link": "https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function", 208 | "year": 1991 209 | }, 210 | { 211 | "id": "xxHash", 212 | "author": "Yann Collet", 213 | "link": [ 214 | "https://cyan4973.github.io/xxHash/", 215 | "https://github.com/Cyan4973/xxHash" 216 | ], 217 | "year": 2014 218 | }, 219 | { 220 | "id": "t1ha", 221 | "organization": "Positive Technologies", 222 | "link": "https://github.com/erthink/t1ha", 223 | "year": 2016 224 | }, 225 | { 226 | "id": "wyhash", 227 | "author": "Yi Wang", 228 | "link": "https://github.com/wangyi-fudan/wyhash", 229 | "year": 2019 230 | }, 231 | { 232 | "id": "Bloom Filter", 233 | "author": "Burton Howard Bloom", 234 | "link": "https://en.wikipedia.org/wiki/Bloom_filter", 235 | "year": 1970 236 | } 237 | ], 238 | "links": [ 239 | { 240 | "source": "Computer Science", 241 | "target": "Data Structure" 242 | }, 243 | { 244 | "source": "Data Structure", 245 | "target": "Array Data Structure" 246 | }, 247 | { 248 | "source": "Array Data Structure", 249 | "target": "Dynamic Array" 250 | }, 251 | { 252 | "source": "Array Data Structure", 253 | "target": "Sorted Array" 254 | }, 255 | { 256 | "source": "Array Data Structure", 257 | "target": "Bit Array" 258 | }, 259 | { 260 | "source": "Array Data Structure", 261 | "target": "Circular Buffer" 262 | }, 263 | { 264 | "source": "Data Structure", 265 | "target": "Linked Data Structure" 266 | }, 267 | { 268 | "source": "Linked Data Structure", 269 | "target": "Linked List" 270 | }, 271 | { 272 | "source": "Linked List", 273 | "target": "Singly Linked List" 274 | }, 275 | { 276 | "source": "Linked List", 277 | "target": "Doubly Linked List" 278 | }, 279 | { 280 | "source": "Linked List", 281 | "target": "Circular Linked List" 282 | }, 283 | { 284 | "source": "Linked Data Structure", 285 | "target": "Free List" 286 | }, 287 | { 288 | "source": "Data Structure", 289 | "target": "Tree Data Structure" 290 | }, 291 | { 292 | "source": "Tree Data Structure", 293 | "target": "Binary Tree" 294 | }, 295 | { 296 | "source": "Binary Tree", 297 | "target": "Binary Search Tree" 298 | }, 299 | { 300 | "source": "Binary Search Tree", 301 | "target": "Self-balancing Binary Search Tree" 302 | }, 303 | { 304 | "source": "Self-balancing Binary Search Tree", 305 | "target": "AVL tree" 306 | }, 307 | { 308 | "source": "Self-balancing Binary Search Tree", 309 | "target": "Red-black Tree" 310 | }, 311 | { 312 | "source": "Red-black Tree", 313 | "target": "Left-leaning red–black tree", 314 | "type": "derive" 315 | }, 316 | { 317 | "source": "Tree Data Structure", 318 | "target": "Trie" 319 | }, 320 | { 321 | "source": "Trie", 322 | "target": "Suffix Tree", 323 | "type": "derive" 324 | }, 325 | { 326 | "source": "Trie", 327 | "target": "Radix Tree", 328 | "type": "derive" 329 | }, 330 | { 331 | "source": "Data Structure", 332 | "target": "Heap Data Structure" 333 | }, 334 | { 335 | "source": "Heap Data Structure", 336 | "target": "Binary Heap" 337 | }, 338 | { 339 | "source": "Heap Data Structure", 340 | "target": "Mergeable Heap" 341 | }, 342 | { 343 | "source": "Mergeable Heap", 344 | "target": "Binomial Heap" 345 | }, 346 | { 347 | "source": "Mergeable Heap", 348 | "target": "Fibonacci Heap" 349 | }, 350 | { 351 | "source": "Data Structure", 352 | "target": "Hash-based Structure" 353 | }, 354 | { 355 | "source": "Hash-based Structure", 356 | "target": "Hash Table" 357 | }, 358 | { 359 | "source": "Hash-based Structure", 360 | "target": "Hash Function" 361 | }, 362 | { 363 | "source": "Hash Function", 364 | "target": "Perfect Hash Function" 365 | }, 366 | { 367 | "source": "Hash Function", 368 | "target": "Fowler–Noll–Vo Hash Function" 369 | }, 370 | { 371 | "source": "Hash Function", 372 | "target": "xxHash" 373 | }, 374 | { 375 | "source": "Hash Function", 376 | "target": "t1ha" 377 | }, 378 | { 379 | "source": "Hash Function", 380 | "target": "wyhash" 381 | }, 382 | { 383 | "source": "Hash Function", 384 | "target": "Cryptographic Hash Function" 385 | }, 386 | { 387 | "source": "Hash-based Structure", 388 | "target": "Bloom Filter" 389 | } 390 | ] 391 | } -------------------------------------------------------------------------------- /tech/graphics/image.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Image", 5 | "aka": "Digital Image", 6 | "link": "https://en.wikipedia.org/wiki/Digital_image" 7 | }, 8 | { 9 | "id": "Pixel", 10 | "aka": "Picture Element", 11 | "link": "https://en.wikipedia.org/wiki/Pixel", 12 | "year": 1965 13 | }, 14 | { 15 | "id": "Color Space" 16 | }, 17 | { 18 | "id": "XYZ Color Space", 19 | "aka": "CIE 1931 Color Space", 20 | "link": "https://en.wikipedia.org/wiki/CIE_1931_color_space", 21 | "year": 1931 22 | }, 23 | { 24 | "id": "RGB Color Space", 25 | "link": "https://en.wikipedia.org/wiki/RGB_color_space", 26 | "year": 1931 27 | }, 28 | { 29 | "id": "sRGB Color Space", 30 | "link": "https://en.wikipedia.org/wiki/SRGB", 31 | "year": 1996 32 | }, 33 | { 34 | "id": "YUV Color Space", 35 | "link": "https://en.wikipedia.org/wiki/YUV" 36 | }, 37 | { 38 | "id": "YCbCr Color Space", 39 | "link": "https://en.wikipedia.org/wiki/YCbCr", 40 | "year": 1982 41 | }, 42 | { 43 | "id": "HSV Color Space", 44 | "aka": "HSB Color Space", 45 | "author": "Alvy Ray Smith", 46 | "title": "Color gamut transform pairs", 47 | "conference": "SIGGRAPH", 48 | "link": "https://en.wikipedia.org/wiki/HSL_and_HSV", 49 | "year": 1978 50 | }, 51 | { 52 | "id": "Image File Format", 53 | "link": "https://en.wikipedia.org/wiki/Image_file_formats" 54 | }, 55 | { 56 | "id": "Truevision Advanced Raster Graphics Adapter", 57 | "abbr": [ 58 | "TARGA", 59 | "TGA" 60 | ], 61 | "link": "https://en.wikipedia.org/wiki/Truevision_TGA", 62 | "year": 1984 63 | }, 64 | { 65 | "id": "Portable Network Graphics", 66 | "abbr": "PNG", 67 | "link": [ 68 | "https://en.wikipedia.org/wiki/Portable_Network_Graphics", 69 | "https://www.w3.org/TR/2003/REC-PNG-20031110/" 70 | ], 71 | "year": 1996 72 | }, 73 | { 74 | "id": "Joint Photographic Experts Group", 75 | "abbr": "JPEG", 76 | "link": [ 77 | "https://jpeg.org/", 78 | "https://en.wikipedia.org/wiki/JPEG" 79 | ], 80 | "year": 1992 81 | }, 82 | { 83 | "id": "WebP", 84 | "link": [ 85 | "https://developers.google.com/speed/webp", 86 | "https://en.wikipedia.org/wiki/WebP" 87 | ], 88 | "year": 2010 89 | }, 90 | { 91 | "id": "DirectDraw Surface", 92 | "abbr": "DDS", 93 | "link": [ 94 | "https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds", 95 | "https://en.wikipedia.org/wiki/DirectDraw_Surface" 96 | ], 97 | "year": 1999 98 | }, 99 | { 100 | "id": "Image Processing", 101 | "aka": "Digital Image Processing", 102 | "link": "https://en.wikipedia.org/wiki/Digital_image_processing" 103 | }, 104 | { 105 | "id": "Convolution", 106 | "link": "https://en.wikipedia.org/wiki/Convolution" 107 | }, 108 | { 109 | "id": "Separable Filter", 110 | "link": "https://en.wikipedia.org/wiki/Separable_filter" 111 | }, 112 | { 113 | "id": "Low Pass Filter", 114 | "aka": "Blur Filter" 115 | }, 116 | { 117 | "id": "Box Blur", 118 | "aka": "Box Filter", 119 | "link": "https://en.wikipedia.org/wiki/Box_blur" 120 | }, 121 | { 122 | "id": "Gaussian Blur", 123 | "aka": "Guassian Filter", 124 | "link": "https://en.wikipedia.org/wiki/Gaussian_blur" 125 | }, 126 | { 127 | "id": "Kawase Blur", 128 | "author": "Masaki Kawase", 129 | "title": "Frame Buffer Postprocessing Effects in DOUBLE-S.T.E.A.L. (Wreckless)", 130 | "conference": "GDC", 131 | "year": 2003 132 | }, 133 | { 134 | "id": "Dual Kawase Blur", 135 | "author": "Marius Bjørge", 136 | "title": "Bandwidth-Efficient Rendering", 137 | "conference": "SIGGRAPH", 138 | "link": "https://community.arm.com/cfs-file/__key/communityserver-blogs-components-weblogfiles/00-00-00-20-66/siggraph2015_2D00_mmg_2D00_marius_2D00_notes.pdf", 139 | "year": 2015 140 | }, 141 | { 142 | "id": "Edge Detection", 143 | "link": "https://en.wikipedia.org/wiki/Edge_detection" 144 | }, 145 | { 146 | "id": "Fourier Transform", 147 | "link": "https://en.wikipedia.org/wiki/Fourier_transform" 148 | }, 149 | { 150 | "id": "Fast Fourier Transform", 151 | "abbr": "FFT", 152 | "author": "E. Oran Brigham", 153 | "title": "The fast Fourier transform and its applications", 154 | "link": "https://en.wikipedia.org/wiki/Fast_Fourier_transform", 155 | "year": 1988 156 | }, 157 | { 158 | "id": "Bilaterial Filter", 159 | "link": "https://en.wikipedia.org/wiki/Bilateral_filter" 160 | }, 161 | { 162 | "id": "Color Transform" 163 | }, 164 | { 165 | "id": "Color Transform by Lookup Table", 166 | "aka": "LUT Color Transform", 167 | "author": "Jeremy Selan", 168 | "title": "Using lookup tables to accelerate color transformations", 169 | "journal": "GPU Gems 2", 170 | "link": "https://developer.nvidia.com/gpugems/gpugems2/part-iii-high-quality-rendering/chapter-24-using-lookup-tables-accelerate-color", 171 | "year": 2004 172 | }, 173 | { 174 | "id": "Gamma Correction", 175 | "aka": "Gamma", 176 | "link": "https://en.wikipedia.org/wiki/Gamma_correction" 177 | }, 178 | { 179 | "id": "Tone Mapping", 180 | "aka": "Tone Reproduction", 181 | "link": "https://en.wikipedia.org/wiki/Tone_mapping" 182 | }, 183 | { 184 | "id": "Local Tone Mapping" 185 | }, 186 | { 187 | "id": "Global Tone Mapping" 188 | }, 189 | { 190 | "id": "Tone Reproduction Transform" 191 | }, 192 | { 193 | "id": "Reinhard Tone Mapping", 194 | "author": [ 195 | "Erik Reinhard", 196 | "Michael Stark", 197 | "Peter Shirley", 198 | "James Ferwerda" 199 | ], 200 | "title": "Photographic tone reproduction for digital images", 201 | "conference": "SIGGRAPH", 202 | "link": "https://dl.acm.org/doi/pdf/10.1145/566570.566575", 203 | "year": 2002 204 | }, 205 | { 206 | "id": "Adaptive Logarithmic Mapping", 207 | "author": [ 208 | "Drago, F.", 209 | "K. Myszkowski", 210 | "T. Annen", 211 | "N. Chiba" 212 | ], 213 | "title": "Adaptive Logarithmic Mapping for Displaying High Contrast Scenes", 214 | "journal": "Computer Graphics Forum", 215 | "link": "http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.69.8094&rep=rep1&type=pdf", 216 | "year": 2003 217 | }, 218 | { 219 | "id": "Flimic Tone Mapping", 220 | "author": [ 221 | "Haarm-Pieter Duiker", 222 | "George Borshukov" 223 | ], 224 | "title": "Filmic Tone Mapping", 225 | "year": 2006 226 | }, 227 | { 228 | "id": "S-curve Tone Mapping", 229 | "author": "Mike Day", 230 | "title": "An Efficient and User-Friendly Tone Mapping Operator", 231 | "link": "http://d3cw3dd2w32x2b.cloudfront.net/wp-content/uploads/2012/09/an-efficient-and-user-friendly-tone-mapping-operator.pdf", 232 | "year": 2012 233 | }, 234 | { 235 | "id": "Filmic Tonemapping with Piecewise Power Curves", 236 | "author": "John Hable", 237 | "title": "Filmic Tonemapping with Piecewise Power Curves", 238 | "link": "http://filmicworlds.com/blog/filmic-tonemapping-with-piecewise-power-curves/", 239 | "year": 2017 240 | }, 241 | { 242 | "id": "Exposure" 243 | }, 244 | { 245 | "id": "Color Grading", 246 | "link": "https://en.wikipedia.org/wiki/Color_grading" 247 | } 248 | ], 249 | "links": [ 250 | { 251 | "source": "Computer Graphics", 252 | "target": "Image" 253 | }, 254 | { 255 | "source": "Image", 256 | "target": "Pixel" 257 | }, 258 | { 259 | "source": "Image", 260 | "target": "Color Space" 261 | }, 262 | { 263 | "source": "Color Space", 264 | "target": "XYZ Color Space" 265 | }, 266 | { 267 | "source": "Color Space", 268 | "target": "RGB Color Space" 269 | }, 270 | { 271 | "source": "RGB Color Space", 272 | "target": "sRGB Color Space" 273 | }, 274 | { 275 | "source": "Color Space", 276 | "target": "YUV Color Space" 277 | }, 278 | { 279 | "source": "YUV Color Space", 280 | "target": "YCbCr Color Space" 281 | }, 282 | { 283 | "source": "Color Space", 284 | "target": "HSV Color Space" 285 | }, 286 | { 287 | "source": "Image", 288 | "target": "Texture", 289 | "type": "derive" 290 | }, 291 | { 292 | "source": "Image", 293 | "target": "Image File Format" 294 | }, 295 | { 296 | "source": "Image", 297 | "target": "Texture" 298 | }, 299 | { 300 | "source": "Image File Format", 301 | "target": "Texture Compression" 302 | }, 303 | { 304 | "source": "Image File Format", 305 | "target": "Truevision Advanced Raster Graphics Adapter" 306 | }, 307 | { 308 | "source": "Image File Format", 309 | "target": "Joint Photographic Experts Group" 310 | }, 311 | { 312 | "source": "Joint Photographic Experts Group", 313 | "target": "Discrete Cosine Transform", 314 | "type": "use" 315 | }, 316 | { 317 | "source": "Image File Format", 318 | "target": "Portable Network Graphics" 319 | }, 320 | { 321 | "source": "Portable Network Graphics", 322 | "target": "Deflate", 323 | "type": "use" 324 | }, 325 | { 326 | "source": "Image File Format", 327 | "target": "WebP" 328 | }, 329 | { 330 | "source": "Image File Format", 331 | "target": "DirectDraw Surface" 332 | }, 333 | { 334 | "source": "DirectX", 335 | "target": "DirectDraw Surface" 336 | }, 337 | { 338 | "source": "Image", 339 | "target": "Image Processing" 340 | }, 341 | { 342 | "source": "Convolution", 343 | "target": "Separable Filter" 344 | }, 345 | { 346 | "source": "Convolution", 347 | "target": "Bilaterial Filter" 348 | }, 349 | { 350 | "source": "Image Processing", 351 | "target": "Convolution" 352 | }, 353 | { 354 | "source": "Convolution", 355 | "target": "Separable Filter" 356 | }, 357 | { 358 | "source": "Convolution", 359 | "target": "Low Pass Filter" 360 | }, 361 | { 362 | "source": "Low Pass Filter", 363 | "target": "Box Blur" 364 | }, 365 | { 366 | "source": "Separable Filter", 367 | "target": "Box Blur" 368 | }, 369 | { 370 | "source": "Low Pass Filter", 371 | "target": "Gaussian Blur" 372 | }, 373 | { 374 | "source": "Separable Filter", 375 | "target": "Gaussian Blur" 376 | }, 377 | { 378 | "source": "Gaussian Blur", 379 | "target": "Kawase Blur", 380 | "type": "derive" 381 | }, 382 | { 383 | "source": "Kawase Blur", 384 | "target": "Dual Kawase Blur", 385 | "type": "derive" 386 | }, 387 | { 388 | "source": "Convolution", 389 | "target": "Edge Detection" 390 | }, 391 | { 392 | "source": "Convolution", 393 | "target": "Fourier Transform" 394 | }, 395 | { 396 | "source": "Fourier Transform", 397 | "target": "Fast Fourier Transform" 398 | }, 399 | { 400 | "source": "Image Processing", 401 | "target": "Color Transform" 402 | }, 403 | { 404 | "source": "Color Transform", 405 | "target": "Gamma Correction" 406 | }, 407 | { 408 | "source": "Color Transform", 409 | "target": "Color Transform by Lookup Table" 410 | }, 411 | { 412 | "source": "Color Transform", 413 | "target": "Color Grading" 414 | }, 415 | { 416 | "source": "Color Transform", 417 | "target": "Tone Mapping" 418 | }, 419 | { 420 | "source": "Tone Mapping", 421 | "target": "Local Tone Mapping" 422 | }, 423 | { 424 | "source": "Tone Mapping", 425 | "target": "Global Tone Mapping" 426 | }, 427 | { 428 | "source": "Tone Mapping", 429 | "target": "Tone Reproduction Transform" 430 | }, 431 | { 432 | "source": "Tone Reproduction Transform", 433 | "target": "Reinhard Tone Mapping" 434 | }, 435 | { 436 | "source": "Tone Reproduction Transform", 437 | "target": "Adaptive Logarithmic Mapping" 438 | }, 439 | { 440 | "source": "Tone Reproduction Transform", 441 | "target": "Flimic Tone Mapping" 442 | }, 443 | { 444 | "source": "Tone Reproduction Transform", 445 | "target": "S-curve Tone Mapping" 446 | }, 447 | { 448 | "source": "Flimic Tone Mapping", 449 | "target": "Filmic Tonemapping with Piecewise Power Curves", 450 | "type": "derive" 451 | }, 452 | { 453 | "source": "Tone Mapping", 454 | "target": "Exposure" 455 | } 456 | ] 457 | } -------------------------------------------------------------------------------- /tech/graphics/rendering/shading.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Shading", 5 | "link": "https://en.wikipedia.org/wiki/Shading" 6 | }, 7 | { 8 | "id": "Shading Interpolation" 9 | }, 10 | { 11 | "id": "Flat Shading", 12 | "link": "https://en.wikipedia.org/wiki/Shading#Flat_shading" 13 | }, 14 | { 15 | "id": "Gouraud Shading", 16 | "author": "Henri Gouraud", 17 | "title": "Continuous shading of curved surfaces", 18 | "journal": "TOG", 19 | "link": [ 20 | "https://dl.acm.org/doi/pdf/10.1145/360349.360353", 21 | "https://en.wikipedia.org/wiki/Gouraud_shading" 22 | ], 23 | "year": 1971 24 | }, 25 | { 26 | "id": "Phong Shading", 27 | "author": "Bui Tuong Phong", 28 | "title": "Illumination for computer generated pictures", 29 | "journal": "Communications of the ACM", 30 | "link": [ 31 | "https://dl.acm.org/doi/pdf/10.1145/360825.360839", 32 | "https://en.wikipedia.org/wiki/Phong_shading" 33 | ], 34 | "year": 1975 35 | }, 36 | { 37 | "id": "Per-pixel Lighting", 38 | "link": "https://en.wikipedia.org/wiki/Per-pixel_lighting" 39 | }, 40 | { 41 | "id": "Forward Shading", 42 | "aka": "Forward Rendering" 43 | }, 44 | { 45 | "id": "Deferred Shading", 46 | "aka": "Deferred Rendering", 47 | "author": [ 48 | "Michael Deering", 49 | "Stephanie Winner", 50 | "Bic Schediwy", 51 | "Chris Duffy", 52 | "Neil Hunt" 53 | ], 54 | "title": "The triangle processor and normal vector shader: a VLSI system for high performance graphics", 55 | "conference": "SIGGRAPH", 56 | "link": "https://en.wikipedia.org/wiki/Deferred_shading", 57 | "year": 1988 58 | }, 59 | { 60 | "id": "Deferred Lighting", 61 | "aka": "Light Pre-pass", 62 | "author": [ 63 | "Rich Geldreich", 64 | "Matt Pritchard", 65 | "John Brooks" 66 | ], 67 | "title": "Deferred lighting and shading", 68 | "conference": "GDC", 69 | "year": 2004 70 | }, 71 | { 72 | "id": "Tiled Deferred Shading", 73 | "author": [ 74 | "Christophe Balestra", 75 | "Pål-Kristian Engstad" 76 | ], 77 | "title": "The technology of uncharted: Drake’s fortune", 78 | "conference": "GDC", 79 | "year": 2008 80 | }, 81 | { 82 | "id": "Tiled Forward Shading", 83 | "author": [ 84 | "Ola Olsson", 85 | "Ulf Assarsson" 86 | ], 87 | "title": "Tiled shading", 88 | "journal": "Journal of Graphics, GPU, and Game Tools", 89 | "link": "https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.441.3074&rep=rep1&type=pdf", 90 | "year": 2011 91 | }, 92 | { 93 | "id": "Clustered Forward Shading", 94 | "author": [ 95 | "Ola Olsson", 96 | "Markus Billeter", 97 | "Ulf Assarsson" 98 | ], 99 | "title": "Clustered deferred and forward shading", 100 | "conference": "HPG", 101 | "link": "https://www.researchgate.net/publication/289301155_Clustered_deferred_and_forward_shading", 102 | "year": 2012 103 | }, 104 | { 105 | "id": "Clustered Deferred Shading", 106 | "author": [ 107 | "Ola Olsson", 108 | "Markus Billeter", 109 | "Ulf Assarsson" 110 | ], 111 | "title": "Clustered deferred and forward shading", 112 | "conference": "HPG", 113 | "link": "https://www.researchgate.net/publication/289301155_Clustered_deferred_and_forward_shading", 114 | "year": 2012 115 | }, 116 | { 117 | "id": "Environment Mapping", 118 | "aka": "Reflection Mapping", 119 | "author": [ 120 | "James Blinn", 121 | "Martin E. Newell" 122 | ], 123 | "title": "Texture and Reflection in Computer Generated Images", 124 | "journal": "Communications of the ACM", 125 | "link": [ 126 | "https://dl.acm.org/doi/pdf/10.1145/360349.360353", 127 | "https://en.wikipedia.org/wiki/Reflection_mapping" 128 | ], 129 | "year": 1976 130 | }, 131 | { 132 | "id": "Latitude-longitude Mapping", 133 | "author": [ 134 | "James Blinn", 135 | "Martin E. Newell" 136 | ], 137 | "title": "Texture and Reflection in Computer Generated Images", 138 | "journal": "Communications of the ACM", 139 | "link": "https://dl.acm.org/doi/pdf/10.1145/360349.360353", 140 | "year": 1976 141 | }, 142 | { 143 | "id": "Sphere Mapping" 144 | }, 145 | { 146 | "id": "Cube Mapping", 147 | "aka": "Cubic Environment Map", 148 | "author": "Ned Greene", 149 | "title": "Environment mapping and other applications of world projections.", 150 | "conference": "IEEE computer graphics and Applications", 151 | "link": "https://en.wikipedia.org/wiki/Cube_mapping", 152 | "year": 1986 153 | }, 154 | { 155 | "id": "Dual Paraboloid Mapping", 156 | "author": [ 157 | "Wolfgang Heidrich", 158 | "Hans-Peter Seidel" 159 | ], 160 | "title": "View-independent Environment Maps", 161 | "conference": "EGGH", 162 | "year": 1998 163 | }, 164 | { 165 | "id": "Octahedral Mapping", 166 | "author": [ 167 | "Thomas Engelhardt", 168 | "Carsten Dachsbacher" 169 | ], 170 | "title": "Octahedron Environment Maps", 171 | "conference": "VMV", 172 | "link": "http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.681.1522&rep=rep1&type=pdf", 173 | "year": 2008 174 | }, 175 | { 176 | "id": "Bump Mapping", 177 | "author": "James Blinn", 178 | "title": "Simulation of wrinkled surfaces", 179 | "conference": "SIGGRAPH", 180 | "link": [ 181 | "https://dl.acm.org/doi/pdf/10.1145/965139.507101", 182 | "https://en.wikipedia.org/wiki/Bump_mapping" 183 | ], 184 | "year": 1978 185 | }, 186 | { 187 | "id": "Normal Mapping", 188 | "aka": "Dot3 bump mapping", 189 | "author": [ 190 | "Jonathan D. Cohen", 191 | "Marc Olano", 192 | "Dinesh Manocha" 193 | ], 194 | "title": "Appearance-Preserving Simplification", 195 | "conference": "SIGGRAPH", 196 | "link": [ 197 | "http://gamma.cs.unc.edu/APS/APS.pdf", 198 | "https://en.wikipedia.org/wiki/Normal_mapping" 199 | ], 200 | "year": 1998 201 | }, 202 | { 203 | "id": "Parallax Mapping", 204 | "aka": [ 205 | "Offset Mapping", 206 | "Virtual Displacement Mapping" 207 | ], 208 | "author": [ 209 | "Tomomichi Kaneko", 210 | "Toshiyuki Takahei", 211 | "Masahiko Inami", 212 | "Naoki Kawakami", 213 | "Yasuyuki Yanagida", 214 | "Taro Maeda", 215 | "Susumu Tachi" 216 | ], 217 | "title": "Detailed Shape Representation with Parallax Mapping", 218 | "conference": "International Conference on Artificial Reality and Telexistence", 219 | "link": [ 220 | "https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.115.1050&rep=rep1&type=pdf", 221 | "https://en.wikipedia.org/wiki/Parallax_mapping" 222 | ], 223 | "year": 2001 224 | }, 225 | { 226 | "id": "Relief Mapping", 227 | "author": [ 228 | "Fábio Policarpo", 229 | "Manuel M. Oliveira", 230 | "Joao LD Comba" 231 | ], 232 | "title": "Real-time relief mapping on arbitrary polygonal surfaces", 233 | "conference": "I3D", 234 | "link": [ 235 | "https://dl.acm.org/doi/pdf/10.1145/1053427.1053453", 236 | "https://en.wikipedia.org/wiki/Relief_mapping_(computer_graphics)" 237 | ], 238 | "year": 2005 239 | }, 240 | { 241 | "id": "Parallax Occlusion Mapping", 242 | "abbr": "POM", 243 | "author": [ 244 | "Zoe Brawley", 245 | "Natalya Tatarchuk" 246 | ], 247 | "title": "Parallax Occlusion Mapping: Self-Shadowing, Perspective-Correct Bump Mapping Using Reverse Height Map Tracing", 248 | "journal": "ShaderX 3", 249 | "link": "https://en.wikipedia.org/wiki/Parallax_occlusion_mapping", 250 | "year": 2005 251 | }, 252 | { 253 | "id": "Parallax Occlusion Mapping with Soft Shadow", 254 | "author": "Natalya Tatarchuk", 255 | "title": "Dynamic parallax occlusion mapping with approximate soft shadows", 256 | "conference": "I3D", 257 | "link": "https://dl.acm.org/doi/pdf/10.1145/1111411.1111423", 258 | "year": 2006 259 | }, 260 | { 261 | "id": "Projective Texture Mapping", 262 | "author": [ 263 | "Mark Segal", 264 | "Carl Korobkin", 265 | "Rolf van Widenfelt", 266 | "Jim Foran", 267 | "Paul Haeberli" 268 | ], 269 | "title": "Fast shadows and lighting effects using texture mapping", 270 | "conference": "SIGGRAPH", 271 | "link": [ 272 | "https://en.wikipedia.org/wiki/Projective_texture_mapping", 273 | "https://dl.acm.org/doi/pdf/10.1145/133994.134071" 274 | ], 275 | "year": 1992 276 | }, 277 | { 278 | "id": "Reflection", 279 | "link": "https://en.wikipedia.org/wiki/Reflection_(computer_graphics)" 280 | }, 281 | { 282 | "id": "Planar Reflection" 283 | }, 284 | { 285 | "id": "Refraction" 286 | }, 287 | { 288 | "id": "Planar Refraction" 289 | } 290 | ], 291 | "links": [ 292 | { 293 | "source": "Rendering", 294 | "target": "Shading" 295 | }, 296 | { 297 | "source": "Shading", 298 | "target": "Shading Interpolation" 299 | }, 300 | { 301 | "source": "Shading Interpolation", 302 | "target": "Flat Shading" 303 | }, 304 | { 305 | "source": "Shading Interpolation", 306 | "target": "Gouraud Shading" 307 | }, 308 | { 309 | "source": "Shading Interpolation", 310 | "target": "Phong Shading" 311 | }, 312 | { 313 | "source": "Shading Interpolation", 314 | "target": "Per-pixel Lighting" 315 | }, 316 | { 317 | "source": "Shading", 318 | "target": "Forward Shading" 319 | }, 320 | { 321 | "source": "Shading", 322 | "target": "Deferred Shading" 323 | }, 324 | { 325 | "source": "Deferred Shading", 326 | "target": "Deferred Lighting", 327 | "type": "derive" 328 | }, 329 | { 330 | "source": "Deferred Shading", 331 | "target": "Tiled Deferred Shading", 332 | "type": "derive" 333 | }, 334 | { 335 | "source": "Forward Shading", 336 | "target": "Tiled Forward Shading", 337 | "type": "derive" 338 | }, 339 | { 340 | "source": "Tiled Forward Shading", 341 | "target": "Clustered Forward Shading", 342 | "type": "derive" 343 | }, 344 | { 345 | "source": "Tiled Deferred Shading", 346 | "target": "Clustered Deferred Shading", 347 | "type": "derive" 348 | }, 349 | { 350 | "source": "Shading", 351 | "target": "Environment Mapping" 352 | }, 353 | { 354 | "source": "Texture", 355 | "target": "Environment Mapping" 356 | }, 357 | { 358 | "source": "Environment Mapping", 359 | "target": "Latitude-longitude Mapping" 360 | }, 361 | { 362 | "source": "Environment Mapping", 363 | "target": "Sphere Mapping" 364 | }, 365 | { 366 | "source": "Environment Mapping", 367 | "target": "Cube Mapping" 368 | }, 369 | { 370 | "source": "Cube Mapping", 371 | "target": "Cube Texture", 372 | "type": "use" 373 | }, 374 | { 375 | "source": "Environment Mapping", 376 | "target": "Dual Paraboloid Mapping" 377 | }, 378 | { 379 | "source": "Environment Mapping", 380 | "target": "Octahedral Mapping" 381 | }, 382 | { 383 | "source": "Shading", 384 | "target": "Bump Mapping" 385 | }, 386 | { 387 | "source": "Bump Mapping", 388 | "target": "Normal Mapping", 389 | "type": "derive" 390 | }, 391 | { 392 | "source": "Normal Mapping", 393 | "target": "Parallax Mapping", 394 | "type": "derive" 395 | }, 396 | { 397 | "source": "Normal Mapping", 398 | "target": "Relief Mapping", 399 | "type": "derive" 400 | }, 401 | { 402 | "source": "Parallax Mapping", 403 | "target": "Parallax Occlusion Mapping", 404 | "type": "derive" 405 | }, 406 | { 407 | "source": "Parallax Occlusion Mapping", 408 | "target": "Parallax Occlusion Mapping with Soft Shadow", 409 | "type": "derive" 410 | }, 411 | { 412 | "source": "Shading", 413 | "target": "Projective Texture Mapping" 414 | }, 415 | { 416 | "source": "Shading", 417 | "target": "Reflection" 418 | }, 419 | { 420 | "source": "Reflection", 421 | "target": "Planar Reflection" 422 | }, 423 | { 424 | "source": "Reflection", 425 | "target": "Environment Mapping" 426 | }, 427 | { 428 | "source": "Shading", 429 | "target": "Refraction" 430 | }, 431 | { 432 | "source": "Refraction", 433 | "target": "Planar Refraction" 434 | }, 435 | { 436 | "source": "Refraction", 437 | "target": "Environment Mapping" 438 | } 439 | ] 440 | } -------------------------------------------------------------------------------- /tech/graphics/rendering/texture.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Texture" 5 | }, 6 | { 7 | "id": "Texel", 8 | "aka": [ 9 | "Texture Element", 10 | "Texture Pixel" 11 | ], 12 | "link": "https://en.wikipedia.org/wiki/Texel_(graphics)" 13 | }, 14 | { 15 | "id": "Texture Mapping", 16 | "author": "Edwin Catmull", 17 | "title": "A subdivision algorithm for computer display of curved surfaces", 18 | "link": "http://www.pixartouchbook.com/storage/catmull_thesis.pdf", 19 | "year": 1974 20 | }, 21 | { 22 | "id": "Texture Mapping Rasterization Algorithm" 23 | }, 24 | { 25 | "id": "Affine Texture Mapping" 26 | }, 27 | { 28 | "id": "Perspective Correct Texture Mapping", 29 | "author": "Paul Heckbert", 30 | "title": "Texture Mapping Polygons in Perspective", 31 | "link": "https://www.researchgate.net/publication/2722735_Texture_Mapping_Polygons_In_Perspective", 32 | "year": 1983 33 | }, 34 | { 35 | "id": "Texture Filtering" 36 | }, 37 | { 38 | "id": "Mipmap", 39 | "author": "Lance Williams", 40 | "title": "Pyramidal Parametrics", 41 | "link": [ 42 | "https://web.archive.org/web/20140414134825/http://staff.cs.psu.ac.th/iew/cs344-481/p1-williams.pdf", 43 | "https://en.wikipedia.org/wiki/Mipmap" 44 | ], 45 | "conference": "SIGGRAPH", 46 | "year": 1983 47 | }, 48 | { 49 | "id": "Nearest Filtering", 50 | "aka": [ 51 | "Point Sampling", 52 | "Nearest-neighbor Interpolation", 53 | "Proximal Interpolation" 54 | ], 55 | "link": "https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation" 56 | }, 57 | { 58 | "id": "Bilinear Filtering", 59 | "aka": "Bilinear Interpolation", 60 | "link": "https://en.wikipedia.org/wiki/Bilinear_interpolation" 61 | }, 62 | { 63 | "id": "Trilinear Filtering", 64 | "link": "https://en.wikipedia.org/wiki/Trilinear_filtering" 65 | }, 66 | { 67 | "id": "Anisotropic Filtering", 68 | "abbr": "AF", 69 | "link": "https://en.wikipedia.org/wiki/Anisotropic_filtering" 70 | }, 71 | { 72 | "id": "Bicubic Filtering", 73 | "link": "https://en.wikipedia.org/wiki/Bicubic_interpolation" 74 | }, 75 | { 76 | "id": "Summed-area Table", 77 | "abbr": "SAT", 78 | "author": "Franklin Crow", 79 | "title": "Summed-Area Tables for Texture Mapping", 80 | "conference": "SIGGRAPH", 81 | "link": "https://en.wikipedia.org/wiki/Summed-area_table", 82 | "year": 1984 83 | }, 84 | { 85 | "id": "Fast Summed-area Table", 86 | "author": [ 87 | "Justin Hensley", 88 | "Thorsten Scheuermann", 89 | "Greg Coombe", 90 | "Montek Singh", 91 | "Anselmo Lastra" 92 | ], 93 | "title": "Fast Summed-Area Table Generation and its Applications", 94 | "journal": "Computer Graphics Forum", 95 | "year": 2005 96 | }, 97 | { 98 | "id": "Texture Addressing Mode" 99 | }, 100 | { 101 | "id": "Wrap Addressing Mode" 102 | }, 103 | { 104 | "id": "Clamp Addressing Mode" 105 | }, 106 | { 107 | "id": "Mirror Addressing Mode" 108 | }, 109 | { 110 | "id": "Border Color Addressing Mode" 111 | }, 112 | { 113 | "id": "Texture Type" 114 | }, 115 | { 116 | "id": "1D Texture" 117 | }, 118 | { 119 | "id": "2D Texture" 120 | }, 121 | { 122 | "id": "3D Texture", 123 | "aka": [ 124 | "Volume Texture", 125 | "Volumetric Texture" 126 | ] 127 | }, 128 | { 129 | "id": "Cube Texture", 130 | "author": "Ned Greene", 131 | "title": "Environment mapping and other applications of world projections.", 132 | "conference": "IEEE computer graphics and Applications", 133 | "link": "https://en.wikipedia.org/wiki/Cube_mapping", 134 | "year": 1986 135 | }, 136 | { 137 | "id": "Texture Array", 138 | "aka": "Array Texture" 139 | }, 140 | { 141 | "id": "Texture Compression", 142 | "author": [ 143 | "Andrew Beers", 144 | "Maneesh Agrawala", 145 | "Navin Chaddha" 146 | ], 147 | "title": "Rendering from Compressed Textures", 148 | "conference": "SIGGRAPH", 149 | "link": [ 150 | "https://dl.acm.org/doi/pdf/10.1145/237170.237276", 151 | "https://en.wikipedia.org/wiki/Texture_compression" 152 | ], 153 | "year": 1996 154 | }, 155 | { 156 | "id": "S3 Texture Compression", 157 | "abbr": "S3TC", 158 | "aka": [ 159 | "DXTn", 160 | "DXTC", 161 | "BCn" 162 | ], 163 | "organization": "S3 Graphics", 164 | "link": "https://en.wikipedia.org/wiki/S3_Texture_Compression", 165 | "year": 1998 166 | }, 167 | { 168 | "id": "Ericsson Texture Compression", 169 | "aka": "iPACKMAN", 170 | "abbr": "ETC", 171 | "organization": "Ericsson Research", 172 | "year": 2005 173 | }, 174 | { 175 | "id": "PowerVR Texture Compression", 176 | "abbr": "PVRTC", 177 | "link": "https://en.wikipedia.org/wiki/PVRTC" 178 | }, 179 | { 180 | "id": "Adaptive Scalable Texture Compression", 181 | "abbr": "ASTC", 182 | "link": "https://en.wikipedia.org/wiki/Adaptive_Scalable_Texture_Compression", 183 | "year": 2012 184 | }, 185 | { 186 | "id": "Supercompressed Texture" 187 | }, 188 | { 189 | "id": "Crunch", 190 | "link": "https://github.com/BinomialLLC/crunch" 191 | }, 192 | { 193 | "id": "Basis Universal", 194 | "link": "https://github.com/BinomialLLC/basis_universal" 195 | }, 196 | { 197 | "id": "GPU-decodable Supercompressed Texture", 198 | "abbr": "GST", 199 | "author": [ 200 | "Pavel Krajcevski", 201 | "Srihari Pratapa", 202 | "Dinesh Manocha" 203 | ], 204 | "conference": "SIGGRAPH Asia", 205 | "link": "http://gamma.cs.unc.edu/GST/", 206 | "year": 2016 207 | }, 208 | { 209 | "id": "Texture Atlas", 210 | "link": "https://en.wikipedia.org/wiki/Texture_atlas" 211 | }, 212 | { 213 | "id": "Virtual Texture" 214 | }, 215 | { 216 | "id": "Clipmap", 217 | "author": [ 218 | "Christopher C. Tanner", 219 | "Christopher J. Migdal", 220 | "Michael T. Jones" 221 | ], 222 | "title": "The clipmap: a virtual mipmap", 223 | "year": 1998 224 | }, 225 | { 226 | "id": "MegaTexture" 227 | }, 228 | { 229 | "id": "Streaming Virtual Texture", 230 | "abbr": "SVT" 231 | }, 232 | { 233 | "id": "Runtime Virtual Texture", 234 | "abbr": "RVT" 235 | }, 236 | { 237 | "id": "Procedural Texture" 238 | }, 239 | { 240 | "id": "Gradient Noise", 241 | "link": "https://en.wikipedia.org/wiki/Gradient_noise" 242 | }, 243 | { 244 | "id": "Value Noise", 245 | "link": "https://en.wikipedia.org/wiki/Value_noise" 246 | }, 247 | { 248 | "id": "Perlin Noise", 249 | "author": "Ken Perlin", 250 | "title": "An image synthesizer", 251 | "conference": "SIGGRAPH", 252 | "link": [ 253 | "http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.220.2248&rep=rep1&type=pdf", 254 | "https://en.wikipedia.org/wiki/Perlin_noise" 255 | ], 256 | "year": 1985 257 | }, 258 | { 259 | "id": "Simplex Noise", 260 | "author": "Ken Perlin", 261 | "title": "Noise hardware", 262 | "conference": "Real-Time Shading SIGGRAPH Course Notes", 263 | "link": [ 264 | "https://www.csee.umbc.edu/~olano/s2002c36/ch02.pdf", 265 | "https://en.wikipedia.org/wiki/Simplex_noise" 266 | ], 267 | "year": 2001 268 | }, 269 | { 270 | "id": "Hypertexture", 271 | "author": [ 272 | "Ken Perlin", 273 | "Eric M. Hoffert" 274 | ], 275 | "conference": "SIGGRAPH", 276 | "year": 1989 277 | } 278 | ], 279 | "links": [ 280 | { 281 | "source": "Rendering", 282 | "target": "Texture" 283 | }, 284 | { 285 | "source": "Texture", 286 | "target": "Texel" 287 | }, 288 | { 289 | "source": "Texture", 290 | "target": "Texture Mapping" 291 | }, 292 | { 293 | "source": "Texture Mapping", 294 | "target": "Texture Mapping Rasterization Algorithm" 295 | }, 296 | { 297 | "source": "Texture Mapping Rasterization Algorithm", 298 | "target": "Affine Texture Mapping" 299 | }, 300 | { 301 | "source": "Texture Mapping Rasterization Algorithm", 302 | "target": "Perspective Correct Texture Mapping" 303 | }, 304 | { 305 | "source": "Texture Mapping", 306 | "target": "Texture Filtering" 307 | }, 308 | { 309 | "source": "Texture Filtering", 310 | "target": "Mipmap" 311 | }, 312 | { 313 | "source": "Texture Filtering", 314 | "target": "Nearest Filtering" 315 | }, 316 | { 317 | "source": "Texture Filtering", 318 | "target": "Bilinear Filtering" 319 | }, 320 | { 321 | "source": "Texture Filtering", 322 | "target": "Trilinear Filtering" 323 | }, 324 | { 325 | "source": "Texture Filtering", 326 | "target": "Anisotropic Filtering" 327 | }, 328 | { 329 | "source": "Texture Filtering", 330 | "target": "Bicubic Filtering" 331 | }, 332 | { 333 | "source": "Anisotropic Filtering", 334 | "target": "Summed-area Table" 335 | }, 336 | { 337 | "source": "Summed-area Table", 338 | "target": "Fast Summed-area Table" 339 | }, 340 | { 341 | "source": "Texture Mapping", 342 | "target": "Texture Addressing Mode" 343 | }, 344 | { 345 | "source": "Texture Addressing Mode", 346 | "target": "Wrap Addressing Mode" 347 | }, 348 | { 349 | "source": "Texture Addressing Mode", 350 | "target": "Clamp Addressing Mode" 351 | }, 352 | { 353 | "source": "Texture Addressing Mode", 354 | "target": "Mirror Addressing Mode" 355 | }, 356 | { 357 | "source": "Texture Addressing Mode", 358 | "target": "Border Color Addressing Mode" 359 | }, 360 | { 361 | "source": "Texture", 362 | "target": "Texture Type" 363 | }, 364 | { 365 | "source": "Texture Type", 366 | "target": "1D Texture" 367 | }, 368 | { 369 | "source": "Texture Type", 370 | "target": "2D Texture" 371 | }, 372 | { 373 | "source": "Texture Type", 374 | "target": "3D Texture" 375 | }, 376 | { 377 | "source": "Texture Type", 378 | "target": "Cube Texture" 379 | }, 380 | { 381 | "source": "Texture Type", 382 | "target": "Texture Array" 383 | }, 384 | { 385 | "source": "Texture", 386 | "target": "Texture Compression" 387 | }, 388 | { 389 | "source": "Texture Compression", 390 | "target": "S3 Texture Compression" 391 | }, 392 | { 393 | "source": "Texture Compression", 394 | "target": "Ericsson Texture Compression" 395 | }, 396 | { 397 | "source": "Texture Compression", 398 | "target": "PowerVR Texture Compression" 399 | }, 400 | { 401 | "source": "Texture Compression", 402 | "target": "Adaptive Scalable Texture Compression" 403 | }, 404 | { 405 | "source": "Texture Compression", 406 | "target": "Supercompressed Texture" 407 | }, 408 | { 409 | "source": "Supercompressed Texture", 410 | "target": "Crunch" 411 | }, 412 | { 413 | "source": "Supercompressed Texture", 414 | "target": "Basis Universal" 415 | }, 416 | { 417 | "source": "Supercompressed Texture", 418 | "target": "GPU-decodable Supercompressed Texture" 419 | }, 420 | { 421 | "source": "Texture", 422 | "target": "Displacement Mapping" 423 | }, 424 | { 425 | "source": "Texture", 426 | "target": "Texture Atlas" 427 | }, 428 | { 429 | "source": "Texture", 430 | "target": "MegaTexture" 431 | }, 432 | { 433 | "source": "Texture", 434 | "target": "Virtual Texture" 435 | }, 436 | { 437 | "source": "Virtual Texture", 438 | "target": "Clipmap" 439 | }, 440 | { 441 | "source": "Virtual Texture", 442 | "target": "MegaTexture" 443 | }, 444 | { 445 | "source": "Virtual Texture", 446 | "target": "Streaming Virtual Texture" 447 | }, 448 | { 449 | "source": "Virtual Texture", 450 | "target": "Runtime Virtual Texture" 451 | }, 452 | { 453 | "source": "Texture", 454 | "target": "Procedural Texture" 455 | }, 456 | { 457 | "source": "Procedural Texture", 458 | "target": "Gradient Noise" 459 | }, 460 | { 461 | "source": "Procedural Texture", 462 | "target": "Value Noise" 463 | }, 464 | { 465 | "source": "Gradient Noise", 466 | "target": "Perlin Noise" 467 | }, 468 | { 469 | "source": "Perlin Noise", 470 | "target": "Simplex Noise", 471 | "type": "derive" 472 | }, 473 | { 474 | "source": "Procedural Texture", 475 | "target": "Hypertexture" 476 | } 477 | ] 478 | } -------------------------------------------------------------------------------- /tech/cs/compression.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Data Compression", 5 | "link": "https://en.wikipedia.org/wiki/Data_compression" 6 | }, 7 | { 8 | "id": "Lossless Compression", 9 | "link": "https://en.wikipedia.org/wiki/Lossless_compression" 10 | }, 11 | { 12 | "id": "Entropy Encoding", 13 | "link": "https://en.wikipedia.org/wiki/Entropy_encoding" 14 | }, 15 | { 16 | "id": "Huffman Coding", 17 | "abbr": "HC", 18 | "author": "David A. Huffman", 19 | "title": "A Method for the Construction of Minimum-Redundancy Codes", 20 | "journal": "Proceedings of the IRE", 21 | "link": [ 22 | "http://compression.ru/download/articles/huff/huffman_1952_minimum-redundancy-codes.pdf", 23 | "https://en.wikipedia.org/wiki/Huffman_coding" 24 | ], 25 | "year": 1952 26 | }, 27 | { 28 | "id": "Arithmetic Coding", 29 | "abbr": "AC", 30 | "link": "https://en.wikipedia.org/wiki/Arithmetic_coding", 31 | "year": 1976 32 | }, 33 | { 34 | "id": "Dictionary Coder", 35 | "link": "https://en.wikipedia.org/wiki/Dictionary_coder" 36 | }, 37 | { 38 | "id": "Lempel-Ziv", 39 | "abbr": "LZ", 40 | "author": [ 41 | "Abraham Lempel", 42 | "Jacob Ziv" 43 | ], 44 | "title": "A Universal Algorithm for Sequential Data Compression", 45 | "journal": "IEEE Transactions on Information Theory", 46 | "link": [ 47 | "https://cs.nyu.edu/~roweis/csc310-2006/extras/ziv_lempel_1977_universal_algorithm.pdf", 48 | "https://en.wikipedia.org/wiki/LZ77_and_LZ78" 49 | ], 50 | "year": 1977 51 | }, 52 | { 53 | "id": "Lempel–Ziv–Storer–Szymanski", 54 | "abbr": "LZSS", 55 | "author": [ 56 | "James A. Storer", 57 | "Thomas G. Szymanski" 58 | ], 59 | "title": "Data Compression via Textual Substitution", 60 | "journal": "Journal of the ACM", 61 | "year": 1982 62 | }, 63 | { 64 | "id": "Deflate", 65 | "author": "Phil Katz", 66 | "link": [ 67 | "https://tools.ietf.org/html/rfc1951", 68 | "https://en.wikipedia.org/wiki/Deflate" 69 | ], 70 | "year": 1993 71 | }, 72 | { 73 | "id": "gzip", 74 | "author": [ 75 | "Jean-loup Gailly", 76 | "Mark Adler" 77 | ], 78 | "link": [ 79 | "https://www.gnu.org/software/gzip/", 80 | "https://en.wikipedia.org/wiki/Gzip" 81 | ], 82 | "year": 1992 83 | }, 84 | { 85 | "id": "zlib", 86 | "author": [ 87 | "Jean-loup Gailly", 88 | "Mark Adler" 89 | ], 90 | "link": [ 91 | "http://zlib.net/", 92 | "https://en.wikipedia.org/wiki/Zlib" 93 | ], 94 | "year": 1995 95 | }, 96 | { 97 | "id": "Lempel-Ziv-Oberhumer", 98 | "abbr": "LZO", 99 | "author": "Markus F.X.J. Oberhumer", 100 | "link": [ 101 | "http://www.oberhumer.com/opensource/lzo/", 102 | "https://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Oberhumer" 103 | ], 104 | "year": 1996 105 | }, 106 | { 107 | "id": "Lempel-Ziv-Markov Chain", 108 | "abbr": "LZMA", 109 | "author": "Igor Pavlov", 110 | "link": [ 111 | "https://www.7-zip.org/", 112 | "https://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Markov_chain_algorithm" 113 | ], 114 | "year": 1998 115 | }, 116 | { 117 | "id": "LZMA SDK", 118 | "link": "https://www.7-zip.org/sdk.html" 119 | }, 120 | { 121 | "id": "Snappy", 122 | "author": [ 123 | "Jeff Dean", 124 | "Sanjay Ghemawat", 125 | "Steinar H. Gunderson" 126 | ], 127 | "organization": "Google", 128 | "link": [ 129 | "https://google.github.io/snappy/", 130 | "https://github.com/google/snappy", 131 | "https://en.wikipedia.org/wiki/Snappy_(compression)" 132 | ], 133 | "year": 2011 134 | }, 135 | { 136 | "id": "Brotli", 137 | "author": [ 138 | "Jyrki Alakuijala", 139 | "Zoltán Szabadka" 140 | ], 141 | "link": [ 142 | "https://tools.ietf.org/html/rfc7932", 143 | "https://github.com/google/brotli", 144 | "https://en.wikipedia.org/wiki/Brotli" 145 | ], 146 | "year": 2013 147 | }, 148 | { 149 | "id": "Asymmetric Numeral Systems", 150 | "abbr": "ANS", 151 | "author": "Jarosław Duda", 152 | "link": "https://en.wikipedia.org/wiki/Asymmetric_numeral_systems", 153 | "year": 2013 154 | }, 155 | { 156 | "id": "Finite State Entropy", 157 | "abbr": "FSE", 158 | "link": "https://github.com/Cyan4973/FiniteStateEntropy", 159 | "year": 2013 160 | }, 161 | { 162 | "id": "Lempel–Ziv Finite State Entropy", 163 | "abbr": "LZFSE", 164 | "organization": "Apple", 165 | "link": [ 166 | "https://github.com/lzfse/lzfse", 167 | "https://en.wikipedia.org/wiki/LZFSE" 168 | ], 169 | "year": 2015 170 | }, 171 | { 172 | "id": "Zstandard", 173 | "author": "Yann Collet", 174 | "organization": "Facebook", 175 | "link": [ 176 | "https://facebook.github.io/zstd/", 177 | "https://en.wikipedia.org/wiki/Zstandard" 178 | ], 179 | "year": 2015 180 | }, 181 | { 182 | "id": "Run-length Encoding", 183 | "abbr": "RLE", 184 | "author": [ 185 | "A. H. Robinson", 186 | "C. Cherry" 187 | ], 188 | "title": "Results of a prototype television bandwidth compression scheme", 189 | "journal": "Proceedings of the IEEE", 190 | "link": "https://en.wikipedia.org/wiki/Run-length_encoding", 191 | "year": 1967 192 | }, 193 | { 194 | "id": "Delta Encoding", 195 | "link": "https://en.wikipedia.org/wiki/Delta_encoding" 196 | }, 197 | { 198 | "id": "Golomb Coding", 199 | "author": "Solomon W. Golomb", 200 | "title": "Run-length encodings", 201 | "link": [ 202 | "http://urchin.earth.li/~twic/Golombs_Original_Paper/", 203 | "https://en.wikipedia.org/wiki/Golomb_coding" 204 | ], 205 | "journal": "IEEE Transaction on Information Theory", 206 | "year": 1966 207 | }, 208 | { 209 | "id": "Rice Coding", 210 | "author": "Robert F. Rice", 211 | "title": "Some practical universal noiseless coding techniques", 212 | "link": [ 213 | "https://ntrs.nasa.gov/citations/19790014634", 214 | "https://en.wikipedia.org/wiki/Golomb_coding#Rice_coding" 215 | ], 216 | "year": 1979 217 | }, 218 | { 219 | "id": "Burrows-Wheeler Transform", 220 | "abbr": "BWT", 221 | "author": [ 222 | "Michael Burrows", 223 | "David Wheeler" 224 | ], 225 | "title": "A block sorting lossless data compression algorithm", 226 | "link": [ 227 | "https://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-124.pdf", 228 | "https://en.wikipedia.org/wiki/Burrows%E2%80%93Wheeler_transform" 229 | ], 230 | "year": 1994 231 | }, 232 | { 233 | "id": "bzip2", 234 | "author": "Julian Seward", 235 | "link": [ 236 | "http://sourceware.org/bzip2/", 237 | "https://en.wikipedia.org/wiki/Bzip2" 238 | ], 239 | "year": 1996 240 | }, 241 | { 242 | "id": "Lossy Compression", 243 | "link": "https://en.wikipedia.org/wiki/Lossy_compression" 244 | }, 245 | { 246 | "id": "Quantization", 247 | "link": "https://en.wikipedia.org/wiki/Quantization_(signal_processing)" 248 | }, 249 | { 250 | "id": "Transform Coding", 251 | "link": "https://en.wikipedia.org/wiki/Transform_coding" 252 | }, 253 | { 254 | "id": "Discrete Cosine Transform", 255 | "abbr": "DCT", 256 | "author": [ 257 | "Nasir Ahmed", 258 | "T. Natarajan", 259 | "K. R. Rao" 260 | ], 261 | "title": "Discrete Cosine Transform", 262 | "journal": "IEEE Transactions on Computers", 263 | "link": [ 264 | "https://www.ic.tu-berlin.de/fileadmin/fg121/Source-Coding_WS12/selected-readings/Ahmed_et_al.__1974.pdf", 265 | "https://en.wikipedia.org/wiki/Discrete_cosine_transform" 266 | ], 267 | "year": 1974 268 | }, 269 | { 270 | "id": "Predictive Coding" 271 | }, 272 | { 273 | "id": "Differential Pulse-code Modulation", 274 | "abbr": "DPCM", 275 | "author": "C. Chapin Cutler", 276 | "organization": "Bell Labs", 277 | "link": "https://en.wikipedia.org/wiki/Differential_pulse-code_modulation", 278 | "year": 1950 279 | }, 280 | { 281 | "id": "Adaptive Differential Pulse-code Modulation", 282 | "abbr": "ADPCM", 283 | "author": [ 284 | "P. Cummiskey", 285 | "Nikil S. Jayant", 286 | "James L. Flanagan" 287 | ], 288 | "title": "Adaptive quantization in differential PCM coding of speech", 289 | "journal": "The Bell System Technical Journal", 290 | "year": 1973, 291 | "link": "https://en.wikipedia.org/wiki/Adaptive_differential_pulse-code_modulation" 292 | } 293 | ], 294 | "links": [ 295 | { 296 | "source": "Computer Science", 297 | "target": "Data Compression" 298 | }, 299 | { 300 | "source": "Data Compression", 301 | "target": "Lossless Compression" 302 | }, 303 | { 304 | "source": "Lossless Compression", 305 | "target": "Entropy Encoding" 306 | }, 307 | { 308 | "source": "Entropy Encoding", 309 | "target": "Huffman Coding" 310 | }, 311 | { 312 | "source": "Entropy Encoding", 313 | "target": "Arithmetic Coding" 314 | }, 315 | { 316 | "source": "Lossless Compression", 317 | "target": "Dictionary Coder" 318 | }, 319 | { 320 | "source": "Dictionary Coder", 321 | "target": "Lempel-Ziv" 322 | }, 323 | { 324 | "source": "Lempel-Ziv", 325 | "target": "Lempel-Ziv-Oberhumer", 326 | "type": "derive" 327 | }, 328 | { 329 | "source": "Lempel-Ziv", 330 | "target": "Lempel-Ziv-Oberhumer", 331 | "type": "derive" 332 | }, 333 | { 334 | "source": "Lempel-Ziv", 335 | "target": "Lempel–Ziv–Storer–Szymanski", 336 | "type": "derive" 337 | }, 338 | { 339 | "source": "Lempel–Ziv–Storer–Szymanski", 340 | "target": "Deflate", 341 | "type": "derive" 342 | }, 343 | { 344 | "source": "Huffman Coding", 345 | "target": "Deflate", 346 | "type": "derive" 347 | }, 348 | { 349 | "source": "Deflate", 350 | "target": "gzip" 351 | }, 352 | { 353 | "source": "Deflate", 354 | "target": "zlib" 355 | }, 356 | { 357 | "source": "Lempel-Ziv", 358 | "target": "Lempel-Ziv-Markov Chain", 359 | "type": "derive" 360 | }, 361 | { 362 | "source": "Lempel-Ziv-Markov Chain", 363 | "target": "LZMA SDK" 364 | }, 365 | { 366 | "source": "Lempel-Ziv", 367 | "target": "Snappy", 368 | "type": "derive" 369 | }, 370 | { 371 | "source": "Lempel-Ziv", 372 | "target": "Brotli", 373 | "type": "derive" 374 | }, 375 | { 376 | "source": "Entropy Encoding", 377 | "target": "Asymmetric Numeral Systems" 378 | }, 379 | { 380 | "source": "Asymmetric Numeral Systems", 381 | "target": "Finite State Entropy" 382 | }, 383 | { 384 | "source": "Lempel-Ziv", 385 | "target": "Lempel–Ziv Finite State Entropy", 386 | "type": "derive" 387 | }, 388 | { 389 | "source": "Finite State Entropy", 390 | "target": "Lempel–Ziv Finite State Entropy", 391 | "type": "derive" 392 | }, 393 | { 394 | "source": "Asymmetric Numeral Systems", 395 | "target": "Zstandard" 396 | }, 397 | { 398 | "source": "Lempel-Ziv", 399 | "target": "Zstandard", 400 | "type": "derive" 401 | }, 402 | { 403 | "source": "Lossless Compression", 404 | "target": "Run-length Encoding" 405 | }, 406 | { 407 | "source": "Lossless Compression", 408 | "target": "Delta Encoding" 409 | }, 410 | { 411 | "source": "Lossless Compression", 412 | "target": "Golomb Coding" 413 | }, 414 | { 415 | "source": "Golomb Coding", 416 | "target": "Rice Coding", 417 | "type": "derive" 418 | }, 419 | { 420 | "source": "Lossless Compression", 421 | "target": "Burrows-Wheeler Transform" 422 | }, 423 | { 424 | "source": "Burrows-Wheeler Transform", 425 | "target": "bzip2", 426 | "type": "derive" 427 | }, 428 | { 429 | "source": "Data Compression", 430 | "target": "Lossy Compression" 431 | }, 432 | { 433 | "source": "Lossy Compression", 434 | "target": "Quantization" 435 | }, 436 | { 437 | "source": "Lossy Compression", 438 | "target": "Transform Coding" 439 | }, 440 | { 441 | "source": "Transform Coding", 442 | "target": "Discrete Cosine Transform" 443 | }, 444 | { 445 | "source": "Lossy Compression", 446 | "target": "Predictive Coding" 447 | }, 448 | { 449 | "source": "Predictive Coding", 450 | "target": "Differential Pulse-code Modulation" 451 | }, 452 | { 453 | "source": "Differential Pulse-code Modulation", 454 | "target": "Adaptive Differential Pulse-code Modulation", 455 | "type": "derive" 456 | }, 457 | { 458 | "source": "Data Compression", 459 | "target": "Texture Compression" 460 | } 461 | ] 462 | } -------------------------------------------------------------------------------- /tech/programming.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Programming", 5 | "aka": "Coding", 6 | "link": "https://en.wikipedia.org/wiki/Computer_programming" 7 | }, 8 | { 9 | "id": "Programming Paradigm", 10 | "link": "https://en.wikipedia.org/wiki/Programming_paradigm" 11 | }, 12 | { 13 | "id": "Procedural Programming", 14 | "link": "https://en.wikipedia.org/wiki/Procedural_programming" 15 | }, 16 | { 17 | "id": "Object-oriented Programming", 18 | "abbr": "OOP" 19 | }, 20 | { 21 | "id": "Data-oriented Programming", 22 | "abbr": "DOP", 23 | "link": "https://en.wikipedia.org/wiki/Data-oriented_design" 24 | }, 25 | { 26 | "id": "Functional Programming", 27 | "abbr": "FP", 28 | "link": "https://en.wikipedia.org/wiki/Functional_programming" 29 | }, 30 | { 31 | "id": "Generic Programming", 32 | "link": "https://en.wikipedia.org/wiki/Generic_programming" 33 | }, 34 | { 35 | "id": "Metaprogramming", 36 | "link": "https://en.wikipedia.org/wiki/Metaprogramming" 37 | }, 38 | { 39 | "id": "Event-driven Programming" 40 | }, 41 | { 42 | "id": "Data-driven Programming", 43 | "link": "https://en.wikipedia.org/wiki/Data-driven_programming" 44 | }, 45 | { 46 | "id": "Programming Language", 47 | "link": "https://en.wikipedia.org/wiki/Programming_language" 48 | }, 49 | { 50 | "id": "Assembly", 51 | "author": "David Wheeler", 52 | "link": "https://en.wikipedia.org/wiki/Assembly_language", 53 | "year": 1949 54 | }, 55 | { 56 | "id": "Compiled Language" 57 | }, 58 | { 59 | "id": "C", 60 | "author": "Dennis Ritchie", 61 | "link": [ 62 | "https://en.cppreference.com/w/c", 63 | "https://en.wikipedia.org/wiki/C_(programming_language)" 64 | ], 65 | "year": 1972 66 | }, 67 | { 68 | "id": "Objective-C", 69 | "author": [ 70 | "Tom Love", 71 | "Brad Cox" 72 | ], 73 | "link": "https://en.wikipedia.org/wiki/Objective-C", 74 | "year": 1984 75 | }, 76 | { 77 | "id": "C++", 78 | "author": "Bjarne Stroustrup", 79 | "link": [ 80 | "https://en.cppreference.com/w/cpp", 81 | "https://en.wikipedia.org/wiki/C%2B%2B" 82 | ], 83 | "year": 1985 84 | }, 85 | { 86 | "id": "Java", 87 | "author": "James Gosling", 88 | "organization": [ 89 | "Sun", 90 | "Oracle" 91 | ], 92 | "link": [ 93 | "https://www.oracle.com/java/", 94 | "https://en.wikipedia.org/wiki/Java_(programming_language)" 95 | ], 96 | "year": 1995 97 | }, 98 | { 99 | "id": "C#", 100 | "author": "Anders Hejlsberg", 101 | "organization": "Microsoft", 102 | "link": [ 103 | "https://docs.microsoft.com/en-us/dotnet/csharp/", 104 | "https://en.wikipedia.org/wiki/C_Sharp_(programming_language)" 105 | ], 106 | "year": 2000 107 | }, 108 | { 109 | "id": "Go", 110 | "author": [ 111 | "Robert Griesemer", 112 | "Rob Pike", 113 | "Ken Thompson" 114 | ], 115 | "link": [ 116 | "https://golang.org/", 117 | "https://en.wikipedia.org/wiki/Go_(programming_language)" 118 | ], 119 | "year": 2009 120 | }, 121 | { 122 | "id": "Rust", 123 | "author": "Graydon Hoare", 124 | "link": [ 125 | "https://www.rust-lang.org/", 126 | "https://en.wikipedia.org/wiki/Rust_(programming_language)" 127 | ], 128 | "year": 2010 129 | }, 130 | { 131 | "id": "Scripting Language", 132 | "link": "https://en.wikipedia.org/wiki/Scripting_language" 133 | }, 134 | { 135 | "id": "Python", 136 | "author": "Guido van Rossum", 137 | "link": [ 138 | "https://www.python.org/", 139 | "https://en.wikipedia.org/wiki/Python_(programming_language)" 140 | ], 141 | "year": 1991 142 | }, 143 | { 144 | "id": "Lua", 145 | "author": [ 146 | "Roberto Ierusalimschy", 147 | "Waldemar Celes", 148 | "Luiz Henrique de Figueiredo" 149 | ], 150 | "link": [ 151 | "https://www.lua.org/", 152 | "https://en.wikipedia.org/wiki/Lua_(programming_language)" 153 | ], 154 | "year": 1993 155 | }, 156 | { 157 | "id": "JavaScript", 158 | "abbr": "JS", 159 | "aka": "ECMAScript", 160 | "author": "Brendan Eich", 161 | "link": [ 162 | "https://www.ecma-international.org/publications-and-standards/standards/ecma-262/", 163 | "https://en.wikipedia.org/wiki/JavaScript" 164 | ], 165 | "year": 1995 166 | }, 167 | { 168 | "id": "Visual Programming Language", 169 | "abbr": "VPL", 170 | "link": "https://en.wikipedia.org/wiki/Visual_programming_language" 171 | }, 172 | { 173 | "id": "Scratch", 174 | "organization": "MIT", 175 | "link": [ 176 | "https://scratch.mit.edu/", 177 | "https://en.wikipedia.org/wiki/Scratch_(programming_language)" 178 | ], 179 | "year": 2003 180 | }, 181 | { 182 | "id": "Blueprint", 183 | "organization": "Epic Games", 184 | "link": "https://docs.unrealengine.com/en-US/ProgrammingAndScripting/Blueprints/index.html", 185 | "year": 2012 186 | }, 187 | { 188 | "id": "Shading Language", 189 | "link": "https://en.wikipedia.org/wiki/Shading_language" 190 | }, 191 | { 192 | "id": "Cg Programming Language", 193 | "author": [ 194 | "William R. Mark", 195 | "R. Steven Glanville", 196 | "Kurt Akeley", 197 | "Mark J. Kilgard" 198 | ], 199 | "title": "Cg: A system for programming graphics hardware in a C-like language.", 200 | "conference": "SIGGRAPH", 201 | "link": [ 202 | "https://dl.acm.org/doi/pdf/10.1145/1201775.882362", 203 | "https://developer.download.nvidia.com/CgTutorial/cg_tutorial_chapter01.html" 204 | ], 205 | "year": 2003 206 | }, 207 | { 208 | "id": "High-Level Shader Language", 209 | "abbr": "HLSL", 210 | "organization": "Microsoft", 211 | "link": [ 212 | "https://en.wikipedia.org/wiki/High-Level_Shading_Language" 213 | ], 214 | "year": 2002 215 | }, 216 | { 217 | "id": "OpenGL Shading Language", 218 | "abbr": "GLSL", 219 | "organization": "Khronos Group", 220 | "link": "https://en.wikipedia.org/wiki/OpenGL_Shading_Language", 221 | "year": 2004 222 | }, 223 | { 224 | "id": "OpenGL ES Shading Language", 225 | "abbr": "GLSL ES", 226 | "organization": "Khronos Group", 227 | "link": "https://en.wikipedia.org/wiki/OpenGL_Shading_Language", 228 | "year": 2009 229 | }, 230 | { 231 | "id": "Metal Shading Language", 232 | "abbr": "MSL" 233 | }, 234 | { 235 | "id": "Intermediate Language", 236 | "abbr": "IR" 237 | }, 238 | { 239 | "id": "Common Intermediate Language", 240 | "abbr": "CIL", 241 | "organization": "Microsoft", 242 | "link": [ 243 | "https://www.ecma-international.org/publications-and-standards/standards/ecma-335/", 244 | "https://en.wikipedia.org/wiki/Common_Intermediate_Language" 245 | ], 246 | "year": 2001 247 | }, 248 | { 249 | "id": "DirectX Intermediate Language", 250 | "organization": "Microsoft", 251 | "abbr": "DXIR", 252 | "link": "https://github.com/microsoft/DirectXShaderCompiler/blob/master/docs/DXIL.rst" 253 | }, 254 | { 255 | "id": "LLVM Intermediate Representation", 256 | "abbr": "LLVM IR", 257 | "link": [ 258 | "https://www.llvm.org/", 259 | "https://en.wikipedia.org/wiki/LLVM" 260 | ], 261 | "year": 2003 262 | }, 263 | { 264 | "id": "Standard Portable Intermediate Representation", 265 | "abbr": "SPIR", 266 | "organization": "Khronos Group", 267 | "link": [ 268 | "https://www.khronos.org/spir", 269 | "https://en.wikipedia.org/wiki/Standard_Portable_Intermediate_Representation" 270 | ], 271 | "year": 2013 272 | }, 273 | { 274 | "id": "Standard Portable Intermediate Representation V", 275 | "abbr": "SPIR-V", 276 | "organization": "Khronos Group", 277 | "link": [ 278 | "https://www.khronos.org/spir", 279 | "https://en.wikipedia.org/wiki/Standard_Portable_Intermediate_Representation" 280 | ], 281 | "year": 2015 282 | }, 283 | { 284 | "id": "Sh", 285 | "author": [ 286 | "Michael D. McCool", 287 | "Zheng Qin", 288 | "Tiberiu S. Popa" 289 | ], 290 | "title": "Shader Metaprogramming", 291 | "link": "http://www.cs.cmu.edu/afs/cs.cmu.edu/academic/class/15869-f11/www/readings/mccool02_sh.pdf", 292 | "year": 2002 293 | }, 294 | { 295 | "id": "Slang", 296 | "author": [ 297 | "Yong He", 298 | "Kayvon Fatahalian", 299 | "Tim Foley" 300 | ], 301 | "title": "Slang: language mechanisms for extensible real-time shading systems.", 302 | "journal": "TOG", 303 | "link": "https://dl.acm.org/doi/pdf/10.1145/3197517.3201380", 304 | "year": 2018 305 | } 306 | ], 307 | "links": [ 308 | { 309 | "source": "Technology", 310 | "target": "Programming" 311 | }, 312 | { 313 | "source": "Programming", 314 | "target": "Programming Paradigm" 315 | }, 316 | { 317 | "source": "Programming Paradigm", 318 | "target": "Procedural Programming" 319 | }, 320 | { 321 | "source": "Programming Paradigm", 322 | "target": "Object-oriented Programming" 323 | }, 324 | { 325 | "source": "Programming Paradigm", 326 | "target": "Data-oriented Programming" 327 | }, 328 | { 329 | "source": "Programming Paradigm", 330 | "target": "Functional Programming" 331 | }, 332 | { 333 | "source": "Programming Paradigm", 334 | "target": "Generic Programming" 335 | }, 336 | { 337 | "source": "Programming Paradigm", 338 | "target": "Metaprogramming" 339 | }, 340 | { 341 | "source": "Programming Paradigm", 342 | "target": "Data-driven Programming" 343 | }, 344 | { 345 | "source": "Programming Paradigm", 346 | "target": "Event-driven Programming" 347 | }, 348 | { 349 | "source": "Programming", 350 | "target": "Programming Language" 351 | }, 352 | { 353 | "source": "Programming Language", 354 | "target": "Assembly" 355 | }, 356 | { 357 | "source": "Programming Language", 358 | "target": "Compiled Language" 359 | }, 360 | { 361 | "source": "Compiled Language", 362 | "target": "C" 363 | }, 364 | { 365 | "source": "Compiled Language", 366 | "target": "Objective-C" 367 | }, 368 | { 369 | "source": "C", 370 | "target": "Objective-C", 371 | "type": "derive" 372 | }, 373 | { 374 | "source": "Compiled Language", 375 | "target": "C++" 376 | }, 377 | { 378 | "source": "C", 379 | "target": "C++", 380 | "type": "derive" 381 | }, 382 | { 383 | "source": "Compiled Language", 384 | "target": "Java" 385 | }, 386 | { 387 | "source": "Compiled Language", 388 | "target": "C#" 389 | }, 390 | { 391 | "source": "Compiled Language", 392 | "target": "Go" 393 | }, 394 | { 395 | "source": "Compiled Language", 396 | "target": "Rust" 397 | }, 398 | { 399 | "source": "Programming Language", 400 | "target": "Scripting Language" 401 | }, 402 | { 403 | "source": "Scripting Language", 404 | "target": "Python" 405 | }, 406 | { 407 | "source": "Scripting Language", 408 | "target": "Lua" 409 | }, 410 | { 411 | "source": "Scripting Language", 412 | "target": "JavaScript" 413 | }, 414 | { 415 | "source": "Programming Language", 416 | "target": "Visual Programming Language" 417 | }, 418 | { 419 | "source": "Visual Programming Language", 420 | "target": "Scratch" 421 | }, 422 | { 423 | "source": "Visual Programming Language", 424 | "target": "Blueprint" 425 | }, 426 | { 427 | "source": "Programming Language", 428 | "target": "Shading Language" 429 | }, 430 | { 431 | "source": "Shading Language", 432 | "target": "High-Level Shader Language" 433 | }, 434 | { 435 | "source": "Shading Language", 436 | "target": "Cg Programming Language" 437 | }, 438 | { 439 | "source": "Shading Language", 440 | "target": "OpenGL Shading Language" 441 | }, 442 | { 443 | "source": "Shading Language", 444 | "target": "OpenGL ES Shading Language" 445 | }, 446 | { 447 | "source": "Shading Language", 448 | "target": "Metal Shading Language" 449 | }, 450 | { 451 | "source": "Programming Language", 452 | "target": "Intermediate Language" 453 | }, 454 | { 455 | "source": "Intermediate Language", 456 | "target": "Common Intermediate Language" 457 | }, 458 | { 459 | "source": "Intermediate Language", 460 | "target": "DirectX Intermediate Language" 461 | }, 462 | { 463 | "source": "Intermediate Language", 464 | "target": "LLVM Intermediate Representation" 465 | }, 466 | { 467 | "source": "Intermediate Language", 468 | "target": "Standard Portable Intermediate Representation" 469 | }, 470 | { 471 | "source": "Standard Portable Intermediate Representation", 472 | "target": "Standard Portable Intermediate Representation V", 473 | "type": "derive" 474 | }, 475 | { 476 | "source": "Shading Language", 477 | "target": "Standard Portable Intermediate Representation V" 478 | }, 479 | { 480 | "source": "Shading Language", 481 | "target": "Sh" 482 | }, 483 | { 484 | "source": "Shading Language", 485 | "target": "Slang" 486 | } 487 | ] 488 | } -------------------------------------------------------------------------------- /tech/graphics/rendering/shadow.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Shadow" 5 | }, 6 | { 7 | "id": "Shadow Volume", 8 | "author": "Franklin Crow", 9 | "title": "Shadow Algorithms for Computer Graphics", 10 | "conference": "SIGGRAPH", 11 | "link": "http://www.cs.rpi.edu/~cutler/classes/advancedgraphics/S15/papers/crow_shadows_77.pdf", 12 | "year": 1977 13 | }, 14 | { 15 | "id": "Stencil Shadow Volume", 16 | "author": "Tim Heidmann", 17 | "title": "Real Shadows, Real Time", 18 | "journal": "IRIS Universe", 19 | "year": 1991 20 | }, 21 | { 22 | "id": "Carmack's Reverse", 23 | "author": "John Carmck", 24 | "link": "https://web.archive.org/web/20080719150755/http://developer.nvidia.com/attach/6832", 25 | "year": 2000 26 | }, 27 | { 28 | "id": "Geometry-based Soft Shadow Volume", 29 | "author": [ 30 | "Ulf Assarsson", 31 | "Tomas Akenine-Moller" 32 | ], 33 | "title": "A Geometry-based Soft Shadow Volume Algorithm using Graphics Hardware", 34 | "journal": "TOG", 35 | "link": "https://dl.acm.org/doi/pdf/10.1145/882262.882300", 36 | "year": 2003 37 | }, 38 | { 39 | "id": "Shadow Map", 40 | "aka": "Shadowing Projection", 41 | "author": "Lance Joseph Williams", 42 | "title": "Casting curved shadows on curved surfaces", 43 | "conference": "SIGGRAPH", 44 | "link": "https://www.researchgate.net/publication/234784687_Casting_Curved_Shadows_on_Curved_Surfaces", 45 | "year": 1978 46 | }, 47 | { 48 | "id": "Shadow Map Projection Schemes" 49 | }, 50 | { 51 | "id": "Perspective Shadow Map", 52 | "abbr": "PSM", 53 | "author": [ 54 | "Marc Stamminger", 55 | "Drettakis George" 56 | ], 57 | "title": "Perspective shadow maps", 58 | "conference": "SIGGRAPH", 59 | "year": 2002 60 | }, 61 | { 62 | "id": "Trapezoidal Shadow Map", 63 | "abbr": "TSM", 64 | "author": [ 65 | "Tobias Martin", 66 | "Tiow-Seng Tan" 67 | ], 68 | "title": "Anti-aliasing and Continuity with Trapezoidal Shadow Maps", 69 | "conference": "EGSR", 70 | "link": "https://www.researchgate.net/publication/220853011_Anti-aliasing_and_Continuity_with_Trapezoidal_Shadow_Maps", 71 | "year": 2004 72 | }, 73 | { 74 | "id": "Parallel-Split Shadow Map", 75 | "abbr": "PSSM", 76 | "author": [ 77 | "Fan Zhang", 78 | "Hanqiu Sun", 79 | "Leilei Xu", 80 | "Lee Kit Lun" 81 | ], 82 | "title": "Parallel-split shadow maps for large-scale virtual environments", 83 | "conference": "VRCAI", 84 | "link": "https://www.researchgate.net/publication/220805307_Parallel-split_shadow_maps_for_large-scale_virtual_environments", 85 | "year": 2006 86 | }, 87 | { 88 | "id": "Cascaded Shadow Map", 89 | "abbr": "CSM", 90 | "author": "Rouslan Dimitrov", 91 | "link": "http://developer.download.nvidia.com/SDK/10.5/opengl/src/cascaded_shadow_maps/doc/cascaded_shadow_maps.pdf", 92 | "year": 2007 93 | }, 94 | { 95 | "id": "Light Space Perspective Shadow Map", 96 | "abbr": "LSPSM", 97 | "author": [ 98 | "Michael Wimmer", 99 | "Daniel Scherzer", 100 | "Werner Purgathofer" 101 | ], 102 | "conference": "EGSR", 103 | "link": "https://www.researchgate.net/publication/220852877_Light_Space_Perspective_Shadow_Maps", 104 | "year": 2004 105 | }, 106 | { 107 | "id": "Shadow Map Filtering Schemes" 108 | }, 109 | { 110 | "id": "Percentage Closer Filtering", 111 | "abbr": "PCF", 112 | "author": [ 113 | "William T. Reeves", 114 | "David H. Salesin", 115 | "Robert L. Cook" 116 | ], 117 | "title": "Rendering Antialiased Shadows with Depth Maps", 118 | "conference": "SIGGRAPH", 119 | "link": "https://graphics.pixar.com/library/ShadowMaps/paper.pdf", 120 | "year": 1987 121 | }, 122 | { 123 | "id": "Variance Shadow Map", 124 | "abbr": "VSM", 125 | "author": [ 126 | "William Donnelly", 127 | "Andrew Lauritzen" 128 | ], 129 | "title": "Variance shadow maps", 130 | "conference": "I3D", 131 | "link": "https://www.researchgate.net/publication/220792112_Variance_shadow_maps", 132 | "year": 2006 133 | }, 134 | { 135 | "id": "Convolution Shadow Map", 136 | "abbr": "CSM", 137 | "author": [ 138 | "Thomas Annen", 139 | "Tom Mertens", 140 | "Philippe Bekaert", 141 | "Hans-Peter Seidel", 142 | "Jan Kautz" 143 | ], 144 | "title": "Convolution Shadow Maps", 145 | "conference": "EGSR", 146 | "year": 2007 147 | }, 148 | { 149 | "id": "Exponential Shadow Map", 150 | "abbr": "ESM", 151 | "author": [ 152 | "Thomas Annen", 153 | "Tom Mertens", 154 | "Hans-Peter Seidel", 155 | "Eddy Flerackers", 156 | "Jan Kautz" 157 | ], 158 | "title": "Exponential Shadow Maps", 159 | "conference": "Graphics Interface", 160 | "link": "https://www.researchgate.net/publication/32893024_Exponential_Shadow_Maps", 161 | "year": 2008 162 | }, 163 | { 164 | "id": "Moment Shadow Map", 165 | "abbr": "MSM", 166 | "author": [ 167 | "Christoph Peters", 168 | "Reinhard Klein" 169 | ], 170 | "title": "Moment shadow mapping", 171 | "conference": "I3D", 172 | "link": [ 173 | "https://dl.acm.org/doi/pdf/10.1145/2699276.2699277", 174 | "https://www.gdcvault.com/play/1023864/Rendering-Antialiased-Shadows-with-Moment" 175 | ], 176 | "year": 2015 177 | }, 178 | { 179 | "id": "Soft Shadow Shadow Map" 180 | }, 181 | { 182 | "id": "Percentage Closer Soft Shadow", 183 | "abbr": "PCSS", 184 | "author": "Randima Fernando", 185 | "conference": "SIGGRAPH", 186 | "link": [ 187 | "https://dl.acm.org/doi/pdf/10.1145/1187112.1187153", 188 | "https://http.download.nvidia.com/developer/presentations/2005/SIGGRAPH/Percentage_Closer_Soft_Shadows.pdf" 189 | ], 190 | "year": 2005 191 | }, 192 | { 193 | "id": "Screen-space Soft Shadow", 194 | "abbr": "SSSS", 195 | "author": [ 196 | "Jesus Gumbau", 197 | "Miguel Chover", 198 | "Mateu Sbert" 199 | ], 200 | "title": "Screen space soft shadows", 201 | "journal": "GPU Pro", 202 | "year": 2010 203 | }, 204 | { 205 | "id": "Variance Soft Shadow Map", 206 | "abbr": "VSSM", 207 | "author": [ 208 | "Baoguang Yang", 209 | "Zhao Dong", 210 | "Jieqing Feng", 211 | "Hans-Peter Seidel", 212 | "Jan Kautz" 213 | ], 214 | "title": "Variance Soft Shadow Mapping", 215 | "conference": "Pacific Graphics", 216 | "link": "https://www.researchgate.net/publication/261844424_Variance_soft_shadow_mapping", 217 | "year": 2010 218 | }, 219 | { 220 | "id": "Shadow Map with Transparency" 221 | }, 222 | { 223 | "id": "Deep Shadow Map", 224 | "abbr": "DSM", 225 | "author": [ 226 | "Tom Lokovic", 227 | "Eric Veach" 228 | ], 229 | "title": "Deep shadow maps", 230 | "conference": "SIGGRAPH", 231 | "link": "https://graphics.stanford.edu/papers/deepshadows/deepshad.pdf", 232 | "year": 2000 233 | }, 234 | { 235 | "id": "Opacity Shadow Map", 236 | "abbr": "OSM", 237 | "author": [ 238 | "Tae-Yong Kim", 239 | "Ulrich Neumann" 240 | ], 241 | "conference": "EGSR", 242 | "link": "http://diglib.eg.org/bitstream/handle/10.2312/EGWR.EGWR01.177-182/177-182.pdf", 243 | "year": 2001 244 | }, 245 | { 246 | "id": "Colored Stochastic Shadow Map", 247 | "abbr": "CSSM", 248 | "author": [ 249 | "Morgan McGuire", 250 | "Eric Enderton" 251 | ], 252 | "conference": "I3D", 253 | "year": 2011 254 | }, 255 | { 256 | "id": "Omnidirectional Shadow Map" 257 | }, 258 | { 259 | "id": "Cube Shadow Map", 260 | "link": "https://developer.download.nvidia.com/books/HTML/gpugems/gpugems_ch12.html" 261 | }, 262 | { 263 | "id": "Dual Paraboloid Shadow Map", 264 | "abbr": "DPSM", 265 | "author": [ 266 | "Stefan Brabec", 267 | "Thomas Annen", 268 | "Hans-Peter", 269 | "Seidel John Vince" 270 | ], 271 | "title": "Shadow Mapping for Hemispherical and Omnidirectional Light Sources", 272 | "link": "https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.11.3540&rep=rep1&type=pdf", 273 | "year": 2002 274 | }, 275 | { 276 | "id": "Practical Dual Paraboloid Shadow Map", 277 | "author": [ 278 | "Brian Osman", 279 | "Mike Bukowski", 280 | "Chris McEvoy" 281 | ], 282 | "title": "Practical implementation of dual paraboloid shadow maps", 283 | "conference": "SIGGRAPH on Video Game", 284 | "year": 2006 285 | }, 286 | { 287 | "id": "Hemispherical Shadow Map" 288 | }, 289 | { 290 | "id": "Imperfect Shadow Map", 291 | "abbr": "ISM", 292 | "author": [ 293 | "T. Ritschel", 294 | "T. Grosch", 295 | "M. H. Kim", 296 | "H. P. Seidel", 297 | "C. Dachsbacher", 298 | "J. Kautz" 299 | ], 300 | "title": "Imperfect Shadow Maps for Efficient Computation of Indirect Illumination", 301 | "journal": "TOG", 302 | "link": "https://dl.acm.org/doi/pdf/10.1145/1409060.1409082", 303 | "year": 2008 304 | }, 305 | { 306 | "id": "Shadow with Precomputation" 307 | }, 308 | { 309 | "id": "Horizon Mapping", 310 | "title": "Horizon Mapping: Shadows for Bump-Mapped Surfaces", 311 | "author": "Nelson Max", 312 | "journal": "The Visual Computer", 313 | "year": 1988 314 | }, 315 | { 316 | "id": "Interactive Horizon Mapping", 317 | "author": [ 318 | "Peter-Pike J. Sloan", 319 | "Michael F. Cohen" 320 | ], 321 | "conference": "EGSR", 322 | "link": "https://www.ppsloan.org/publications/bs.pdf", 323 | "year": 2000 324 | }, 325 | { 326 | "id": "Occlusion Interval Map", 327 | "author": [ 328 | "William Donnelly", 329 | "Joe Demers" 330 | ], 331 | "title": "Generating soft shadows using occlusion interval maps", 332 | "journal": "GPU Gems", 333 | "year": 2004 334 | } 335 | ], 336 | "links": [ 337 | { 338 | "source": "Rendering", 339 | "target": "Shadow" 340 | }, 341 | { 342 | "source": "Shadow", 343 | "target": "Shadow Volume" 344 | }, 345 | { 346 | "source": "Shadow Volume", 347 | "target": "Stencil Shadow Volume", 348 | "type": "derive" 349 | }, 350 | { 351 | "source": "Stencil Shadow Volume", 352 | "target": "Carmack's Reverse", 353 | "type": "derive" 354 | }, 355 | { 356 | "source": "Shadow Volume", 357 | "target": "Geometry-based Soft Shadow Volume", 358 | "type": "derive" 359 | }, 360 | { 361 | "source": "Shadow", 362 | "target": "Shadow Map" 363 | }, 364 | { 365 | "source": "Shadow Map", 366 | "target": "Shadow Map Projection Schemes", 367 | "type": "derive" 368 | }, 369 | { 370 | "source": "Shadow Map Projection Schemes", 371 | "target": "Perspective Shadow Map" 372 | }, 373 | { 374 | "source": "Shadow Map Projection Schemes", 375 | "target": "Trapezoidal Shadow Map" 376 | }, 377 | { 378 | "source": "Shadow Map Projection Schemes", 379 | "target": "Parallel-Split Shadow Map" 380 | }, 381 | { 382 | "source": "Shadow Map Projection Schemes", 383 | "target": "Cascaded Shadow Map" 384 | }, 385 | { 386 | "source": "Shadow Map Projection Schemes", 387 | "target": "Light Space Perspective Shadow Map" 388 | }, 389 | { 390 | "source": "Shadow Map", 391 | "target": "Shadow Map Filtering Schemes", 392 | "type": "derive" 393 | }, 394 | { 395 | "source": "Shadow Map Filtering Schemes", 396 | "target": "Percentage Closer Filtering" 397 | }, 398 | { 399 | "source": "Shadow Map Filtering Schemes", 400 | "target": "Variance Shadow Map" 401 | }, 402 | { 403 | "source": "Shadow Map Filtering Schemes", 404 | "target": "Convolution Shadow Map", 405 | "type": "derive" 406 | }, 407 | { 408 | "source": "Convolution Shadow Map", 409 | "target": "Exponential Shadow Map", 410 | "type": "derive" 411 | }, 412 | { 413 | "source": "Exponential Shadow Map", 414 | "target": "Moment Shadow Map", 415 | "type": "derive" 416 | }, 417 | { 418 | "source": "Shadow Map", 419 | "target": "Soft Shadow Shadow Map", 420 | "type": "derive" 421 | }, 422 | { 423 | "source": "Soft Shadow Shadow Map", 424 | "target": "Percentage Closer Soft Shadow" 425 | }, 426 | { 427 | "source": "Soft Shadow Shadow Map", 428 | "target": "Screen-space Soft Shadow" 429 | }, 430 | { 431 | "source": "Soft Shadow Shadow Map", 432 | "target": "Variance Soft Shadow Map" 433 | }, 434 | { 435 | "source": "Shadow Map", 436 | "target": "Shadow Map with Transparency" 437 | }, 438 | { 439 | "source": "Shadow Map with Transparency", 440 | "target": "Deep Shadow Map" 441 | }, 442 | { 443 | "source": "Shadow Map with Transparency", 444 | "target": "Opacity Shadow Map" 445 | }, 446 | { 447 | "source": "Shadow Map with Transparency", 448 | "target": "Colored Stochastic Shadow Map" 449 | }, 450 | { 451 | "source": "Shadow Map", 452 | "target": "Omnidirectional Shadow Map" 453 | }, 454 | { 455 | "source": "Omnidirectional Shadow Map", 456 | "target": "Cube Shadow Map" 457 | }, 458 | { 459 | "source": "Cube Shadow Map", 460 | "target": "Cube Mapping" 461 | }, 462 | { 463 | "source": "Omnidirectional Shadow Map", 464 | "target": "Dual Paraboloid Shadow Map" 465 | }, 466 | { 467 | "source": "Dual Paraboloid Shadow Map", 468 | "target": "Dual Paraboloid Mapping", 469 | "type": "use" 470 | }, 471 | { 472 | "source": "Dual Paraboloid Shadow Map", 473 | "target": "Practical Dual Paraboloid Shadow Map", 474 | "type": "derive" 475 | }, 476 | { 477 | "source": "Shadow Map", 478 | "target": "Hemispherical Shadow Map" 479 | }, 480 | { 481 | "source": "Hemispherical Shadow Map", 482 | "target": "Imperfect Shadow Map" 483 | }, 484 | { 485 | "source": "Shadow", 486 | "target": "Shadow with Precomputation" 487 | }, 488 | { 489 | "source": "Shadow with Precomputation", 490 | "target": "Horizon Mapping" 491 | }, 492 | { 493 | "source": "Horizon Mapping", 494 | "target": "Interactive Horizon Mapping", 495 | "type": "derive" 496 | }, 497 | { 498 | "source": "Shadow with Precomputation", 499 | "target": "Occlusion Interval Map" 500 | } 501 | ] 502 | } -------------------------------------------------------------------------------- /tech/programming/datatype.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [ 3 | { 4 | "id": "Data Type", 5 | "link": "https://en.wikipedia.org/wiki/Data_type" 6 | }, 7 | { 8 | "id": "Primitive Data Type", 9 | "link": "https://en.wikipedia.org/wiki/Primitive_data_type" 10 | }, 11 | { 12 | "id": "Boolean", 13 | "link": "https://en.wikipedia.org/wiki/Boolean_data_type" 14 | }, 15 | { 16 | "id": "Character", 17 | "link": "https://en.wikipedia.org/wiki/Character_(computing)" 18 | }, 19 | { 20 | "id": "Enumerated Type", 21 | "link": "https://en.wikipedia.org/wiki/Enumerated_type" 22 | }, 23 | { 24 | "id": "Pointer", 25 | "link": "https://en.wikipedia.org/wiki/Pointer_(computer_programming)" 26 | }, 27 | { 28 | "id": "Null Pointer", 29 | "link": "https://en.wikipedia.org/wiki/Null_pointer" 30 | }, 31 | { 32 | "id": "Opaque Pointer", 33 | "link": "https://en.wikipedia.org/wiki/Opaque_pointer" 34 | }, 35 | { 36 | "id": "Smart Pointer", 37 | "link": "https://en.wikipedia.org/wiki/Smart_pointer" 38 | }, 39 | { 40 | "id": "Reference", 41 | "link": "https://en.wikipedia.org/wiki/Reference_(computer_science)" 42 | }, 43 | { 44 | "id": "Numeric Data Type" 45 | }, 46 | { 47 | "id": "Integral Data Type", 48 | "aka": "Integer", 49 | "link": "https://en.wikipedia.org/wiki/Integer_(computer_science)" 50 | }, 51 | { 52 | "id": "Fixed-point Number", 53 | "link": "https://en.wikipedia.org/wiki/Fixed-point_arithmetic" 54 | }, 55 | { 56 | "id": "Floating-point Number", 57 | "link": "https://en.wikipedia.org/wiki/Floating-point_arithmetic" 58 | }, 59 | { 60 | "id": "Single Precision Floating-point Number", 61 | "aka": [ 62 | "single", 63 | "float", 64 | "binary32" 65 | ] 66 | }, 67 | { 68 | "id": "Double Precision Floating-point Number", 69 | "aka": [ 70 | "double", 71 | "binary64" 72 | ] 73 | }, 74 | { 75 | "id": "Half Precision Floating-point Number", 76 | "aka": [ 77 | "half", 78 | "binary16" 79 | ] 80 | }, 81 | { 82 | "id": "IEEE 754", 83 | "organization": "IEEE", 84 | "link": [ 85 | "https://standards.ieee.org/standard/754-2019.html", 86 | "https://en.wikipedia.org/wiki/IEEE_754", 87 | "https://dl.acm.org/doi/pdf/10.1145/103162.103163" 88 | ], 89 | "year": 1985 90 | }, 91 | { 92 | "id": "Signed Zero", 93 | "link": "https://en.wikipedia.org/wiki/Signed_zero" 94 | }, 95 | { 96 | "id": "Denormal Number", 97 | "aka": "Subnormal Number", 98 | "link": "https://en.wikipedia.org/wiki/Denormal_number" 99 | }, 100 | { 101 | "id": "NaN", 102 | "aka": "Not a Number", 103 | "link": "https://en.wikipedia.org/wiki/NaN" 104 | }, 105 | { 106 | "id": "Infinity", 107 | "link": "https://en.wikipedia.org/wiki/Floating-point_arithmetic#Infinities" 108 | }, 109 | { 110 | "id": "Rational Data Type", 111 | "link": "https://en.wikipedia.org/wiki/Rational_data_type" 112 | }, 113 | { 114 | "id": "Complex Data Type", 115 | "link": "https://en.wikipedia.org/wiki/Complex_data_type" 116 | }, 117 | { 118 | "id": "Signed Number Representation", 119 | "link": "https://en.wikipedia.org/wiki/Signed_number_representations" 120 | }, 121 | { 122 | "id": "Signed Magnitude", 123 | "link": "https://en.wikipedia.org/wiki/Signed_number_representations#Sign-and-magnitude_method" 124 | }, 125 | { 126 | "id": "Ones' Complement", 127 | "link": "https://en.wikipedia.org/wiki/Ones%27_complement" 128 | }, 129 | { 130 | "id": "Two's Complement", 131 | "link": "https://en.wikipedia.org/wiki/Two%27s_complement" 132 | }, 133 | { 134 | "id": "Offset Binary", 135 | "aka": [ 136 | "Excess-k", 137 | "Excess-n", 138 | "Excess-e", 139 | "Excess Code", 140 | "Biased Representation" 141 | ], 142 | "link": "https://en.wikipedia.org/wiki/Offset_binary" 143 | }, 144 | { 145 | "id": "Arbitrary-precision Arithmetic", 146 | "link": "https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" 147 | }, 148 | { 149 | "id": "Composite Data Type", 150 | "link": "https://en.wikipedia.org/wiki/Composite_data_type" 151 | }, 152 | { 153 | "id": "Array Data Type", 154 | "aka": "Array", 155 | "link": "https://en.wikipedia.org/wiki/Array_data_type" 156 | }, 157 | { 158 | "id": "Variable-length Array", 159 | "abbr": "VLA", 160 | "aka": [ 161 | "Variable-sized Array", 162 | "Runtime-sized Array" 163 | ], 164 | "link": "https://en.wikipedia.org/wiki/Variable-length_array" 165 | }, 166 | { 167 | "id": "Array Slicing", 168 | "link": "https://en.wikipedia.org/wiki/Array_slicing" 169 | }, 170 | { 171 | "id": "String", 172 | "link": "https://en.wikipedia.org/wiki/String_(computer_science)" 173 | }, 174 | { 175 | "id": "Null-terminated String", 176 | "link": "https://en.wikipedia.org/wiki/Null-terminated_string" 177 | }, 178 | { 179 | "id": "Empty String", 180 | "aka": "Empty Word", 181 | "link": "https://en.wikipedia.org/wiki/Empty_string" 182 | }, 183 | { 184 | "id": "Record", 185 | "aka": [ 186 | "Structure", 187 | "Struct", 188 | "Compound Data" 189 | ], 190 | "link": "https://en.wikipedia.org/wiki/Record_(computer_science)" 191 | }, 192 | { 193 | "id": "Union Type", 194 | "link": "https://en.wikipedia.org/wiki/Union_type" 195 | }, 196 | { 197 | "id": "Tagged Union", 198 | "aka": "Variant", 199 | "link": "https://en.wikipedia.org/wiki/Tagged_union" 200 | }, 201 | { 202 | "id": "Algebraic Data Type", 203 | "link": "https://en.wikipedia.org/wiki/Algebraic_data_type" 204 | }, 205 | { 206 | "id": "Sum Type", 207 | "link": "https://en.wikipedia.org/wiki/Tagged_union" 208 | }, 209 | { 210 | "id": "Product Type", 211 | "link": "https://en.wikipedia.org/wiki/Product_type" 212 | }, 213 | { 214 | "id": "Option Type", 215 | "aka": "Maybe Type", 216 | "link": "https://en.wikipedia.org/wiki/Option_type" 217 | }, 218 | { 219 | "id": "Result Type", 220 | "link": "https://en.wikipedia.org/wiki/Result_type" 221 | }, 222 | { 223 | "id": "Abstract Data Type", 224 | "abbr": "ADT", 225 | "link": "https://en.wikipedia.org/wiki/Abstract_data_type" 226 | }, 227 | { 228 | "id": "Pair", 229 | "link": "https://en.wikipedia.org/wiki/Product_type" 230 | }, 231 | { 232 | "id": "Tuple", 233 | "link": "https://en.wikipedia.org/wiki/Product_type" 234 | }, 235 | { 236 | "id": "List", 237 | "link": "https://en.wikipedia.org/wiki/List_(abstract_data_type)" 238 | }, 239 | { 240 | "id": "Set", 241 | "link": "https://en.wikipedia.org/wiki/Set_(abstract_data_type)" 242 | }, 243 | { 244 | "id": "Multiset", 245 | "aka": [ 246 | "Bag", 247 | "mset" 248 | ], 249 | "link": "https://en.wikipedia.org/wiki/Multiset" 250 | }, 251 | { 252 | "id": "Map", 253 | "aka": [ 254 | "Associative Array", 255 | "Symbol Table", 256 | "Dictionary" 257 | ], 258 | "link": "https://en.wikipedia.org/wiki/Associative_array" 259 | }, 260 | { 261 | "id": "Multimap", 262 | "aka": [ 263 | "Multihash", 264 | "Multidict" 265 | ], 266 | "link": "https://en.wikipedia.org/wiki/Multimap" 267 | }, 268 | { 269 | "id": "Stack", 270 | "aka": "LIFO", 271 | "link": "https://en.wikipedia.org/wiki/Stack_(abstract_data_type)" 272 | }, 273 | { 274 | "id": "Queue", 275 | "aka": "FIFO", 276 | "link": "https://en.wikipedia.org/wiki/Queue_(abstract_data_type)" 277 | }, 278 | { 279 | "id": "Double-ended Queue", 280 | "aka": "Deque", 281 | "link": "https://en.wikipedia.org/wiki/Double-ended_queue" 282 | }, 283 | { 284 | "id": "Priority Queue", 285 | "link": "https://en.wikipedia.org/wiki/Priority_queue" 286 | }, 287 | { 288 | "id": "Double-ended Priority Queue", 289 | "abbr": "DEPQ", 290 | "aka": "Double-ended Heap", 291 | "link": "https://en.wikipedia.org/wiki/Double-ended_priority_queue" 292 | } 293 | ], 294 | "links": [ 295 | { 296 | "source": "Programming", 297 | "target": "Data Type" 298 | }, 299 | { 300 | "source": "Data Type", 301 | "target": "Primitive Data Type" 302 | }, 303 | { 304 | "source": "Primitive Data Type", 305 | "target": "Boolean" 306 | }, 307 | { 308 | "source": "Primitive Data Type", 309 | "target": "Character" 310 | }, 311 | { 312 | "source": "Primitive Data Type", 313 | "target": "Enumerated Type" 314 | }, 315 | { 316 | "source": "Primitive Data Type", 317 | "target": "Pointer" 318 | }, 319 | { 320 | "source": "Pointer", 321 | "target": "Null Pointer" 322 | }, 323 | { 324 | "source": "Pointer", 325 | "target": "Opaque Pointer" 326 | }, 327 | { 328 | "source": "Pointer", 329 | "target": "Smart Pointer" 330 | }, 331 | { 332 | "source": "Primitive Data Type", 333 | "target": "Reference" 334 | }, 335 | { 336 | "source": "Primitive Data Type", 337 | "target": "Numeric Data Type" 338 | }, 339 | { 340 | "source": "Numeric Data Type", 341 | "target": "Integral Data Type" 342 | }, 343 | { 344 | "source": "Numeric Data Type", 345 | "target": "Fixed-point Number" 346 | }, 347 | { 348 | "source": "Numeric Data Type", 349 | "target": "Floating-point Number" 350 | }, 351 | { 352 | "source": "Floating-point Number", 353 | "target": "Single Precision Floating-point Number" 354 | }, 355 | { 356 | "source": "Floating-point Number", 357 | "target": "Double Precision Floating-point Number" 358 | }, 359 | { 360 | "source": "Floating-point Number", 361 | "target": "Half Precision Floating-point Number" 362 | }, 363 | { 364 | "source": "Floating-point Number", 365 | "target": "IEEE 754" 366 | }, 367 | { 368 | "source": "IEEE 754", 369 | "target": "Signed Zero" 370 | }, 371 | { 372 | "source": "IEEE 754", 373 | "target": "Denormal Number" 374 | }, 375 | { 376 | "source": "IEEE 754", 377 | "target": "NaN" 378 | }, 379 | { 380 | "source": "IEEE 754", 381 | "target": "Infinity" 382 | }, 383 | { 384 | "source": "Numeric Data Type", 385 | "target": "Rational Data Type" 386 | }, 387 | { 388 | "source": "Numeric Data Type", 389 | "target": "Complex Data Type" 390 | }, 391 | { 392 | "source": "Numeric Data Type", 393 | "target": "Signed Number Representation" 394 | }, 395 | { 396 | "source": "Signed Number Representation", 397 | "target": "Signed Magnitude" 398 | }, 399 | { 400 | "source": "Signed Number Representation", 401 | "target": "Ones' Complement" 402 | }, 403 | { 404 | "source": "Signed Number Representation", 405 | "target": "Two's Complement" 406 | }, 407 | { 408 | "source": "Signed Number Representation", 409 | "target": "Offset Binary" 410 | }, 411 | { 412 | "source": "Numeric Data Type", 413 | "target": "Arbitrary-precision Arithmetic" 414 | }, 415 | { 416 | "source": "Data Type", 417 | "target": "Composite Data Type" 418 | }, 419 | { 420 | "source": "Composite Data Type", 421 | "target": "Array Data Type" 422 | }, 423 | { 424 | "source": "Array Data Type", 425 | "target": "Variable-length Array" 426 | }, 427 | { 428 | "source": "Array Data Type", 429 | "target": "Array Slicing" 430 | }, 431 | { 432 | "source": "Composite Data Type", 433 | "target": "String" 434 | }, 435 | { 436 | "source": "String", 437 | "target": "Null-terminated String" 438 | }, 439 | { 440 | "source": "String", 441 | "target": "Empty String" 442 | }, 443 | { 444 | "source": "String", 445 | "target": "Character", 446 | "type": "use" 447 | }, 448 | { 449 | "source": "Composite Data Type", 450 | "target": "Record" 451 | }, 452 | { 453 | "source": "Composite Data Type", 454 | "target": "Union Type" 455 | }, 456 | { 457 | "source": "Composite Data Type", 458 | "target": "Tagged Union" 459 | }, 460 | { 461 | "source": "Composite Data Type", 462 | "target": "Algebraic Data Type" 463 | }, 464 | { 465 | "source": "Algebraic Data Type", 466 | "target": "Sum Type" 467 | }, 468 | { 469 | "source": "Sum Type", 470 | "target": "Tagged Union" 471 | }, 472 | { 473 | "source": "Algebraic Data Type", 474 | "target": "Product Type" 475 | }, 476 | { 477 | "source": "Product Type", 478 | "target": "Record" 479 | }, 480 | { 481 | "source": "Product Type", 482 | "target": "Pair" 483 | }, 484 | { 485 | "source": "Product Type", 486 | "target": "Tuple" 487 | }, 488 | { 489 | "source": "Composite Data Type", 490 | "target": "Option Type" 491 | }, 492 | { 493 | "source": "Composite Data Type", 494 | "target": "Result Type" 495 | }, 496 | { 497 | "source": "Data Type", 498 | "target": "Abstract Data Type" 499 | }, 500 | { 501 | "source": "Abstract Data Type", 502 | "target": "Pair" 503 | }, 504 | { 505 | "source": "Abstract Data Type", 506 | "target": "Tuple" 507 | }, 508 | { 509 | "source": "Abstract Data Type", 510 | "target": "List" 511 | }, 512 | { 513 | "source": "List", 514 | "target": "Linked List", 515 | "type": "use" 516 | }, 517 | { 518 | "source": "Abstract Data Type", 519 | "target": "Set" 520 | }, 521 | { 522 | "source": "Set", 523 | "target": "Hash Table", 524 | "type": "use" 525 | }, 526 | { 527 | "source": "Set", 528 | "target": "Binary Search Tree", 529 | "type": "use" 530 | }, 531 | { 532 | "source": "Set", 533 | "target": "Multiset" 534 | }, 535 | { 536 | "source": "Abstract Data Type", 537 | "target": "Map" 538 | }, 539 | { 540 | "source": "Map", 541 | "target": "Hash Table", 542 | "type": "use" 543 | }, 544 | { 545 | "source": "Map", 546 | "target": "Binary Search Tree", 547 | "type": "use" 548 | }, 549 | { 550 | "source": "Map", 551 | "target": "Multimap" 552 | }, 553 | { 554 | "source": "Abstract Data Type", 555 | "target": "Stack" 556 | }, 557 | { 558 | "source": "Abstract Data Type", 559 | "target": "Queue" 560 | }, 561 | { 562 | "source": "Queue", 563 | "target": "Double-ended Queue" 564 | }, 565 | { 566 | "source": "Queue", 567 | "target": "Circular Buffer", 568 | "type": "use" 569 | }, 570 | { 571 | "source": "Abstract Data Type", 572 | "target": "Priority Queue" 573 | }, 574 | { 575 | "source": "Priority Queue", 576 | "target": "Heap Data Structure", 577 | "type": "use" 578 | }, 579 | { 580 | "source": "Set", 581 | "target": "Binary Search Tree", 582 | "type": "use" 583 | }, 584 | { 585 | "source": "Priority Queue", 586 | "target": "Double-ended Priority Queue" 587 | } 588 | ] 589 | } --------------------------------------------------------------------------------