commit
0e4ec7b7b1
22 changed files with 2020 additions and 0 deletions
@ -0,0 +1,91 @@ |
|||
#.gitignore is a file which makes git ignore files which should |
|||
# not go into version control in the first place |
|||
# Questions? See |
|||
# http://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#Ignoring-Files |
|||
# http://git-scm.com/docs/gitignore |
|||
|
|||
########################### |
|||
# ignore generated binaries |
|||
# but not the data folder |
|||
########################### |
|||
|
|||
/bin/data/images |
|||
/bin/data/recordings |
|||
|
|||
######### |
|||
# general |
|||
######### |
|||
|
|||
[Bb]uild/ |
|||
[Oo]bj/ |
|||
*.o |
|||
[Dd]ebug*/ |
|||
[Rr]elease*/ |
|||
*.mode* |
|||
*.app/ |
|||
*.pyc |
|||
.svn/ |
|||
*.log |
|||
|
|||
######################## |
|||
# IDE files which should |
|||
# be ignored |
|||
######################## |
|||
|
|||
# XCode |
|||
*.pbxuser |
|||
*.perspective |
|||
*.perspectivev3 |
|||
*.mode1v3 |
|||
*.mode2v3 |
|||
# XCode 4 |
|||
*.xccheckout |
|||
xcuserdata/ |
|||
|
|||
# Visual Studio |
|||
*.sdf |
|||
*.opensdf |
|||
*.suo |
|||
*.pdb |
|||
*.ilk |
|||
*.aps |
|||
ipch/ |
|||
|
|||
# Eclipse |
|||
.metadata |
|||
local.properties |
|||
.externalToolBuilders |
|||
|
|||
# Android Studio |
|||
.gradle |
|||
/local.properties |
|||
/.idea/workspace.xml |
|||
/.idea/libraries |
|||
|
|||
################## |
|||
# operating system |
|||
################## |
|||
|
|||
# Linux |
|||
*~ |
|||
# KDE |
|||
.directory |
|||
.AppleDouble |
|||
|
|||
# OSX |
|||
.DS_Store |
|||
*.swp |
|||
*~.nib |
|||
# Thumbnails |
|||
._* |
|||
|
|||
# Windows |
|||
# Image file caches |
|||
Thumbs.db |
|||
# Folder config file |
|||
Desktop.ini |
|||
|
|||
# Android |
|||
.csettings |
|||
|
|||
/bin/data/ |
|||
@ -0,0 +1,194 @@ |
|||
{ |
|||
"configurations": [ |
|||
{ |
|||
"name": "Mac", |
|||
"includePath": [ |
|||
"/usr/include", |
|||
"/usr/local/include", |
|||
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/", |
|||
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/c++/4.2.1", |
|||
"${workspaceRoot}/../../../libs/openFrameworks", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/3d", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/app", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/communication", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/events", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/gl", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/graphics", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/math", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/sound", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/types", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/utils", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/video", |
|||
"${workspaceRoot}/../../../libs/boost/include", |
|||
"${workspaceRoot}/../../../libs/cairo/include", |
|||
"${workspaceRoot}/../../../libs/curl/include", |
|||
"${workspaceRoot}/../../../libs/fmod/include", |
|||
"${workspaceRoot}/../../../libs/FreeImage/include", |
|||
"${workspaceRoot}/../../../libs/freetype/include", |
|||
"${workspaceRoot}/../../../libs/glew/include", |
|||
"${workspaceRoot}/../../../libs/glfw/include", |
|||
"${workspaceRoot}/../../../libs/glm/include", |
|||
"${workspaceRoot}/../../../libs/json/include", |
|||
"${workspaceRoot}/../../../libs/pugixml/include", |
|||
"${workspaceRoot}/../../../libs/rtAudio/include", |
|||
"${workspaceRoot}/../../../libs/tess2/include", |
|||
"${workspaceRoot}/../../../libs/uriparser/include", |
|||
"${workspaceRoot}/../../../libs/utf8/include" |
|||
], |
|||
"browse": { |
|||
"limitSymbolsToIncludedHeaders": true, |
|||
"databaseFilename": "${workspaceRoot}/.vscode/browse.db", |
|||
"path": [ |
|||
"/usr/include", |
|||
"/usr/local/include", |
|||
"/System/Library/Frameworks", |
|||
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/", |
|||
"${workspaceRoot}/../../../libs", |
|||
"${workspaceRoot}/../../../addons", |
|||
"${workspaceRoot}/../../../libs/openFrameworks" |
|||
] |
|||
}, |
|||
"intelliSenseMode": "clang-x64", |
|||
"macFrameworkPath": [ |
|||
"/System/Library/Frameworks", |
|||
"/Library/Frameworks" |
|||
], |
|||
"compilerPath": "/usr/local/bin/gcc-8", |
|||
"cStandard": "c11", |
|||
"cppStandard": "c++17" |
|||
}, |
|||
{ |
|||
"name": "Linux", |
|||
"includePath": [ |
|||
"/usr/include", |
|||
"/usr/local/include", |
|||
"/usr/include/c++/5", |
|||
"/usr/include/c++/5/backward", |
|||
"/usr/lib/gcc/x86_64-linux-gnu/5/include", |
|||
"/usr/lib/x86_64-linux-gnu/glib-2.0/include", |
|||
"/usr/lib/x86_64-linux-gnu/gstreamer-1.0/include", |
|||
"/usr/local/include", |
|||
"/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed", |
|||
"/usr/include/x86_64-linux-gnu", |
|||
"${workspaceRoot}/../../../libs/openFrameworks", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/3d", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/app", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/communication", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/events", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/gl", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/graphics", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/math", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/sound", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/types", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/utils", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/video", |
|||
"${workspaceRoot}/../../../libs/boost/include", |
|||
"${workspaceRoot}/../../../libs/cairo/include", |
|||
"${workspaceRoot}/../../../libs/curl/include", |
|||
"${workspaceRoot}/../../../libs/fmod/include", |
|||
"${workspaceRoot}/../../../libs/FreeImage/include", |
|||
"${workspaceRoot}/../../../libs/freetype/include", |
|||
"${workspaceRoot}/../../../libs/glew/include", |
|||
"${workspaceRoot}/../../../libs/glfw/include", |
|||
"${workspaceRoot}/../../../libs/glm/include", |
|||
"${workspaceRoot}/../../../libs/json/include", |
|||
"${workspaceRoot}/../../../libs/pugixml/include", |
|||
"${workspaceRoot}/../../../libs/rtAudio/include", |
|||
"${workspaceRoot}/../../../libs/tess2/include", |
|||
"${workspaceRoot}/../../../libs/uriparser/include", |
|||
"${workspaceRoot}/../../../libs/utf8/include", |
|||
"${workspaceRoot}/../../../libs/poco/include", |
|||
"${workspaceRoot}/../../../libs/kiss/include", |
|||
"/usr/include/x86_64-linux-gnu/c++/5", |
|||
"/usr/include/pulse", |
|||
"/usr/include/cairo", |
|||
"/usr/include/gstreamer-1.0", |
|||
"/usr/include/glib-2.0", |
|||
"${workspaceRoot}", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxOpenCv/libs/opencv/include/opencv4", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxOpenCv/src", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBox2d/src", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBox2d/libs/Box2D", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBox2d/libs", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/libs", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/src", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/src/shapes", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/src/events", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/src/render", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/libs/bullet2.8.2/include/BulletCollision/CollisionShapes", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/libs/bullet2.8.2/include", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/src/joints", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxFFmpeg/src", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxVideoRecorder/src" |
|||
], |
|||
"browse": { |
|||
"limitSymbolsToIncludedHeaders": true, |
|||
"databaseFilename": "", |
|||
"path": [ |
|||
"/usr/include", |
|||
"/usr/local/include", |
|||
"${workspaceRoot}/../../../libs", |
|||
"${workspaceRoot}/../../../addons", |
|||
"${workspaceRoot}/../../../libs/openFrameworks", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxOpenCv/src", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBox2d/src", |
|||
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxBullet/src" |
|||
] |
|||
}, |
|||
"intelliSenseMode": "clang-x64", |
|||
"compilerPath": "/usr/bin/gcc", |
|||
"cStandard": "c17", |
|||
"cppStandard": "c++17" |
|||
}, |
|||
{ |
|||
"name": "Win32", |
|||
"includePath": [ |
|||
"C:/msys64/mingw32/include/c++/7.4.0", |
|||
"C:/msys64/mingw32/i686-w64-mingw32/include", |
|||
"${workspaceRoot}/../../../libs", |
|||
"${workspaceRoot}/../../../addons", |
|||
"${workspaceRoot}/../../../libs/openFrameworks", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/3d", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/app", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/communication", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/events", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/gl", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/graphics", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/math", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/sound", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/types", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/utils", |
|||
"${workspaceRoot}/../../../libs/openFrameworks/video", |
|||
"${workspaceRoot}/../../../libs/boost/include", |
|||
"${workspaceRoot}/../../../libs/cairo/include", |
|||
"${workspaceRoot}/../../../libs/curl/include", |
|||
"${workspaceRoot}/../../../libs/fmod/include", |
|||
"${workspaceRoot}/../../../libs/FreeImage/include", |
|||
"${workspaceRoot}/../../../libs/freetype/include", |
|||
"${workspaceRoot}/../../../libs/glew/include", |
|||
"${workspaceRoot}/../../../libs/glfw/include", |
|||
"${workspaceRoot}/../../../libs/glm/include", |
|||
"${workspaceRoot}/../../../libs/json/include", |
|||
"${workspaceRoot}/../../../libs/pugixml/include", |
|||
"${workspaceRoot}/../../../libs/rtAudio/include", |
|||
"${workspaceRoot}/../../../libs/tess2/include", |
|||
"${workspaceRoot}/../../../libs/uriparser/include", |
|||
"${workspaceRoot}/../../../libs/utf8/include" |
|||
], |
|||
"browse": { |
|||
"limitSymbolsToIncludedHeaders": true, |
|||
"databaseFilename": "", |
|||
"path": [ |
|||
"${workspaceRoot}/../../../libs", |
|||
"${workspaceRoot}/../../../addons", |
|||
"${workspaceRoot}/../../../libs/openFrameworks" |
|||
] |
|||
}, |
|||
"intelliSenseMode": "clang-x64", |
|||
"compilerPath": "C:/msys64/mingw32/bin/g++.exe", |
|||
"cStandard": "c11", |
|||
"cppStandard": "c++17" |
|||
} |
|||
], |
|||
"version": 4 |
|||
} |
|||
@ -0,0 +1,72 @@ |
|||
{ |
|||
"version": "0.2.0", |
|||
"configurations": [ |
|||
{ |
|||
"name": "C++ Launch", |
|||
"type": "cppdbg", |
|||
"request": "launch", |
|||
"args": [], |
|||
"stopAtEntry": false, |
|||
"cwd": "${workspaceRoot}", |
|||
"environment": [], |
|||
"externalConsole": false, |
|||
"linux": { |
|||
"MIMode": "gdb", |
|||
"setupCommands": [ |
|||
{ |
|||
"description": "Enable pretty-printing for gdb", |
|||
"text": "-enable-pretty-printing", |
|||
"ignoreFailures": true |
|||
} |
|||
], |
|||
"program": "${workspaceRoot}/bin/${workspaceFolderBasename}_debug" |
|||
}, |
|||
"osx": { |
|||
"MIMode": "lldb", |
|||
"program": "${workspaceRoot}/bin/${workspaceFolderBasename}_debug.app/Contents/MacOS/${workspaceFolderBasename}_debug" |
|||
}, |
|||
"windows": { |
|||
"MIMode": "gdb", |
|||
"miDebuggerPath": "gdb.exe", |
|||
"setupCommands": [ |
|||
{ |
|||
"description": "Enable pretty-printing for gdb", |
|||
"text": "-enable-pretty-printing", |
|||
"ignoreFailures": true |
|||
} |
|||
], |
|||
"program": "${workspaceRoot}/bin/${workspaceFolderBasename}_debug" |
|||
} |
|||
}, |
|||
{ |
|||
"name": "C++ Attach", |
|||
"type": "cppdbg", |
|||
"request": "attach", |
|||
"program": "enter program name, for example ${workspaceRoot}/a.out", |
|||
"processId": "${command:pickProcess}", |
|||
"linux": { |
|||
"MIMode": "gdb", |
|||
"setupCommands": [ |
|||
{ |
|||
"description": "Enable pretty-printing for gdb", |
|||
"text": "-enable-pretty-printing", |
|||
"ignoreFailures": true |
|||
} |
|||
] |
|||
}, |
|||
"osx": { |
|||
"MIMode": "lldb" |
|||
}, |
|||
"windows": { |
|||
"MIMode": "gdb", |
|||
"setupCommands": [ |
|||
{ |
|||
"description": "Enable pretty-printing for gdb", |
|||
"text": "-enable-pretty-printing", |
|||
"ignoreFailures": true |
|||
} |
|||
] |
|||
} |
|||
} |
|||
] |
|||
} |
|||
@ -0,0 +1,133 @@ |
|||
{ |
|||
"version": "2.0.0", |
|||
"shell":{ |
|||
"task": true |
|||
}, |
|||
"tasks": [ |
|||
{ |
|||
"type": "shell", |
|||
"label": "Build RELEASE", |
|||
"presentation": { |
|||
"reveal": "always", |
|||
"panel": "shared" |
|||
}, |
|||
"command": "make -j -s 2>&1 && make RunRelease", |
|||
"group": { |
|||
"kind": "build", |
|||
"isDefault": true |
|||
}, |
|||
"problemMatcher": { |
|||
"owner": "cpp", |
|||
"fileLocation": ["relative", "${workspaceFolder}"], |
|||
"pattern": { |
|||
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
|||
"file": 1, |
|||
"line": 2, |
|||
"column": 3, |
|||
"severity": 4, |
|||
"message": 5 |
|||
} |
|||
} |
|||
}, |
|||
{ |
|||
"type": "shell", |
|||
"label": "Build DEBUG", |
|||
"presentation": { |
|||
"reveal": "always", |
|||
"panel": "shared" |
|||
}, |
|||
"command": "make Debug -j -s 2>&1 || exit 1", |
|||
"group": { |
|||
"kind": "build", |
|||
"isDefault": true |
|||
}, |
|||
"problemMatcher": { |
|||
"owner": "cpp", |
|||
"fileLocation": ["relative", "${workspaceFolder}"], |
|||
"pattern": { |
|||
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
|||
"file": 1, |
|||
"line": 2, |
|||
"column": 3, |
|||
"severity": 4, |
|||
"message": 5 |
|||
} |
|||
} |
|||
}, |
|||
{ |
|||
"type": "shell", |
|||
"label": "Clean DEBUG", |
|||
"presentation": { |
|||
"reveal": "always", |
|||
"panel": "shared" |
|||
}, |
|||
"command": "make CleanDebug", |
|||
"group": { |
|||
"kind": "build", |
|||
"isDefault": true |
|||
}, |
|||
"problemMatcher": { |
|||
"owner": "cpp", |
|||
"fileLocation": ["relative", "${workspaceFolder}"], |
|||
"pattern": { |
|||
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
|||
"file": 1, |
|||
"line": 2, |
|||
"column": 3, |
|||
"severity": 4, |
|||
"message": 5 |
|||
} |
|||
} |
|||
}, |
|||
{ |
|||
"type": "shell", |
|||
"label": "Clean RELEASE", |
|||
"presentation": { |
|||
"reveal": "always", |
|||
"panel": "shared" |
|||
}, |
|||
"command": "make CleanRelease", |
|||
"group": { |
|||
"kind": "build", |
|||
"isDefault": true |
|||
}, |
|||
"problemMatcher": { |
|||
"owner": "cpp", |
|||
"fileLocation": ["relative", "${workspaceFolder}"], |
|||
"pattern": { |
|||
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
|||
"file": 1, |
|||
"line": 2, |
|||
"column": 3, |
|||
"severity": 4, |
|||
"message": 5 |
|||
} |
|||
} |
|||
}, |
|||
{ |
|||
"type": "shell", |
|||
"label": "Clean ALL", |
|||
"presentation": { |
|||
"reveal": "always", |
|||
"panel": "shared" |
|||
}, |
|||
"command": "make clean", |
|||
"group": { |
|||
"kind": "build", |
|||
"isDefault": true |
|||
}, |
|||
"problemMatcher": { |
|||
"owner": "cpp", |
|||
"fileLocation": ["relative", "${workspaceFolder}"], |
|||
"pattern": { |
|||
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
|||
"file": 1, |
|||
"line": 2, |
|||
"column": 3, |
|||
"severity": 4, |
|||
"message": 5 |
|||
} |
|||
} |
|||
} |
|||
] |
|||
} |
|||
@ -0,0 +1,13 @@ |
|||
# Attempt to load a config.make file.
|
|||
# If none is found, project defaults in config.project.make will be used.
|
|||
ifneq ($(wildcard config.make),) |
|||
include config.make |
|||
endif |
|||
|
|||
# make sure the the OF_ROOT location is defined
|
|||
ifndef OF_ROOT |
|||
OF_ROOT=$(realpath ../../..) |
|||
endif |
|||
|
|||
# call the project makefile!
|
|||
include $(OF_ROOT)/libs/openFrameworksCompiled/project/makefileCommon/compile.project.mk |
|||
@ -0,0 +1,4 @@ |
|||
ofxOpenCv |
|||
ofxOpenCv |
|||
ofxBullet |
|||
ofxBullet |
|||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -0,0 +1,142 @@ |
|||
################################################################################ |
|||
# CONFIGURE PROJECT MAKEFILE (optional) |
|||
# This file is where we make project specific configurations. |
|||
################################################################################ |
|||
|
|||
################################################################################ |
|||
# OF ROOT |
|||
# The location of your root openFrameworks installation |
|||
# (default) OF_ROOT = ../../.. |
|||
################################################################################ |
|||
OF_ROOT = ../../.. |
|||
|
|||
################################################################################ |
|||
# PROJECT ROOT |
|||
# The location of the project - a starting place for searching for files |
|||
# (default) PROJECT_ROOT = . (this directory) |
|||
# |
|||
################################################################################ |
|||
# PROJECT_ROOT = . |
|||
|
|||
################################################################################ |
|||
# PROJECT SPECIFIC CHECKS |
|||
# This is a project defined section to create internal makefile flags to |
|||
# conditionally enable or disable the addition of various features within |
|||
# this makefile. For instance, if you want to make changes based on whether |
|||
# GTK is installed, one might test that here and create a variable to check. |
|||
################################################################################ |
|||
# None |
|||
|
|||
################################################################################ |
|||
# PROJECT EXTERNAL SOURCE PATHS |
|||
# These are fully qualified paths that are not within the PROJECT_ROOT folder. |
|||
# Like source folders in the PROJECT_ROOT, these paths are subject to |
|||
# exlclusion via the PROJECT_EXLCUSIONS list. |
|||
# |
|||
# (default) PROJECT_EXTERNAL_SOURCE_PATHS = (blank) |
|||
# |
|||
# Note: Leave a leading space when adding list items with the += operator |
|||
################################################################################ |
|||
# PROJECT_EXTERNAL_SOURCE_PATHS = |
|||
|
|||
################################################################################ |
|||
# PROJECT EXCLUSIONS |
|||
# These makefiles assume that all folders in your current project directory |
|||
# and any listed in the PROJECT_EXTERNAL_SOURCH_PATHS are are valid locations |
|||
# to look for source code. The any folders or files that match any of the |
|||
# items in the PROJECT_EXCLUSIONS list below will be ignored. |
|||
# |
|||
# Each item in the PROJECT_EXCLUSIONS list will be treated as a complete |
|||
# string unless teh user adds a wildcard (%) operator to match subdirectories. |
|||
# GNU make only allows one wildcard for matching. The second wildcard (%) is |
|||
# treated literally. |
|||
# |
|||
# (default) PROJECT_EXCLUSIONS = (blank) |
|||
# |
|||
# Will automatically exclude the following: |
|||
# |
|||
# $(PROJECT_ROOT)/bin% |
|||
# $(PROJECT_ROOT)/obj% |
|||
# $(PROJECT_ROOT)/%.xcodeproj |
|||
# |
|||
# Note: Leave a leading space when adding list items with the += operator |
|||
################################################################################ |
|||
# PROJECT_EXCLUSIONS = |
|||
|
|||
################################################################################ |
|||
# PROJECT LINKER FLAGS |
|||
# These flags will be sent to the linker when compiling the executable. |
|||
# |
|||
# (default) PROJECT_LDFLAGS = -Wl,-rpath=./libs |
|||
# |
|||
# Note: Leave a leading space when adding list items with the += operator |
|||
################################################################################ |
|||
|
|||
# Currently, shared libraries that are needed are copied to the |
|||
# $(PROJECT_ROOT)/bin/libs directory. The following LDFLAGS tell the linker to |
|||
# add a runtime path to search for those shared libraries, since they aren't |
|||
# incorporated directly into the final executable application binary. |
|||
# TODO: should this be a default setting? |
|||
# PROJECT_LDFLAGS=-Wl,-rpath=./libs |
|||
|
|||
################################################################################ |
|||
# PROJECT DEFINES |
|||
# Create a space-delimited list of DEFINES. The list will be converted into |
|||
# CFLAGS with the "-D" flag later in the makefile. |
|||
# |
|||
# (default) PROJECT_DEFINES = (blank) |
|||
# |
|||
# Note: Leave a leading space when adding list items with the += operator |
|||
################################################################################ |
|||
# PROJECT_DEFINES = |
|||
|
|||
################################################################################ |
|||
# PROJECT CFLAGS |
|||
# This is a list of fully qualified CFLAGS required when compiling for this |
|||
# project. These CFLAGS will be used IN ADDITION TO the PLATFORM_CFLAGS |
|||
# defined in your platform specific core configuration files. These flags are |
|||
# presented to the compiler BEFORE the PROJECT_OPTIMIZATION_CFLAGS below. |
|||
# |
|||
# (default) PROJECT_CFLAGS = (blank) |
|||
# |
|||
# Note: Before adding PROJECT_CFLAGS, note that the PLATFORM_CFLAGS defined in |
|||
# your platform specific configuration file will be applied by default and |
|||
# further flags here may not be needed. |
|||
# |
|||
# Note: Leave a leading space when adding list items with the += operator |
|||
################################################################################ |
|||
# PROJECT_CFLAGS = |
|||
|
|||
################################################################################ |
|||
# PROJECT OPTIMIZATION CFLAGS |
|||
# These are lists of CFLAGS that are target-specific. While any flags could |
|||
# be conditionally added, they are usually limited to optimization flags. |
|||
# These flags are added BEFORE the PROJECT_CFLAGS. |
|||
# |
|||
# PROJECT_OPTIMIZATION_CFLAGS_RELEASE flags are only applied to RELEASE targets. |
|||
# |
|||
# (default) PROJECT_OPTIMIZATION_CFLAGS_RELEASE = (blank) |
|||
# |
|||
# PROJECT_OPTIMIZATION_CFLAGS_DEBUG flags are only applied to DEBUG targets. |
|||
# |
|||
# (default) PROJECT_OPTIMIZATION_CFLAGS_DEBUG = (blank) |
|||
# |
|||
# Note: Before adding PROJECT_OPTIMIZATION_CFLAGS, please note that the |
|||
# PLATFORM_OPTIMIZATION_CFLAGS defined in your platform specific configuration |
|||
# file will be applied by default and further optimization flags here may not |
|||
# be needed. |
|||
# |
|||
# Note: Leave a leading space when adding list items with the += operator |
|||
################################################################################ |
|||
# PROJECT_OPTIMIZATION_CFLAGS_RELEASE = |
|||
# PROJECT_OPTIMIZATION_CFLAGS_DEBUG = |
|||
|
|||
################################################################################ |
|||
# PROJECT COMPILERS |
|||
# Custom compilers can be set for CC and CXX |
|||
# (default) PROJECT_CXX = (blank) |
|||
# (default) PROJECT_CC = (blank) |
|||
# Note: Leave a leading space when adding list items with the += operator |
|||
################################################################################ |
|||
# PROJECT_CXX = |
|||
# PROJECT_CC = |
|||
@ -0,0 +1,107 @@ |
|||
{ |
|||
"folders": [ |
|||
{ |
|||
"path": "." |
|||
}, |
|||
{ |
|||
"path": "${workspaceRoot}/../../../../libs/openFrameworks" |
|||
}, |
|||
{ |
|||
"path": "${workspaceRoot}/../../../../addons" |
|||
} |
|||
], |
|||
"settings": { |
|||
"files.associations": { |
|||
"ostream": "cpp", |
|||
"*.ipp": "cpp", |
|||
"functional": "cpp", |
|||
"cctype": "cpp", |
|||
"clocale": "cpp", |
|||
"cmath": "cpp", |
|||
"csignal": "cpp", |
|||
"cstdarg": "cpp", |
|||
"cstddef": "cpp", |
|||
"cstdio": "cpp", |
|||
"cstdlib": "cpp", |
|||
"cstring": "cpp", |
|||
"ctime": "cpp", |
|||
"cwchar": "cpp", |
|||
"cwctype": "cpp", |
|||
"any": "cpp", |
|||
"array": "cpp", |
|||
"atomic": "cpp", |
|||
"strstream": "cpp", |
|||
"bit": "cpp", |
|||
"*.tcc": "cpp", |
|||
"bitset": "cpp", |
|||
"cfenv": "cpp", |
|||
"charconv": "cpp", |
|||
"chrono": "cpp", |
|||
"codecvt": "cpp", |
|||
"compare": "cpp", |
|||
"complex": "cpp", |
|||
"concepts": "cpp", |
|||
"condition_variable": "cpp", |
|||
"cstdint": "cpp", |
|||
"deque": "cpp", |
|||
"forward_list": "cpp", |
|||
"list": "cpp", |
|||
"map": "cpp", |
|||
"set": "cpp", |
|||
"string": "cpp", |
|||
"unordered_map": "cpp", |
|||
"unordered_set": "cpp", |
|||
"vector": "cpp", |
|||
"exception": "cpp", |
|||
"expected": "cpp", |
|||
"algorithm": "cpp", |
|||
"iterator": "cpp", |
|||
"memory": "cpp", |
|||
"memory_resource": "cpp", |
|||
"numeric": "cpp", |
|||
"optional": "cpp", |
|||
"random": "cpp", |
|||
"ratio": "cpp", |
|||
"regex": "cpp", |
|||
"source_location": "cpp", |
|||
"string_view": "cpp", |
|||
"system_error": "cpp", |
|||
"tuple": "cpp", |
|||
"type_traits": "cpp", |
|||
"utility": "cpp", |
|||
"fstream": "cpp", |
|||
"future": "cpp", |
|||
"initializer_list": "cpp", |
|||
"iomanip": "cpp", |
|||
"iosfwd": "cpp", |
|||
"iostream": "cpp", |
|||
"istream": "cpp", |
|||
"limits": "cpp", |
|||
"mutex": "cpp", |
|||
"new": "cpp", |
|||
"numbers": "cpp", |
|||
"ranges": "cpp", |
|||
"semaphore": "cpp", |
|||
"shared_mutex": "cpp", |
|||
"span": "cpp", |
|||
"sstream": "cpp", |
|||
"stdexcept": "cpp", |
|||
"stop_token": "cpp", |
|||
"streambuf": "cpp", |
|||
"thread": "cpp", |
|||
"cinttypes": "cpp", |
|||
"typeindex": "cpp", |
|||
"typeinfo": "cpp", |
|||
"valarray": "cpp", |
|||
"variant": "cpp", |
|||
"format": "cpp", |
|||
"stdfloat": "cpp", |
|||
"__nullptr": "cpp", |
|||
"__hash_table": "cpp", |
|||
"__split_buffer": "cpp", |
|||
"__tree": "cpp", |
|||
"queue": "cpp", |
|||
"stack": "cpp" |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,71 @@ |
|||
import qbs |
|||
import qbs.Process |
|||
import qbs.File |
|||
import qbs.FileInfo |
|||
import qbs.TextFile |
|||
import "../../../libs/openFrameworksCompiled/project/qtcreator/ofApp.qbs" as ofApp |
|||
|
|||
Project{ |
|||
property string of_root: "../../.." |
|||
|
|||
ofApp { |
|||
name: { return FileInfo.baseName(sourceDirectory) } |
|||
|
|||
files: [ |
|||
'src/main.cpp', |
|||
'src/ofApp.cpp', |
|||
'src/ofApp.h', |
|||
] |
|||
|
|||
of.addons: [ |
|||
'ofxBox2d', |
|||
'ofxBox2d', |
|||
'ofxOpenCv', |
|||
'ofxOpenCv', |
|||
] |
|||
|
|||
// additional flags for the project. the of module sets some |
|||
// flags by default to add the core libraries, search paths... |
|||
// this flags can be augmented through the following properties: |
|||
of.pkgConfigs: [] // list of additional system pkgs to include |
|||
of.includePaths: [] // include search paths |
|||
of.cFlags: [] // flags passed to the c compiler |
|||
of.cxxFlags: [] // flags passed to the c++ compiler |
|||
of.linkerFlags: [] // flags passed to the linker |
|||
of.defines: [] // defines are passed as -D to the compiler |
|||
// and can be checked with #ifdef or #if in the code |
|||
of.frameworks: [] // osx only, additional frameworks to link with the project |
|||
of.staticLibraries: [] // static libraries |
|||
of.dynamicLibraries: [] // dynamic libraries |
|||
|
|||
// other flags can be set through the cpp module: http://doc.qt.io/qbs/cpp-module.html |
|||
// eg: this will enable ccache when compiling |
|||
// |
|||
// cpp.compilerWrapper: 'ccache' |
|||
|
|||
Depends{ |
|||
name: "cpp" |
|||
} |
|||
|
|||
// common rules that parse the include search paths, core libraries... |
|||
Depends{ |
|||
name: "of" |
|||
} |
|||
|
|||
// dependency with the OF library |
|||
Depends{ |
|||
name: "openFrameworks" |
|||
} |
|||
} |
|||
|
|||
property bool makeOF: true // use makfiles to compile the OF library |
|||
// will compile OF only once for all your projects |
|||
// otherwise compiled per project with qbs |
|||
|
|||
|
|||
property bool precompileOfMain: false // precompile ofMain.h |
|||
// faster to recompile when including ofMain.h |
|||
// but might use a lot of space per project |
|||
|
|||
references: [FileInfo.joinPaths(of_root, "/libs/openFrameworksCompiled/project/qtcreator/openFrameworks.qbs")] |
|||
} |
|||
@ -0,0 +1,267 @@ |
|||
#include "Bullet.h" |
|||
|
|||
void Bullet::setup(){ |
|||
/* setup camera & world */ |
|||
camera_start_pos = ofVec3f(0, -3.f, -40.f); |
|||
camera_end_position = glm::vec3(ofRandom(-100, 100), ofRandom(-100, 100), ofRandom(0, 0)); |
|||
camera_move_duration = 10.f; |
|||
camera_move_start_time = ofGetElapsedTimef(); |
|||
is_camera_moving = false; |
|||
|
|||
camera.setPosition(camera_start_pos); |
|||
camera.lookAt(ofVec3f(0, 0, 0), ofVec3f(0, -1, 0)); |
|||
camera.enableOrtho(); |
|||
camera.setScale(0.01); |
|||
camera.setNearClip(-10000); |
|||
camera.setFarClip(10000); |
|||
|
|||
world.setup(); |
|||
world.setCamera(&camera); |
|||
world.setGravity( ofVec3f(0, 0, 0) ); |
|||
|
|||
for (int i = 0; i < numThreads; ++i) { |
|||
workerThreads.emplace_back(&Bullet::workerThreadFunction, this, i); |
|||
} |
|||
|
|||
shader.load("vertex_snap"); |
|||
|
|||
std::cout << workerThreads.size() << std::endl; |
|||
} |
|||
|
|||
void Bullet::update(){ |
|||
updateRepulsionNode(); |
|||
cameraBounds = getCameraBounds(camera); |
|||
world.update(); |
|||
if(is_camera_moving){ |
|||
float t = (ofGetElapsedTimef() - camera_move_start_time) / camera_move_duration; |
|||
if (t >= 1.0f){ |
|||
t = 1.0f; |
|||
is_camera_moving = false; |
|||
} |
|||
|
|||
float easedT = easeInOutCubic(t); |
|||
|
|||
glm::vec3 new_position = glm::mix(camera_start_pos, camera_end_position, easedT); |
|||
camera.setPosition(new_position); |
|||
|
|||
float baseZoom = 0.01f; |
|||
float peakZoom = 0.04f; |
|||
float zoomT = 1.0f - abs(2.0f * easedT - 1.0f); // Triangle wave using easedT
|
|||
float easedZoomT = easeInOutCubic(zoomT); // Apply easing to the zoom
|
|||
float currentZoom = glm::mix(baseZoom, peakZoom, easedZoomT); |
|||
camera.setScale(currentZoom); |
|||
} else { |
|||
//setNewCameraEndpoint();
|
|||
} |
|||
} |
|||
|
|||
void Bullet::draw(){ |
|||
std::lock_guard<std::mutex> lock(shapeMutex); |
|||
float shapes_drawn = 0; |
|||
|
|||
gridSize = calculateGridSize(camera.getScale().x); |
|||
|
|||
camera.begin(); |
|||
glEnable( GL_DEPTH_TEST ); |
|||
|
|||
ofSetLineWidth(10.f); |
|||
ofDrawGrid(20, 10, true, false, false, true); |
|||
|
|||
ofNoFill(); |
|||
ofSetColor(ofColor::yellow); |
|||
|
|||
ofNoFill(); |
|||
|
|||
ofSetColor(ofColor::orange); |
|||
for(const auto& n : nodes){ |
|||
if(checkNodeVisibility(n)){ |
|||
ofPushMatrix(); |
|||
n.collider->transformGL(); |
|||
ofScale(n.scale * 1.4); |
|||
n.col_mesh.draw(); |
|||
n.collider->restoreTransformGL(); |
|||
ofPopMatrix(); |
|||
} |
|||
|
|||
} |
|||
|
|||
|
|||
ofSetColor(ofColor::white); |
|||
ofFill(); |
|||
|
|||
for(const auto& n : nodes){ |
|||
|
|||
if(checkNodeVisibility(n)){ |
|||
ofPushMatrix(); |
|||
shader.begin(); |
|||
shader.setUniform1f("gridSize", gridSize); |
|||
shader.setUniformTexture("tex0", n.tex, 0); |
|||
n.collider->transformGL(); |
|||
ofScale(n.scale); |
|||
n.mesh.draw(); |
|||
n.collider->restoreTransformGL(); |
|||
shader.end(); |
|||
ofPopMatrix(); |
|||
shapes_drawn++; |
|||
} |
|||
} |
|||
|
|||
camera.end(); |
|||
glDisable(GL_DEPTH_TEST); |
|||
|
|||
|
|||
|
|||
int totalShapes = nodes.size(); |
|||
ofVec3f gravity = world.getGravity(); |
|||
stringstream ss; |
|||
ss << "Total Shapes: " << totalShapes << endl; |
|||
ss << "FPS: " << ofGetFrameRate() << endl; |
|||
ss << "Shapes Drawn: " << shapes_drawn << endl; |
|||
ss << "Camera Position: " << camera.getPosition() << std::endl; |
|||
ss << "Camera Scale: " << camera.getScale() << std::endl; |
|||
ss << "Camera Bounds: " << cameraBounds.z << std::endl; |
|||
ofSetColor(255, 255, 255); |
|||
ofDrawBitmapString(ss.str().c_str(), 20, 20); |
|||
now = false; |
|||
} |
|||
|
|||
void Bullet::addMesh(ofMesh _mesh, ofMesh _simple_mesh, ofTexture _tex){ |
|||
std::lock_guard<std::mutex> lock(shapeMutex); |
|||
Node n; |
|||
n.tex = _tex; |
|||
float rand = ofRandom(0.01, 0.02); |
|||
glm::vec3 random_szie(rand, rand, rand); |
|||
n.scale = random_szie; |
|||
ofQuaternion startRot = ofQuaternion(0., 0., 0., PI); |
|||
ofVec3f target_location = ofVec3f( ofRandom(0, 0), ofRandom(0, 0), -5 ); |
|||
ofVec3f start_location = ofVec3f( ofRandom(-300, 300), ofRandom(-300, 300), -5 ); |
|||
|
|||
ofxBulletCustomShape* s = new ofxBulletCustomShape(); |
|||
s->addMesh(_simple_mesh, n.scale * 1.4, true); |
|||
s->create( world.world, start_location, startRot, 3.); |
|||
s->add(); |
|||
s->getRigidBody()->setAngularFactor(btVector3(0, 0, 1)); |
|||
s->getRigidBody()->setDamping(btScalar(0.001), btScalar(0.05)); |
|||
s->getRigidBody()->setLinearFactor(btVector3(1, 1, 0)); |
|||
s->getRigidBody()->setActivationState(DISABLE_DEACTIVATION); |
|||
s->getRigidBody()->setRestitution(btScalar(0.5)); |
|||
s->getRigidBody()->setFriction(btScalar(1.0)); |
|||
|
|||
positions.push_back(target_location); |
|||
|
|||
// Set how the col mesh is drawn!
|
|||
_simple_mesh.setMode(OF_PRIMITIVE_LINES); |
|||
|
|||
n.collider = s; |
|||
n.mesh = _mesh; |
|||
n.col_mesh = _simple_mesh; |
|||
nodes.push_back(n); |
|||
} |
|||
|
|||
void Bullet::workerThreadFunction(int threadId) { |
|||
while (!shouldTerminate) { |
|||
size_t batchSize = shapes.size() / numThreads; |
|||
size_t start = threadId * batchSize; |
|||
size_t end = (threadId == numThreads - 1) ? nodes.size() : start + batchSize; |
|||
|
|||
updateShapeBatch(start, end); |
|||
|
|||
// Add a small sleep to prevent busy-waiting
|
|||
std::this_thread::sleep_for(std::chrono::milliseconds(1)); |
|||
} |
|||
} |
|||
|
|||
void Bullet::updateShapeBatch(size_t start, size_t end) { |
|||
// for (size_t i = start; i < end; ++i) {
|
|||
// std::lock_guard<std::mutex> lock(shapeMutex);
|
|||
// glm::vec3 pos = nodes[i].collider->getPosition();
|
|||
// glm::vec3 direction = glm::vec3(0, 0, -5) - pos;
|
|||
// float dist_sq = glm::length(direction);
|
|||
// glm::vec3 norm_dir = glm::normalize(direction);
|
|||
// nodes[i].collider->applyCentralForce(1.0 * norm_dir);
|
|||
|
|||
// if(now){
|
|||
// std::lock_guard<std::mutex> lock(shapeMutex);
|
|||
// nodes[i].collider->applyCentralForce(glm::vec3(ofRandom(-1, 1), ofRandom(-1, 1), ofRandom(-1, 1)));
|
|||
// }
|
|||
|
|||
// if (dist_sq > FORCE_RADIUS_SQ){
|
|||
// glm::vec3 norm_dir = glm::normalize(direction);
|
|||
// std::lock_guard<std::mutex> lock(shapeMutex);
|
|||
// nodes[i].collider->applyCentralForce(0.001 * direction);
|
|||
// }
|
|||
|
|||
|
|||
// btVector3 vel = nodes[i].collider->getRigidBody()->getLinearVelocity();
|
|||
// float vel_mag = vel.length();
|
|||
|
|||
// if (vel_mag > 1.0f) { // Cap at magnitude 1
|
|||
// vel.normalize(); // Normalize the velocity
|
|||
// vel *= 1.0f; // Scale to cap
|
|||
// nodes[i].collider->getRigidBody()->setLinearVelocity(vel); // Set the capped velocity
|
|||
// }
|
|||
|
|||
//}
|
|||
for (size_t i = start; i < end; ++i) { |
|||
std::lock_guard<std::mutex> lock(shapeMutex); |
|||
|
|||
glm::vec3 pos = nodes[i].collider->getPosition(); |
|||
glm::vec3 direction = glm::vec3(0, 0, -5) - pos; |
|||
float dist_sq = glm::length(direction); |
|||
glm::vec3 norm_dir = glm::normalize(direction); |
|||
nodes[i].collider->applyCentralForce(1.0f * norm_dir); |
|||
|
|||
// Apply repulsion force if needed
|
|||
if (shouldApplyRepulsion && i != repulsionNodeIndex) { |
|||
const Node& repulsionNode = nodes[repulsionNodeIndex]; |
|||
glm::vec3 repulsionDir = pos - repulsionNode.collider->getPosition(); |
|||
float repulsionDist = glm::length(repulsionDir); |
|||
|
|||
if (repulsionDist < repulsionRadius && repulsionDist > 0) { |
|||
repulsionDir = glm::normalize(repulsionDir); |
|||
float forceMagnitude = repulsionStrength * (1.0f - repulsionDist / repulsionRadius); |
|||
glm::vec3 repulsionForce = repulsionDir * forceMagnitude; |
|||
nodes[i].collider->applyCentralForce(repulsionForce * 100.0f); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
float Bullet::easeInOutCubic(float t) { |
|||
return t < 0.5 ? 4 * t * t * t : 1 - pow(-2 * t + 2, 3) / 2; |
|||
} |
|||
|
|||
float Bullet::calculateGridSize(float zoom){ |
|||
const float ref_zoom = 0.01; |
|||
const float ref_scale = 20; |
|||
float new_grid_size = (ref_zoom * ref_scale) / zoom; |
|||
if(new_grid_size < 5){ |
|||
new_grid_size = 5; |
|||
} |
|||
return new_grid_size; |
|||
} |
|||
|
|||
void Bullet::setNewCameraEndpoint(){ |
|||
camera_move_start_time = ofGetElapsedTimef(); |
|||
is_camera_moving = true; |
|||
camera_start_pos = camera.getPosition(); |
|||
camera_end_position = glm::vec3(ofRandom(-75, 75), ofRandom(-75, 75), 0.0); |
|||
} |
|||
|
|||
glm::vec4 Bullet::getCameraBounds(const ofCamera& cam){ |
|||
|
|||
glm::vec3 cam_pos = cam.getPosition(); |
|||
float cam_scale = cam.getScale().x; |
|||
float bounds = ofMap(cam_scale, 0.01, 0.2, 10, 120) + 20; |
|||
return glm::vec4(cam_pos.x + bounds, cam_pos.x - bounds, cam_pos.y + bounds, cam_pos.y - bounds); |
|||
|
|||
} |
|||
|
|||
bool Bullet::checkNodeVisibility(const Node& n){ |
|||
glm::vec3 n_pos = n.collider->getPosition(); |
|||
if(n_pos.x < cameraBounds.x && n_pos.x > cameraBounds.y && n_pos.y < cameraBounds.z && n_pos.y > cameraBounds.w ){ |
|||
return true; |
|||
} else { |
|||
return false; |
|||
} |
|||
} |
|||
@ -0,0 +1,128 @@ |
|||
#pragma once |
|||
#include "ofMain.h" |
|||
#include "ofxBullet.h" |
|||
#include <thread> |
|||
#include <mutex> |
|||
#include <atomic> |
|||
#include <vector> |
|||
|
|||
struct Node { |
|||
ofxBulletCustomShape* collider; |
|||
ofMesh col_mesh; |
|||
ofMesh mesh; |
|||
ofImage img; |
|||
ofTexture tex; |
|||
glm::vec3 scale; |
|||
}; |
|||
|
|||
class Bullet{ |
|||
public: |
|||
void setup(); |
|||
void update(); |
|||
void draw(); |
|||
void addMesh(ofMesh _mesh, ofMesh _simple_mesh, ofTexture _tex); |
|||
float easeInOutCubic(float t); |
|||
float calculateGridSize(float zoom); |
|||
void setNewCameraEndpoint(); |
|||
glm::vec4 getCameraBounds(const ofCamera& cam); |
|||
bool checkNodeVisibility(const Node& n); |
|||
ofxBulletWorldRigid world; |
|||
vector <ofxBulletBox*> bounds; |
|||
ofxBulletCustomShape* boundsShape; |
|||
ofMaterial boundsMat; |
|||
ofMaterial shapeMat; |
|||
float boundsWidth; |
|||
vector<ofxBulletCustomShape*> shapes; |
|||
vector<ofxBulletCustomShape*> simplifiedShapes; |
|||
vector<glm::vec3> positions; |
|||
ofMaterial logoMat; |
|||
vector<Node> nodes; |
|||
|
|||
bool bDrawDebug; |
|||
|
|||
|
|||
ofMesh mesh; |
|||
ofMesh simple_mesh; |
|||
|
|||
ofEasyCam camera; |
|||
glm::vec3 camera_start_pos; |
|||
glm::vec3 camera_end_position; |
|||
bool is_camera_moving; |
|||
float camera_move_duration; |
|||
float camera_move_start_time; |
|||
|
|||
ofLight light; |
|||
ofTexture tex; |
|||
|
|||
ofShader shader; |
|||
float gridSize = 20.0f; |
|||
|
|||
glm::vec4 cameraBounds; |
|||
|
|||
void updateRepulsionNode() { |
|||
static int frameCount = 0; |
|||
static const int repulsionInterval = 60; // Apply repulsion every 60 frames
|
|||
|
|||
if (frameCount % repulsionInterval == 0 && !nodes.empty()) { |
|||
repulsionNodeIndex = ofRandom(nodes.size()); |
|||
shouldApplyRepulsion = true; |
|||
} else if (frameCount % repulsionInterval == repulsionInterval - 1) { |
|||
shouldApplyRepulsion = false; |
|||
} |
|||
frameCount++; |
|||
} |
|||
|
|||
ofRectangle calculateMeshBounds(const ofMesh& mesh) { |
|||
if (mesh.getVertices().empty()) { |
|||
return ofRectangle(); |
|||
} |
|||
|
|||
ofVec3f min = mesh.getVertices()[0]; |
|||
ofVec3f max = min; |
|||
|
|||
for (const auto& vertex : mesh.getVertices()) { |
|||
min.x = std::min(min.x, vertex.x); |
|||
min.y = std::min(min.y, vertex.y); |
|||
min.z = std::min(min.z, vertex.z); |
|||
|
|||
max.x = std::max(max.x, vertex.x); |
|||
max.y = std::max(max.y, vertex.y); |
|||
max.z = std::max(max.z, vertex.z); |
|||
} |
|||
|
|||
return ofRectangle(min.x, min.y, max.x - min.x, max.y - min.y); |
|||
} |
|||
|
|||
|
|||
void cleanup() { |
|||
shouldTerminate = true; |
|||
for (auto& thread : workerThreads) { |
|||
if (thread.joinable()) { |
|||
thread.join(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
~Bullet() { |
|||
cleanup(); |
|||
} |
|||
|
|||
private: |
|||
std::vector<std::thread> workerThreads; |
|||
std::mutex shapeMutex; |
|||
std::atomic<bool> shouldTerminate{false}; |
|||
|
|||
std::atomic<size_t> repulsionNodeIndex{0}; |
|||
std::atomic<bool> shouldApplyRepulsion{false}; |
|||
const float repulsionRadius = 10.0f; |
|||
const float repulsionStrength = 1.0f; |
|||
|
|||
const int numThreads = std::thread::hardware_concurrency(); |
|||
const float FORCE_RADIUS = 200.0f; // Radius beyond which force is applied
|
|||
const float FORCE_RADIUS_SQ = FORCE_RADIUS * FORCE_RADIUS; // Squared radius for faster comparisons
|
|||
const float INNER_RADIUS = 10.0f; // Inner radius where objects are considered "arrived"
|
|||
const float INNER_RADIUS_SQ = INNER_RADIUS * INNER_RADIUS; |
|||
void workerThreadFunction(int threadId); |
|||
void updateShapeBatch(size_t start, size_t end); |
|||
bool now = true; |
|||
}; |
|||
@ -0,0 +1,151 @@ |
|||
#include "MeshGenerator.h" |
|||
|
|||
vector<ofMesh> MeshGenerator::generateSimplifiedMesh(ofImage& image) { |
|||
ofMesh mesh; |
|||
ofMesh simple_mesh; |
|||
|
|||
// Convert ofImage to cv::Mat
|
|||
cv::Mat imageMat(image.getHeight(), image.getWidth(), CV_8UC4, image.getPixels().getData()); |
|||
|
|||
// Split the channels
|
|||
std::vector<cv::Mat> channels; |
|||
cv::split(imageMat, channels); |
|||
|
|||
// Use the alpha channel for processing
|
|||
cv::Mat alphaMat = channels[3]; |
|||
|
|||
// Threshold the alpha channel
|
|||
cv::Mat binaryMat; |
|||
cv::threshold(alphaMat, binaryMat, 1, 255, cv::THRESH_BINARY); |
|||
|
|||
ofImage debugImage; |
|||
debugImage.setFromPixels(binaryMat.data, image.getWidth(), image.getHeight(), OF_IMAGE_GRAYSCALE); |
|||
debugImage.save("debug_binaryMat.png"); |
|||
|
|||
|
|||
// Find contours
|
|||
std::vector<std::vector<cv::Point>> contours; |
|||
cv::findContours(binaryMat, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE); |
|||
|
|||
// Clear existing mesh
|
|||
mesh.clear(); |
|||
simple_mesh.clear(); |
|||
|
|||
// Filter and process contours
|
|||
double minContourArea = 100.0; // Adjust this value as needed
|
|||
std::vector<std::vector<cv::Point>> filteredContours; |
|||
|
|||
for (const auto& contour : contours) { |
|||
double area = cv::contourArea(contour); |
|||
if (area > minContourArea) { |
|||
filteredContours.push_back(contour); |
|||
} |
|||
} |
|||
|
|||
// Sort contours by area (largest first)
|
|||
std::sort(filteredContours.begin(), filteredContours.end(), |
|||
[](const std::vector<cv::Point>& c1, const std::vector<cv::Point>& c2) { |
|||
return cv::contourArea(c1) > cv::contourArea(c2); |
|||
}); |
|||
|
|||
// Process only the largest contour (or a few largest if needed)
|
|||
size_t numContoursToProcess = std::min(size_t(1), filteredContours.size()); |
|||
|
|||
// Vector to hold the vertices
|
|||
std::vector<ofVec3f> vertices; |
|||
|
|||
for (size_t i = 0; i < numContoursToProcess; ++i) { |
|||
const auto& contour = filteredContours[i]; |
|||
std::vector<cv::Point> approxCurve; |
|||
|
|||
// Simplify the contour 0.005 (0.05) -> v simple mesh
|
|||
double epsilon = 0.005 * cv::arcLength(contour, true); |
|||
cv::approxPolyDP(contour, approxCurve, epsilon, true); |
|||
|
|||
// Add vertices and calculate the texture coordinates based on contour points
|
|||
if (approxCurve.size() > 1) { |
|||
for (const auto& point : approxCurve) { |
|||
float x = point.x; |
|||
float y = point.y; |
|||
vertices.emplace_back(x, y, 0); |
|||
|
|||
// Map the texture coordinates to the non-transparent parts directly
|
|||
float texCoordX = ofMap(x, 0, image.getWidth() - 1, 0, 1); // use image width
|
|||
float texCoordY = ofMap(y, 0, image.getHeight() - 1, 0, 1); // use image height
|
|||
mesh.addTexCoord(ofVec2f(texCoordX, texCoordY)); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
// Calculate the centroid
|
|||
ofVec3f centroid(0, 0, 0); |
|||
for (const auto& vertex : vertices) { |
|||
centroid += vertex; |
|||
} |
|||
centroid /= vertices.size(); |
|||
|
|||
// Add vertices to the mesh, adjusting for centroid
|
|||
for (const auto& vertex : vertices) { |
|||
mesh.addVertex(vertex - centroid); // Translate each vertex to center it
|
|||
} |
|||
|
|||
// Create indices for drawing
|
|||
for (size_t i = 0; i < vertices.size(); ++i) { |
|||
mesh.addIndex(i); |
|||
mesh.addIndex((i + 1) % vertices.size()); |
|||
} |
|||
|
|||
/* simplified mesh */ |
|||
|
|||
vertices.clear(); |
|||
|
|||
for (size_t i = 0; i < numContoursToProcess; ++i) { |
|||
const auto& contour = filteredContours[i]; |
|||
std::vector<cv::Point> approxCurve; |
|||
|
|||
// Simplify the contour 0.005 (0.05) -> v simple mesh
|
|||
double epsilon = 0.025 * cv::arcLength(contour, true); |
|||
cv::approxPolyDP(contour, approxCurve, epsilon, true); |
|||
|
|||
// Add vertices and calculate the texture coordinates based on contour points
|
|||
if (approxCurve.size() > 1) { |
|||
for (const auto& point : approxCurve) { |
|||
float x = point.x; |
|||
float y = point.y; |
|||
vertices.emplace_back(x, y, 0); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
// Calculate the centroid
|
|||
centroid = glm::vec3(0, 0, 0); |
|||
for (const auto& vertex : vertices) { |
|||
centroid += vertex; |
|||
} |
|||
centroid /= vertices.size(); |
|||
|
|||
// Add vertices to the mesh, adjusting for centroid
|
|||
for (const auto& vertex : vertices) { |
|||
simple_mesh.addVertex(vertex - centroid); // Translate each vertex to center it
|
|||
} |
|||
|
|||
// Create indices for drawing
|
|||
for (size_t i = 0; i < vertices.size(); ++i) { |
|||
simple_mesh.addIndex(i); |
|||
simple_mesh.addIndex((i + 1) % vertices.size()); |
|||
} |
|||
|
|||
// Set the primitive mode to triangles to allow proper texture mapping
|
|||
mesh.setMode(OF_PRIMITIVE_TRIANGLE_FAN); |
|||
simple_mesh.setMode(OF_PRIMITIVE_TRIANGLES); |
|||
|
|||
vector<ofMesh> mesh_list; |
|||
mesh_list.emplace_back(mesh); |
|||
mesh_list.emplace_back(simple_mesh); |
|||
return mesh_list; |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,11 @@ |
|||
#pragma once |
|||
|
|||
#include "ofMain.h" |
|||
#include "ofxOpenCv.h" |
|||
|
|||
class MeshGenerator{ |
|||
|
|||
public: |
|||
vector<ofMesh> generateSimplifiedMesh(ofImage& img); |
|||
|
|||
}; |
|||
@ -0,0 +1,31 @@ |
|||
#include "VP.h" |
|||
|
|||
// Function to generate random vectors
|
|||
std::vector<std::vector<double>> VP::generateRandomVectors(int count, int dimension) { |
|||
std::vector<std::vector<double>> vectors; |
|||
std::random_device rd; |
|||
std::mt19937 gen(rd()); |
|||
std::uniform_real_distribution<> dis(0.0, 1.0); |
|||
|
|||
for (int i = 0; i < count; ++i) { |
|||
std::vector<double> vec; |
|||
for (int j = 0; j < dimension; ++j) { |
|||
vec.push_back(dis(gen)); |
|||
} |
|||
vectors.push_back(vec); |
|||
} |
|||
return vectors; |
|||
} |
|||
|
|||
vpt::VpTree VP::loadTree(std::string path){ |
|||
return vpt::VpTree::load(path); |
|||
} |
|||
|
|||
void VP::saveTree(std::string filename, vpt::VpTree& tree){ |
|||
tree.save(filename); |
|||
} |
|||
|
|||
vpt::VpTree VP::buildTree(std::vector<vpt::Vector> vectors){ |
|||
vpt::VpTree tree(vectors); |
|||
return tree; |
|||
} |
|||
@ -0,0 +1,14 @@ |
|||
#pragma once |
|||
#include <iostream> |
|||
#include <vector> |
|||
#include <random> |
|||
#include <chrono> |
|||
#include "VpTree.hpp" |
|||
|
|||
class VP{ |
|||
public: |
|||
std::vector<std::vector<double>> generateRandomVectors(int count, int dimension); |
|||
vpt::VpTree loadTree(std::string path); |
|||
void saveTree(std::string filename, vpt::VpTree& tree); |
|||
vpt::VpTree buildTree(std::vector<vpt::Vector> vectors); |
|||
}; |
|||
@ -0,0 +1,346 @@ |
|||
#pragma once |
|||
|
|||
#include <algorithm> |
|||
#include <vector> |
|||
#include <queue> |
|||
#include <limits> |
|||
#include <random> |
|||
#include <cmath> |
|||
#include <stdexcept> |
|||
#include <functional> |
|||
#include <optional> |
|||
#include <fstream> |
|||
#include <iostream> |
|||
#include <numeric> |
|||
#include "ofFileUtils.h" |
|||
|
|||
namespace vpt { |
|||
|
|||
using Vector = std::vector<double>; |
|||
using Metric = std::function<double(const Vector&, const Vector&)>; |
|||
using DistancesIndices = std::pair<std::vector<double>, std::vector<int>>; |
|||
using BatchDistancesIndices = std::pair<std::vector<std::vector<double>>, std::vector<std::vector<int>>>; |
|||
|
|||
template<class InputIterator> |
|||
inline double sum(InputIterator begin, InputIterator end) { |
|||
return std::accumulate(begin, end, 0.0); |
|||
} |
|||
|
|||
struct EuclideanMetric { |
|||
inline double operator()(const Vector& v1, const Vector& v2) const { |
|||
Vector diffSquares(v1.size()); |
|||
std::transform(v1.begin(), v1.end(), v2.begin(), diffSquares.begin(), |
|||
[](double lhs, double rhs) { return (lhs - rhs) * (lhs - rhs); }); |
|||
return std::sqrt(sum(diffSquares.begin(), diffSquares.end())); |
|||
} |
|||
}; |
|||
|
|||
class DimensionMismatch : public std::runtime_error { |
|||
public: |
|||
inline DimensionMismatch(int expected, int got) |
|||
: std::runtime_error("Item dimension doesn't match: expected " + std::to_string(expected) + |
|||
", got " + std::to_string(got)) {} |
|||
}; |
|||
|
|||
class VpTree { |
|||
public: |
|||
template<typename InputIterator> |
|||
inline explicit VpTree(InputIterator start, InputIterator end, Metric metric = EuclideanMetric()); |
|||
|
|||
template<typename Container> |
|||
inline explicit VpTree(const Container& container, Metric metric = EuclideanMetric()); |
|||
|
|||
inline explicit VpTree(std::initializer_list<Vector> list, Metric metric = EuclideanMetric()); |
|||
|
|||
inline DistancesIndices getNearestNeighbors(const Vector& target, int neighborsCount) const; |
|||
|
|||
template<typename VectorLike> |
|||
inline DistancesIndices getNearestNeighbors(const VectorLike& target, int neighborsCount) const; |
|||
|
|||
inline DistancesIndices getNearestNeighbors(std::initializer_list<double> target, int neighborsCount) const; |
|||
|
|||
template<typename Container> |
|||
inline BatchDistancesIndices getNearestNeighborsBatch(const Container& targets, int neighborsCount) const; |
|||
|
|||
inline BatchDistancesIndices getNearestNeighborsBatch(std::initializer_list<Vector> targets, int neighborsCount) const; |
|||
|
|||
// Save the VpTree to a file
|
|||
inline void save(const std::string& filename) const { |
|||
std::ofstream out(filename, std::ios::binary); |
|||
if (!out) { |
|||
throw std::runtime_error("Cannot open file for writing: " + filename); |
|||
} |
|||
|
|||
// Save dimension
|
|||
out.write(reinterpret_cast<const char*>(&dimension_), sizeof(dimension_)); |
|||
|
|||
// Save items
|
|||
size_t itemsSize = items_.size(); |
|||
out.write(reinterpret_cast<const char*>(&itemsSize), sizeof(itemsSize)); |
|||
for (const auto& item : items_) { |
|||
size_t vecSize = item.first.size(); |
|||
out.write(reinterpret_cast<const char*>(&vecSize), sizeof(vecSize)); |
|||
out.write(reinterpret_cast<const char*>(item.first.data()), vecSize * sizeof(double)); |
|||
out.write(reinterpret_cast<const char*>(&item.second), sizeof(item.second)); |
|||
} |
|||
|
|||
// Save nodes
|
|||
size_t nodesSize = nodes_.size(); |
|||
out.write(reinterpret_cast<const char*>(&nodesSize), sizeof(nodesSize)); |
|||
out.write(reinterpret_cast<const char*>(nodes_.data()), nodesSize * sizeof(Node)); |
|||
|
|||
if (!out) { |
|||
throw std::runtime_error("Error writing to file: " + filename); |
|||
} |
|||
} |
|||
|
|||
// Load the VpTree from a file
|
|||
inline static VpTree load(const std::string& filename, Metric metric = EuclideanMetric()) { |
|||
std::ifstream in(filename, std::ios::binary); |
|||
if (!in) { |
|||
throw std::runtime_error("Cannot open file for reading: " + filename); |
|||
} |
|||
|
|||
VpTree tree; |
|||
tree.distance_ = std::move(metric); |
|||
|
|||
// Load dimension
|
|||
in.read(reinterpret_cast<char*>(&tree.dimension_), sizeof(tree.dimension_)); |
|||
|
|||
// Load items
|
|||
size_t itemsSize; |
|||
in.read(reinterpret_cast<char*>(&itemsSize), sizeof(itemsSize)); |
|||
tree.items_.resize(itemsSize); |
|||
for (auto& item : tree.items_) { |
|||
size_t vecSize; |
|||
in.read(reinterpret_cast<char*>(&vecSize), sizeof(vecSize)); |
|||
item.first.resize(vecSize); |
|||
in.read(reinterpret_cast<char*>(item.first.data()), vecSize * sizeof(double)); |
|||
in.read(reinterpret_cast<char*>(&item.second), sizeof(item.second)); |
|||
} |
|||
|
|||
// Load nodes
|
|||
size_t nodesSize; |
|||
in.read(reinterpret_cast<char*>(&nodesSize), sizeof(nodesSize)); |
|||
tree.nodes_.resize(nodesSize); |
|||
in.read(reinterpret_cast<char*>(tree.nodes_.data()), nodesSize * sizeof(Node)); |
|||
|
|||
if (!in) { |
|||
throw std::runtime_error("Error reading from file: " + filename); |
|||
} else { |
|||
std::cout << "Tree loaded from disk." << std::endl; |
|||
} |
|||
|
|||
return tree; |
|||
} |
|||
|
|||
private: |
|||
struct Node { |
|||
static constexpr int Leaf = -1; |
|||
int item; |
|||
double threshold; |
|||
int left; |
|||
int right; |
|||
|
|||
// Default constructor
|
|||
Node() : item(Leaf), threshold(0.0), left(Leaf), right(Leaf) {} |
|||
|
|||
Node(int item, double threshold = 0., int left = Leaf, int right = Leaf) |
|||
: item(item), threshold(threshold), left(left), right(right) {} |
|||
}; |
|||
|
|||
using Item = std::pair<Vector, int>; |
|||
|
|||
std::vector<Item> items_; |
|||
std::vector<Node> nodes_; |
|||
std::mt19937 rng_; |
|||
int dimension_; |
|||
Metric distance_; |
|||
|
|||
template<typename InputIterator> |
|||
inline std::vector<Item> makeItems(InputIterator start, InputIterator end); |
|||
|
|||
inline std::optional<int> makeTree(int lower, int upper); |
|||
inline void selectRoot(int lower, int upper); |
|||
inline void partitionByDistance(int lower, int pos, int upper); |
|||
inline int makeNode(int item); |
|||
inline Node root() const { return nodes_[0]; } |
|||
|
|||
// Default constructor for use in load function
|
|||
inline VpTree() : rng_(std::random_device()()) {} |
|||
|
|||
class Searcher { |
|||
public: |
|||
inline explicit Searcher(const VpTree* tree, const Vector& target, int neighborsCount); |
|||
inline DistancesIndices search(); |
|||
|
|||
private: |
|||
struct HeapItem { |
|||
inline bool operator<(const HeapItem& other) const { return dist < other.dist; } |
|||
int item; |
|||
double dist; |
|||
}; |
|||
|
|||
inline void searchInNode(const Node& node); |
|||
|
|||
const VpTree* tree_; |
|||
Vector target_; |
|||
int neighborsCount_; |
|||
double tau_; |
|||
std::priority_queue<HeapItem> heap_; |
|||
}; |
|||
|
|||
friend class Searcher; |
|||
}; |
|||
|
|||
template<typename InputIterator> |
|||
inline VpTree::VpTree(InputIterator start, InputIterator end, Metric metric) |
|||
: items_(makeItems(start, end)), nodes_(), rng_(std::random_device()()), distance_(std::move(metric)) { |
|||
nodes_.reserve(items_.size()); |
|||
makeTree(0, items_.size()); |
|||
} |
|||
|
|||
template<typename Container> |
|||
inline VpTree::VpTree(const Container& container, Metric metric) |
|||
: VpTree(container.begin(), container.end(), std::move(metric)) {} |
|||
|
|||
inline VpTree::VpTree(std::initializer_list<Vector> list, Metric metric) |
|||
: VpTree(list.begin(), list.end(), std::move(metric)) {} |
|||
|
|||
inline std::optional<int> VpTree::makeTree(int lower, int upper) { |
|||
if (lower >= upper) { |
|||
return std::nullopt; |
|||
} else if (lower + 1 == upper) { |
|||
return makeNode(lower); |
|||
} else { |
|||
selectRoot(lower, upper); |
|||
int median = (upper + lower) / 2; |
|||
partitionByDistance(lower, median, upper); |
|||
auto node = makeNode(lower); |
|||
nodes_[node].threshold = distance_(items_[lower].first, items_[median].first); |
|||
nodes_[node].left = makeTree(lower + 1, median).value_or(Node::Leaf); |
|||
nodes_[node].right = makeTree(median, upper).value_or(Node::Leaf); |
|||
return node; |
|||
} |
|||
} |
|||
|
|||
inline void VpTree::selectRoot(int lower, int upper) { |
|||
std::uniform_int_distribution<int> uni(lower, upper - 1); |
|||
int root = uni(rng_); |
|||
std::swap(items_[lower], items_[root]); |
|||
} |
|||
|
|||
inline void VpTree::partitionByDistance(int lower, int pos, int upper) { |
|||
std::nth_element( |
|||
items_.begin() + lower + 1, items_.begin() + pos, items_.begin() + upper, |
|||
[this, &lower](const Item& i1, const Item& i2) { |
|||
return distance_(items_[lower].first, i1.first) < distance_(items_[lower].first, i2.first); |
|||
}); |
|||
} |
|||
|
|||
inline int VpTree::makeNode(int item) { |
|||
nodes_.emplace_back(item); |
|||
return static_cast<int>(nodes_.size() - 1); |
|||
} |
|||
|
|||
template<typename InputIterator> |
|||
inline std::vector<VpTree::Item> VpTree::makeItems(InputIterator begin, InputIterator end) { |
|||
if (begin != end) { |
|||
dimension_ = begin->size(); |
|||
} else { |
|||
dimension_ = -1; |
|||
} |
|||
|
|||
std::vector<Item> res; |
|||
for (int i = 0; begin != end; ++begin, ++i) { |
|||
res.emplace_back(Vector(begin->begin(), begin->end()), i); |
|||
auto lastDimension = res.back().first.size(); |
|||
if (lastDimension != dimension_) { |
|||
throw DimensionMismatch(dimension_, lastDimension); |
|||
} |
|||
} |
|||
return res; |
|||
} |
|||
|
|||
template<typename VectorLike> |
|||
inline DistancesIndices VpTree::getNearestNeighbors(const VectorLike& target, int neighborsCount) const { |
|||
return getNearestNeighbors(Vector(target.begin(), target.end()), neighborsCount); |
|||
} |
|||
|
|||
inline DistancesIndices VpTree::getNearestNeighbors(std::initializer_list<double> target, int neighborsCount) const { |
|||
return getNearestNeighbors(Vector(target.begin(), target.end()), neighborsCount); |
|||
} |
|||
|
|||
inline DistancesIndices VpTree::getNearestNeighbors(const Vector& target, int neighborsCount) const { |
|||
auto targetDimension = target.size(); |
|||
if (targetDimension != dimension_) { |
|||
throw DimensionMismatch(dimension_, targetDimension); |
|||
} |
|||
Searcher searcher(this, target, neighborsCount); |
|||
return searcher.search(); |
|||
} |
|||
|
|||
template<typename Container> |
|||
inline BatchDistancesIndices VpTree::getNearestNeighborsBatch(const Container& targets, int neighborsCount) const { |
|||
std::vector<std::vector<double>> batchDistances(targets.size()); |
|||
std::vector<std::vector<int>> batchIndices(targets.size()); |
|||
#pragma omp parallel for schedule(dynamic) |
|||
for (size_t i = 0; i < targets.size(); ++i) { |
|||
std::tie(batchDistances[i], batchIndices[i]) = getNearestNeighbors(targets[i], neighborsCount); |
|||
} |
|||
return {batchDistances, batchIndices}; |
|||
} |
|||
|
|||
inline BatchDistancesIndices VpTree::getNearestNeighborsBatch(std::initializer_list<Vector> targets, int neighborsCount) const { |
|||
return getNearestNeighborsBatch(std::vector<Vector>(targets.begin(), targets.end()), neighborsCount); |
|||
} |
|||
|
|||
inline VpTree::Searcher::Searcher(const VpTree* tree, const Vector& target, int neighborsCount) |
|||
: tree_(tree), target_(target), neighborsCount_(neighborsCount), |
|||
tau_(std::numeric_limits<double>::max()), heap_() {} |
|||
|
|||
inline DistancesIndices VpTree::Searcher::search() { |
|||
searchInNode(tree_->root()); |
|||
|
|||
DistancesIndices results; |
|||
results.first.reserve(heap_.size()); |
|||
results.second.reserve(heap_.size()); |
|||
while (!heap_.empty()) { |
|||
results.first.push_back(heap_.top().dist); |
|||
results.second.push_back(tree_->items_[heap_.top().item].second); |
|||
heap_.pop(); |
|||
} |
|||
std::reverse(results.first.begin(), results.first.end()); |
|||
std::reverse(results.second.begin(), results.second.end()); |
|||
return results; |
|||
} |
|||
|
|||
inline void VpTree::Searcher::searchInNode(const Node& node) { |
|||
double dist = tree_->distance_(tree_->items_[node.item].first, target_); |
|||
|
|||
if (dist < tau_) { |
|||
if (heap_.size() == neighborsCount_) |
|||
heap_.pop(); |
|||
|
|||
heap_.push({node.item, dist}); |
|||
|
|||
if (heap_.size() == neighborsCount_) |
|||
tau_ = heap_.top().dist; |
|||
} |
|||
|
|||
if (dist < node.threshold) { |
|||
if (node.left != Node::Leaf && dist - tau_ <= node.threshold) |
|||
searchInNode(tree_->nodes_[node.left]); |
|||
|
|||
if (node.right != Node::Leaf && dist + tau_ >= node.threshold) |
|||
searchInNode(tree_->nodes_[node.right]); |
|||
} else { |
|||
if (node.right != Node::Leaf && dist + tau_ >= node.threshold) |
|||
searchInNode(tree_->nodes_[node.right]); |
|||
|
|||
if (node.left != Node::Leaf && dist - tau_ <= node.threshold) |
|||
searchInNode(tree_->nodes_[node.left]); |
|||
} |
|||
} |
|||
|
|||
} // namespace vpt
|
|||
@ -0,0 +1,18 @@ |
|||
#include "ofMain.h" |
|||
#include "ofApp.h" |
|||
|
|||
//========================================================================
|
|||
int main( ){ |
|||
|
|||
//Use ofGLFWWindowSettings for more options like multi-monitor fullscreen
|
|||
ofGLWindowSettings settings; |
|||
settings.setSize(1920, 960); |
|||
settings.setGLVersion(3, 2); |
|||
settings.windowMode = OF_WINDOW; //can also be OF_FULLSCREEN
|
|||
|
|||
auto window = ofCreateWindow(settings); |
|||
|
|||
ofRunApp(window, make_shared<ofApp>()); |
|||
ofRunMainLoop(); |
|||
|
|||
} |
|||
@ -0,0 +1,184 @@ |
|||
#include "ofApp.h" |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::setup(){ |
|||
|
|||
const int vectorCount = 10000; |
|||
const int dimension = 7; |
|||
const int queryCount = 10; |
|||
const int k = 5; // Number of nearest neighbors to find
|
|||
|
|||
// Generate random vectors
|
|||
auto vectors = vp_tree.generateRandomVectors(vectorCount, dimension); |
|||
|
|||
vpt::VpTree tree = vp_tree.buildTree(vectors); |
|||
vp_tree.saveTree("./data/vp-tree.bin", tree); |
|||
|
|||
// Generate query vectors
|
|||
auto queries = vp_tree.generateRandomVectors(queryCount, dimension); |
|||
for (const auto& query : queries) { |
|||
auto [distances, indices] = tree.getNearestNeighbors(query, k); |
|||
|
|||
// Uncomment the following lines to print results for each query
|
|||
std::cout << "Query: "; |
|||
for (double d : query) std::cout << d << " "; |
|||
std::cout << "\nNearest neighbors:\n"; |
|||
for (int i = 0; i < k; ++i) { |
|||
std::cout << " Index: " << indices[i] << ", Distance: " << distances[i] << "\n"; |
|||
} |
|||
} |
|||
|
|||
record_fbo.allocate(ofGetWindowWidth(), ofGetWindowHeight(), GL_RGB); |
|||
shader_fbo.allocate(ofGetWindowWidth(), ofGetWindowHeight(), GL_RGBA); |
|||
out_fbo.allocate(ofGetWindowWidth(), ofGetWindowHeight(), GL_RGBA); |
|||
ofSetVerticalSync(true); |
|||
ofDisableArbTex(); |
|||
//ofEnableDepthTest();
|
|||
ofDisableDepthTest(); |
|||
ofDisableAntiAliasing(); |
|||
ofEnableAlphaBlending(); |
|||
shaders.load("dither"); |
|||
|
|||
std::string path = "images"; |
|||
ofDirectory dir(path); |
|||
dir.allowExt("png"); |
|||
dir.listDir(); |
|||
|
|||
ofLoadImage(bayer, "images/bayer.png"); |
|||
bayer.setTextureWrap(GL_REPEAT, GL_REPEAT); |
|||
|
|||
// Loop through files and load images
|
|||
for (size_t i = 0; i < dir.size(); i++) { |
|||
std::string filePath = dir.getPath(i); |
|||
ofImage img; |
|||
if (img.load(filePath)) { // Load the image
|
|||
images.push_back(img); // Add the image to the list
|
|||
} else { |
|||
ofLog() << "Failed to load: " << filePath; // Log if failed to load
|
|||
} |
|||
} |
|||
|
|||
bullet.setup(); |
|||
|
|||
vector<ofMesh> mesh_list; |
|||
|
|||
for(auto& img : images){ |
|||
mesh_list = mesh_generator.generateSimplifiedMesh(img); |
|||
bullet.addMesh(mesh_list[0], mesh_list[1], img.getTexture()); |
|||
mesh_list.clear(); |
|||
} |
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::update(){ |
|||
bullet.update(); |
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::draw(){ |
|||
|
|||
ofPushStyle(); |
|||
shader_fbo.begin(); |
|||
ofClear(ofColor::grey); |
|||
bullet.draw(); |
|||
shader_fbo.end(); |
|||
ofPopStyle(); |
|||
|
|||
ofTexture t = shader_fbo.getTexture(); |
|||
|
|||
|
|||
out_fbo.begin(); |
|||
shaders.begin(); |
|||
shaders.setUniformTexture("tex0", t, 0); |
|||
shaders.setUniformTexture("tex1", bayer, 1); |
|||
shaders.setUniform2f("resolution", ofGetWidth(), ofGetHeight()); |
|||
shaders.setUniform1f("time", ofGetElapsedTimef()); |
|||
shaders.setUniform1i("frame", ofGetFrameNum()); |
|||
ofClear(0, 0, 0, 0); |
|||
shader_fbo.draw(0,0); |
|||
|
|||
shaders.end(); |
|||
out_fbo.end(); |
|||
|
|||
|
|||
out_fbo.draw(0,0); |
|||
//shader_fbo.draw(0, 0);
|
|||
// float planeScale = 0.75;
|
|||
// int planeWidth = ofGetWidth() * planeScale;
|
|||
// int planeHeight = ofGetHeight() * planeScale;
|
|||
// int planeGridSize = 20;
|
|||
// int planeColumns = planeWidth / planeGridSize;
|
|||
// int planeRows = planeHeight / planeGridSize;
|
|||
|
|||
// plane.set(planeWidth, planeHeight, planeColumns, planeRows, OF_PRIMITIVE_TRIANGLES);
|
|||
|
|||
// plane.mapTexCoordsFromTexture(t);
|
|||
|
|||
// t.bind();
|
|||
// shaders.begin();
|
|||
// ofPushMatrix();
|
|||
// ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
|||
// plane.draw();
|
|||
// ofPopMatrix();
|
|||
// shaders.end();
|
|||
// t.unbind();
|
|||
|
|||
|
|||
//t.draw(ofGetWindowWidth() / 2, 0);
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::keyPressed(int key){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::keyReleased(int key){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::mouseMoved(int x, int y ){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::mouseDragged(int x, int y, int button){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::mousePressed(int x, int y, int button){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::mouseReleased(int x, int y, int button){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::mouseEntered(int x, int y){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::mouseExited(int x, int y){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::windowResized(int w, int h){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::gotMessage(ofMessage msg){ |
|||
|
|||
} |
|||
|
|||
//--------------------------------------------------------------
|
|||
void ofApp::dragEvent(ofDragInfo dragInfo){ |
|||
|
|||
} |
|||
|
|||
@ -0,0 +1,43 @@ |
|||
#pragma once |
|||
|
|||
#include "ofMain.h" |
|||
#include "MeshGenerator.h" |
|||
#include "Bullet.h" |
|||
#include "VP.h" |
|||
|
|||
class ofApp : public ofBaseApp{ |
|||
|
|||
public: |
|||
void setup(); |
|||
void update(); |
|||
void draw(); |
|||
|
|||
void keyPressed(int key); |
|||
void keyReleased(int key); |
|||
void mouseMoved(int x, int y ); |
|||
void mouseDragged(int x, int y, int button); |
|||
void mousePressed(int x, int y, int button); |
|||
void mouseReleased(int x, int y, int button); |
|||
void mouseEntered(int x, int y); |
|||
void mouseExited(int x, int y); |
|||
void windowResized(int w, int h); |
|||
void dragEvent(ofDragInfo dragInfo); |
|||
void gotMessage(ofMessage msg); |
|||
|
|||
ofEasyCam cam; |
|||
ofImage img; |
|||
ofMesh mesh; |
|||
MeshGenerator mesh_generator; |
|||
Bullet bullet; |
|||
vector<ofImage> images; |
|||
|
|||
ofFbo record_fbo; |
|||
ofFbo shader_fbo; |
|||
ofFbo out_fbo; |
|||
|
|||
ofShader shaders; |
|||
|
|||
ofPlanePrimitive plane; |
|||
ofTexture bayer; |
|||
VP vp_tree; |
|||
}; |
|||
Loading…
Reference in new issue