lucaspalomodevelop/meshlab
1
0
Fork 0
mirror of https://github.com/lucaspalomodevelop/meshlab.git synced 2026-03-13 00:07:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'devel' into animate_meshes

Browse Source 
# Conflicts:
#	src/meshlab/layerDialog.cpp
This commit is contained in:
Alessandro Muntoni 2023-08-29 10:07:59 +02:00
commit 0f5d624679
3149 changed files with 74054 additions and 952963 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
.github/actions/0_setup/action.yml vendored Normal file
View File

@ -0,0 +1,23 @@
name: 'Setup Environment'
description: 'Setup Environment'
inputs:
qt-version:
description: 'Qt Version'
required: false
default: '5.15.2'
runs:
using: "composite"
steps:
- name: Setup MSVC
uses: ilammy/msvc-dev-cmd@v1
- name: Install Qt
uses: jurplel/install-qt-action@v3
with:
cache: true
version: ${{ inputs.qt-version }}
- name: Install dependencies
shell: bash
run: |
bash scripts/${{ runner.os }}/0_setup_env.sh --dont_install_qt

56
.github/actions/1_build/action.yml vendored Normal file
View File

@ -0,0 +1,56 @@
name: 'Build'
description: 'Build'
inputs:
cache-path:
description: 'Directory to cache after build'
required: false
default: ''
cache-key:
description: 'Cache key'
required: false
default: ''
build-option:
description: 'Build option'
required: false
default: ''
nightly:
description: 'Nightly build'
required: false
type: boolean
default: false
runs:
using: "composite"
steps:
- name: Setup env variables
id: envs
shell: bash
run: |
if [ "${{ inputs.build-option }}" != "" ]; then
echo "build_option=--${{ inputs.build-option }}" >> $GITHUB_OUTPUT
echo "artifact_suffix=_${{ inputs.build-option }}" >> $GITHUB_OUTPUT
else
echo "build_option=" >> $GITHUB_OUTPUT
echo "artifact_suffix=" >> $GITHUB_OUTPUT
fi
if [ "${{ inputs.nightly }}" = "true" ]; then
echo "nightly=--nightly" >> $GITHUB_OUTPUT
else
echo "nightly=" >> $GITHUB_OUTPUT
fi
- name: Cache external libraries sources
id: cache-ext-libs
if: ${{ inputs.cache-path != '' }}
uses: actions/cache@v3
with:
path: ${{ inputs.cache-path }}
key: ${{ runner.os }}-${{ inputs.cache-key }}
- name: Ccache
uses: hendrikmuhs/ccache-action@v1.2
with:
key: ${{ runner.os }}-${{ github.ref }}-${{ inputs.build-option }}
- name: Configure and Build
shell: bash
run: |
bash scripts/${{ runner.os }}/1_build.sh ${{ steps.envs.outputs.build_option }} ${{ steps.envs.outputs.nightly }} --ccache

65
.github/actions/2_deploy/action.yml vendored Normal file
View File

@ -0,0 +1,65 @@
name: 'Deploy'
description: 'Deploy'
inputs:
mac-certificate:
description: 'MacOS Certificate'
required: false
default: ''
mac-certificate-id:
description: 'MacOS Certificate ID'
required: false
default: ''
mac-certificate-pssw:
description: 'MacOS Certificate Password'
required: false
mac-notarization-user:
description: 'MacOS Notarization User'
required: false
default: ''
mac-notarization-team:
description: 'MacOS Notarization Team'
required: false
default: ''
mac-notarization-pssw:
description: 'MacOS Notarization Password'
required: false
default: ''
win-certificate:
description: 'Windows Certificate'
required: false
default: ''
win-certificate-pssw:
description: 'Windows Certificate Password'
required: false
default: ''
runs:
using: "composite"
steps:
- name: Set Notarization settings
id: notarization
shell: bash
run: |
if [ "${{ inputs.mac-notarization-user }}" != "" ]; then
echo "not_setting=--notarization_user='${{ inputs.mac-notarization-user }}' --notarization_team='${{ inputs.mac-notarization-team }}' --notarization_pssw='${{ inputs.mac-notarization-pssw }}'" >> $GITHUB_OUTPUT
else
echo "not_setting=" >> $GITHUB_OUTPUT
fi
- name: Set CodeSign Certificate macOS
if: ${{ runner.os == 'macOS' && inputs.mac-certificate != ''}}
uses: apple-actions/import-codesign-certs@v2
with:
p12-file-base64: ${{ inputs.mac-certificate }}
p12-password: ${{ inputs.mac-certificate-pssw }}
- name: Set CodeSign Certificate Windows
shell: powershell
if: ${{ runner.os == 'Windows' && inputs.win-certificate != '' }}
run: |
New-Item -ItemType directory -Path certificate
Set-Content -Path certificate\certificate.txt -Value '${{ inputs.win-certificate }}'
certutil -decode certificate\certificate.txt certificate\certificate.pfx
- name: Deploy
shell: bash
run: |
bash scripts/${{ runner.os }}/2_deploy.sh --cert_pssw='${{ inputs.win-certificate-pssw }}' --cert_id='${{ inputs.mac-certificate-id }}' ${{ steps.notarization.outputs.not_setting }}

10
.github/pull_request_template.md vendored Normal file
View File

@ -0,0 +1,10 @@
## Thank you for sending a Pull Request to MeshLab!
On this repository, we keep two relevant branches:
- `main`: we keep here the **last release version of MeshLab**, with just bugfixes. In case of serious bugs caught after a release, this branch is used to publish "post-releases".
- `devel`: we add here new features and functionalities of the software that are going to appear in the next release of MeshLab. Bugfixes pushed in `main` are automatically merged on the `devel` branch.
Before submitting a PR, please check which branch suits better for your contribution!
**PLEASE REMOVE THIS BEFORE SUBMITTING**

9
.github/stale.yml vendored
View File

@ -34,9 +34,10 @@ staleLabel: wontfix
# Comment to post when marking as stale. Set to `false` to disable
markComment: >
This issue has been automatically marked as stale because it has not had
recent activity. It will be closed if no further activity occurs. Thank you
for your contributions.
This issue has been automatically marked as stale because it has not had recent activity. The resources of the VCLab team are limited, and so we are asking for your help.
If this is a bug and you can still reproduce this error on the last release of MeshLab, please reply with all of the information you have about it in order to keep the issue open.
If this is a feature request, and you feel that it is still relevant and valuable, please tell us why.
This issue will automatically be closed in the near future if no further activity occurs. Thank you for all your contributions.
# Comment to post when removing the stale label.
# unmarkComment: >
@ -50,7 +51,7 @@ markComment: >
limitPerRun: 10
# Limit to only `issues` or `pulls`
# only: issues
only: issues
# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls':
# pulls:

22
.github/workflows/AutoMergeMainOnDevel.yml vendored Normal file
View File

@ -0,0 +1,22 @@
name: AutoMergeMainOnDevel
on:
push:
branches:
- 'main'
jobs:
auto_merge:
if: github.repository == 'cnr-isti-vclab/meshlab'
name: Automatic Merge Main On Devel
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Merge main -> devel
uses: devmasx/merge-branch@master
with:
type: now
target_branch: devel
message: "Automatic merge branch 'main' into 'devel'"
github_token: ${{ github.token }}

60
.github/workflows/BuildMeshLab.yml vendored Normal file
View File

@ -0,0 +1,60 @@
name: BuildMeshLab
on:
[push, pull_request]
env:
QT_VERSION: 5.15.2
MAC_CERT: ${{secrets.MACOS_CERT_ID}}
MAC_CERT_PSSW: ${{secrets.MACOS_CERTIFICATE_PSSW}}
WIN_CERT: ${{secrets.WIN_CERTIFICATE}}
jobs:
meshlab_build:
name: Build MeshLab
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: ['ubuntu-20.04', 'macos-latest', 'windows-latest']
precision: [single_precision, double_precision]
steps:
- uses: actions/checkout@v3
with:
submodules: recursive
- name: Setup Environment
uses: ./.github/actions/0_setup
- name: Setup env variables
id: envs
shell: bash
run: |
if [ "${{matrix.precision}}" == "double_precision" ]; then
echo "artifact_suffix=_double" >> $GITHUB_OUTPUT
else
echo "artifact_suffix=" >> $GITHUB_OUTPUT
fi
- name: Build
uses: ./.github/actions/1_build
with:
cache-path: src/external/downloads/*
cache-key: external-libraries
build-option: ${{matrix.precision}}
nightly: true
- name: Deploy
uses: ./.github/actions/2_deploy
with:
mac-certificate: ${{ secrets.MACOS_CERTIFICATE }}
mac-certificate-id: ${{ secrets.MACOS_CERT_ID }}
mac-certificate-pssw: ${{ secrets.MACOS_CERTIFICATE_PSSW }}
win-certificate: ${{ secrets.WIN_CERTIFICATE }}
win-certificate-pssw: ${{ secrets.WIN_CERTIFICATE_PSSW }}
- name: Upload MeshLab Portable
uses: actions/upload-artifact@v3
with:
name: MeshLab_${{ runner.os }}_portable${{steps.envs.outputs.artifact_suffix}}
path: install/
- name: Upload MeshLab Packages
uses: actions/upload-artifact@v3
with:
name: MeshLab_${{ runner.os }}_packages${{steps.envs.outputs.artifact_suffix}}
path: packages/MeshLab*

460
.github/workflows/CreateRelease.yml vendored
View File

@ -9,413 +9,213 @@ on:
required: true
default: 'YYYY.MM'
env:
QT_VERSION: 5.15.2
jobs:
update_ml_version:
name: Update ML_VERSION, snapcraft.yaml and Info.plist
runs-on: macos-latest
name: Update ML_VERSION
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions/checkout@v3
with:
submodules: true
- name: Update MeshLab version
run : |
echo ${{ github.event.inputs.version }} | tr -d '\n'> ML_VERSION
- name: Update Info.plist
run: |
/usr/libexec/PlistBuddy -c "Set CFBundleShortVersionString ${{ github.event.inputs.version }}" src/meshlab/Info.plist
/usr/libexec/PlistBuddy -c "Set CFBundleVersion ${{ github.event.inputs.version }}" src/meshlab/Info.plist
- name: Update Snap file
run: |
sed "s%MESHLAB_VERSION%$(cat ML_VERSION)%g" scripts/Linux/resources/snap/snap_noversion.yaml > snapcraft.yaml
- name: commit ML_VERSION, snapcraft.yaml and Info.plist change
uses: stefanzweifel/git-auto-commit-action@v4.1.1
- name: commit ML_VERSION change
uses: stefanzweifel/git-auto-commit-action@v4
with:
commit_message: Apply automatic ML_VERSION, snapcraft.yaml and Info.plist change
commit_message: Set MeshLab version to ${{ github.event.inputs.version }}
linux_build:
meshlab_build:
needs: [update_ml_version]
name: Build MeshLab (Linux)
runs-on: ubuntu-16.04 #in order to deploy, need to use oldest supported version
name: Build MeshLab
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: ['ubuntu-20.04', 'macos-latest', 'windows-latest']
precision: [single_precision, double_precision]
steps:
- uses: actions/checkout@v2
- uses: actions/checkout@v3
with:
ref: master
submodules: true
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Install dependencies
run: |
sudo apt-get install -y mesa-common-dev libglu1-mesa-dev libgmp-dev
#needed by qt 5.15 on linux
sudo apt-get install libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-render-util0-dev libxcb-xinerama0-dev
submodules: recursive
ref: main
- name: Setup Environment
uses: ./.github/actions/0_setup
- name: Setup env variables
id: envs
shell: bash
run: |
if [ "${{matrix.precision}}" == "double_precision" ]; then
echo ::set-output name=version::"$(cat ML_VERSION)d"
echo ::set-output name=artifact_suffix::"_double"
echo "artifact_suffix=_double" >> $GITHUB_OUTPUT
else
echo ::set-output name=version::"$(cat ML_VERSION)"
echo ::set-output name=artifact_suffix::""
echo "artifact_suffix=" >> $GITHUB_OUTPUT
fi
- name: Configure and Build
run: |
sh scripts/${{ runner.os }}/1_build.sh --${{ matrix.precision }}
- name: Build
uses: ./.github/actions/1_build
with:
cache-path: src/external/downloads/*
cache-key: external-libraries
build-option: ${{matrix.precision}}
- name: Deploy
run: |
sh scripts/${{ runner.os }}/2_deploy.sh
- name: Build MeshLab AppImage
run : |
sh scripts/${{ runner.os }}/3_appimage.sh --${{ matrix.precision }}
- name: Upload Meshlab Portable
uses: actions/upload-artifact@v1
uses: ./.github/actions/2_deploy
with:
name: meshlab_linux_portable${{steps.envs.outputs.artifact_suffix}}
path: src/install/
- name: Upload Meshlab AppImage
uses: actions/upload-artifact@v1
with:
name: meshlab_linux_appimage${{steps.envs.outputs.artifact_suffix}}
path: src/MeshLab${{steps.envs.outputs.version}}-linux.AppImage
macos_build:
needs: [update_ml_version]
name: Build MeshLab (MacOS)
runs-on: macos-latest
strategy:
matrix:
precision: [single_precision, double_precision]
steps:
- uses: actions/checkout@v2
with:
ref: master
submodules: true
- name: Install dependencies
run: |
brew install libomp
npm install -g appdmg
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Setup env variables
id: envs
shell: bash
run: |
if [ "${{matrix.precision}}" == "double_precision" ]; then
echo ::set-output name=version::"$(cat ML_VERSION)d"
echo ::set-output name=artifact_suffix::"_double"
else
echo ::set-output name=version::"$(cat ML_VERSION)"
echo ::set-output name=artifact_suffix::""
fi
- name: Configure and Build
run: |
sh scripts/${{ runner.os }}/1_build.sh --${{ matrix.precision }}
- name: Deploy
run: |
sh scripts/${{ runner.os }}/2_deploy.sh
- name: Create MeshLab DMG
run: |
sh scripts/${{ runner.os }}/3_dmg.sh --${{ matrix.precision }}
mv src/install/MeshLab${{steps.envs.outputs.version}}.dmg src/install/MeshLab${{steps.envs.outputs.version}}-macos.dmg
mac-certificate: ${{ secrets.MACOS_CERTIFICATE }}
mac-certificate-id: ${{ secrets.MACOS_CERT_ID }}
mac-certificate-pssw: ${{ secrets.MACOS_CERTIFICATE_PSSW }}
mac-notarization-user: ${{ secrets.MACOS_NOTARIZATION_USER }}
mac-notarization-team: ${{ secrets.MACOS_NOTARIZATION_TEAM_ID }}
mac-notarization-pssw: ${{ secrets.MACOS_NOTARIZATION_PSSW }}
win-certificate: ${{ secrets.WIN_CERTIFICATE }}
win-certificate-pssw: ${{ secrets.WIN_CERTIFICATE_PSSW }}
- name: Upload MeshLab Portable
uses: actions/upload-artifact@v1
uses: actions/upload-artifact@v3
with:
name: meshlab_macos_portable${{steps.envs.outputs.artifact_suffix}}
path: src/install/meshlab.app
- name: Upload DMG
uses: actions/upload-artifact@v1
name: MeshLab_${{ runner.os }}_portable${{steps.envs.outputs.artifact_suffix}}
path: install/
- name: Upload MeshLab Packages
uses: actions/upload-artifact@v3
with:
name: meshlab_macos_dmg${{steps.envs.outputs.artifact_suffix}}
path: src/install/MeshLab${{steps.envs.outputs.version}}-macos.dmg
windows_build:
needs: [update_ml_version]
name: Build MeshLab (Windows)
runs-on: windows-latest
strategy:
matrix:
precision: [single_precision, double_precision]
steps:
- uses: actions/checkout@v2
with:
ref: master
submodules: true
- name: Download Jom
run: |
Invoke-WebRequest -Uri "http://download.qt.io/official_releases/jom/jom_1_1_3.zip" -OutFile "jom_1_1_3.zip"
New-Item -Name "jom" -ItemType "directory"
Expand-Archive -Path jom_1_1_3.zip -DestinationPath .\jom
echo "$(Get-Location)\jom" >> GITHUB_PATH
- name: Setup MSVC
uses: ilammy/msvc-dev-cmd@v1
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Setup env variables
shell: bash
id: envs
run: |
if [ "${{matrix.precision}}" == "double_precision" ]; then
echo ::set-output name=version::"$(cat ML_VERSION)d"
echo ::set-output name=artifact_suffix::"_double"
else
echo ::set-output name=version::"$(cat ML_VERSION)"
echo ::set-output name=artifact_suffix::""
fi
echo "VCINSTALLDIR=C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC" >> $GITHUB_ENV
- name: Configure and Build
shell: bash
run: |
sh scripts/${{ runner.os }}/1_build.sh --${{ matrix.precision }}
- name: Deploy
shell: bash
run: |
sh scripts/${{ runner.os }}/2_deploy.sh
- name: NSIS script
shell: bash
run: |
sh scripts/${{ runner.os }}/resources/nsis_script.sh --${{ matrix.precision }}
- name: Create Installer
uses: joncloud/makensis-action@v1
with:
script-file: "src/install/meshlab_final.nsi"
- name: Rename Installer
shell: bash
run: |
mv src/install/MeshLab${{steps.envs.outputs.version}}.exe src/MeshLab${{steps.envs.outputs.version}}-windows.exe
- name: Uploading MeshLab Portable
uses: actions/upload-artifact@v1
with:
name: meshlab_windows_portable${{steps.envs.outputs.artifact_suffix}}
path: src/install
- name: Upload Meshlab Installer
uses: actions/upload-artifact@v1
with:
name: meshlab_windows_installer${{steps.envs.outputs.artifact_suffix}}
path: src/MeshLab${{steps.envs.outputs.version}}-windows.exe
name: MeshLab_${{ runner.os }}_packages${{steps.envs.outputs.artifact_suffix}}
path: packages/MeshLab*
#after building MeshLab for the three platforms, we create a release in github
create_release:
name: Create Release
needs: [linux_build, macos_build, windows_build]
needs: [meshlab_build]
runs-on: ubuntu-latest
steps:
#Download Linux Packages
- name: Download Linux ZIP
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_linux_portable
name: MeshLab_Linux_portable
path: meshlab_linux_portable
- name: Download Linux ZIP-d
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_linux_portable_double
name: MeshLab_Linux_portable_double
path: meshlab_linux_portable_double
- name: Download Linux AppImage
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_linux_appimage
name: MeshLab_Linux_packages
path: meshlab_linux_appimage
- name: Download Linux AppImage-d
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_linux_appimage_double
name: MeshLab_Linux_packages_double
path: meshlab_linux_appimage_double
- name: Change Permissions
run: |
chmod +x meshlab_linux_portable/usr/bin/meshlab
chmod +x meshlab_linux_portable/AppRun
chmod +x meshlab_linux_portable_double/usr/bin/meshlab
chmod +x meshlab_linux_portable_double/AppRun
- name: Setup env variables
id: envs
shell: bash
run: |
#get version of meshlab
IFS=' ' #space delimiter
STR_VERSION=$(meshlab_linux_portable/usr/bin/meshlab --version)
read -a strarr <<< "$STR_VERSION"
ML_VERSION=${strarr[1]} #get the meshlab version from the string
echo "ml_version=$ML_VERSION" >> $GITHUB_OUTPUT
STR_VERSION=$(meshlab_linux_portable_double/usr/bin/meshlab --version)
read -a strarrd <<< "$STR_VERSION"
ML_VERSION_D=${strarrd[1]} #get the meshlab version from the string
echo "ml_version_d=$ML_VERSION_D" >> $GITHUB_OUTPUT
#access to this variable using ${{steps.envs.outputs.ml_version}} or ${{steps.envs.outputs.ml_version_d}}
- name: Create MeshLab Portable Linux Archive
run: |
tar -cvzf MeshLab${{ github.event.inputs.version }}-linux.tar.gz meshlab_linux_portable/
tar -cvzf MeshLab${{ github.event.inputs.version }}d-linux.tar.gz meshlab_linux_portable_double/
cd meshlab_linux_portable
tar -cvzf ../MeshLab${{steps.envs.outputs.ml_version}}-linux.tar.gz *
cd ../meshlab_linux_portable_double
tar -cvzf ../MeshLab${{steps.envs.outputs.ml_version_d}}-linux.tar.gz *
cd ..
#Download MacOS Package
- name: Download MacOS DMG
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_macos_dmg
name: MeshLab_macOS_packages
path: meshlab_macos_dmg
- name: Download MacOS DMG-d
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_macos_dmg_double
name: MeshLab_macOS_packages_double
path: meshlab_macos_dmg_double
- name: Download MacOS Portable
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_macos_portable
name: MeshLab_macOS_portable
path: meshlab_macos_portable
- name: Download MacOS Portable-d
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_macos_portable_double
name: MeshLab_macOS_portable_double
path: meshlab_macos_portable_double
- name: Change Permissions
run: |
chmod +x meshlab_macos_portable/MeshLab*.app/Contents/MacOS/meshlab
chmod +x meshlab_macos_portable_double/MeshLab*.app/Contents/MacOS/meshlab
- name: Create MeshLab Portable MacOS
run: |
mv meshlab_macos_portable meshlab.app
zip -r MeshLab${{ github.event.inputs.version }}-macos.zip meshlab.app/
rm -r meshlab.app
mv meshlab_macos_portable_double meshlab.app
zip -r MeshLab${{ github.event.inputs.version }}d-macos.zip meshlab.app/
cd meshlab_macos_portable
tar -cvzf ../MeshLab${{steps.envs.outputs.ml_version}}-macos.tar.gz *
cd ../meshlab_macos_portable_double
tar -cvzf ../MeshLab${{steps.envs.outputs.ml_version_d}}-macos.tar.gz *
cd ..
#Download Windows Packages
- name: Download Windows ZIP
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_windows_portable
name: MeshLab_Windows_portable
path: meshlab_windows_portable
- name: Download Windows ZIP-d
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_windows_portable_double
name: MeshLab_Windows_portable_double
path: meshlab_windows_portable_double
- name: Download Windows Installer
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_windows_installer
name: MeshLab_Windows_packages
path: meshlab_windows_installer
- name: Download Windows Installer-d
uses: actions/download-artifact@v1
uses: actions/download-artifact@v3
with:
name: meshlab_windows_installer_double
name: MeshLab_Windows_packages_double
path: meshlab_windows_installer_double
- name: Create MeshLab Portable Windows Archive
run: |
zip -r MeshLab${{ github.event.inputs.version }}-windows.zip meshlab_windows_portable/
zip -r MeshLab${{ github.event.inputs.version }}d-windows.zip meshlab_windows_portable_double/
cd meshlab_windows_portable
zip -r ../MeshLab${{steps.envs.outputs.ml_version}}-windows.zip *
cd ../meshlab_windows_portable_double
zip -r ../MeshLab${{steps.envs.outputs.ml_version_d}}-windows.zip *
cd ..
#Create release and upload
- name: Publish Release
id: create_release
uses: actions/create-release@v1.0.0
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- uses: "marvinpinto/action-automatic-releases@6273874b61ebc8c71f1a61b2d98e234cf389b303"
with:
tag_name: Meshlab-${{ github.event.inputs.version }}
release_name: MeshLab-${{ github.event.inputs.version }}
draft: false
prerelease: false
#Linux
- name: Upload ReleaseLinuxPortable
id: upload-release-linux-portable
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: MeshLab${{ github.event.inputs.version }}-linux.tar.gz
asset_name: MeshLab${{ github.event.inputs.version }}-linux.tar.gz
asset_content_type: MeshLab Portable for Linux
- name: Upload ReleaseLinuxPortable-d
id: upload-release-linux-portable-d
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: MeshLab${{ github.event.inputs.version }}d-linux.tar.gz
asset_name: MeshLab${{ github.event.inputs.version }}d-linux.tar.gz
asset_content_type: MeshLab Portable for Linux
- name: Upload ReleaseLinuxAppImage
id: upload-release-linux-appimage
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: meshlab_linux_appimage/MeshLab${{ github.event.inputs.version }}-linux.AppImage
asset_name: MeshLab${{ github.event.inputs.version }}-linux.AppImage
asset_content_type: MeshLab AppImage for Linux
- name: Upload ReleaseLinuxAppImage-d
id: upload-release-linux-appimage-d
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: meshlab_linux_appimage_double/MeshLab${{ github.event.inputs.version }}d-linux.AppImage
asset_name: MeshLab${{ github.event.inputs.version }}d-linux.AppImage
asset_content_type: MeshLab AppImage for Linux
#MacOS
- name: Upload ReleaseMacOSDMG
id: upload-release-macos
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: meshlab_macos_dmg/MeshLab${{ github.event.inputs.version }}-macos.dmg
asset_name: MeshLab${{ github.event.inputs.version }}-macos.dmg
asset_content_type: MeshLab DMG for MacOS
- name: Upload ReleaseMacOSDMG-d
id: upload-release-macos-d
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: meshlab_macos_dmg_double/MeshLab${{ github.event.inputs.version }}d-macos.dmg
asset_name: MeshLab${{ github.event.inputs.version }}d-macos.dmg
asset_content_type: MeshLab DMG for MacOS
- name: Upload ReleaseMacOSPortable
id: upload-release-macos-portable
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: MeshLab${{ github.event.inputs.version }}-macos.zip
asset_name: MeshLab${{ github.event.inputs.version }}-macos.zip
asset_content_type: MeshLab Portable for MacOS
- name: Upload ReleaseMacOSPortable-d
id: upload-release-macos-portable-d
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: MeshLab${{ github.event.inputs.version }}d-macos.zip
asset_name: MeshLab${{ github.event.inputs.version }}d-macos.zip
asset_content_type: MeshLab Portable for MacOS
#Windows
- name: Upload ReleaseWindowsPortable
id: upload-release-windows-portable
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: MeshLab${{ github.event.inputs.version }}-windows.zip
asset_name: MeshLab${{ github.event.inputs.version }}-windows.zip
asset_content_type: MeshLab Portable for Windows
- name: Upload ReleaseWindowsPortable-d
id: upload-release-windows-portable-d
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: MeshLab${{ github.event.inputs.version }}d-windows.zip
asset_name: MeshLab${{ github.event.inputs.version }}d-windows.zip
asset_content_type: MeshLab Portable for Windows
- name: Upload ReleaseWindowsInstaller
id: upload-release-windows-installer
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: meshlab_windows_installer/MeshLab${{ github.event.inputs.version }}-windows.exe
asset_name: MeshLab${{ github.event.inputs.version }}-windows.exe
asset_content_type: MeshLab Portable for Windows
- name: Upload ReleaseWindowsInstaller-d
id: upload-release-windows-installer-d
uses: actions/upload-release-asset@v1.0.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: meshlab_windows_installer_double/MeshLab${{ github.event.inputs.version }}d-windows.exe
asset_name: MeshLab${{ github.event.inputs.version }}d-windows.exe
asset_content_type: MeshLab Portable for Windows
repo_token: "${{ secrets.GITHUB_TOKEN }}"
automatic_release_tag: "MeshLab-${{steps.envs.outputs.ml_version}}"
prerelease: false #${{ github.event.inputs.release_candidate }}
title: "MeshLab-${{steps.envs.outputs.ml_version}}"
files: |
MeshLab${{steps.envs.outputs.ml_version}}-linux.tar.gz
MeshLab${{steps.envs.outputs.ml_version_d}}-linux.tar.gz
meshlab_linux_appimage/MeshLab${{steps.envs.outputs.ml_version}}-linux.AppImage
meshlab_linux_appimage_double/MeshLab${{steps.envs.outputs.ml_version_d}}-linux.AppImage
MeshLab${{steps.envs.outputs.ml_version}}-macos.tar.gz
MeshLab${{steps.envs.outputs.ml_version_d}}-macos.tar.gz
meshlab_macos_dmg/MeshLab${{steps.envs.outputs.ml_version}}-macos.dmg
meshlab_macos_dmg_double/MeshLab${{steps.envs.outputs.ml_version_d}}-macos.dmg
MeshLab${{steps.envs.outputs.ml_version}}-windows.zip
MeshLab${{steps.envs.outputs.ml_version_d}}-windows.zip
meshlab_windows_installer/MeshLab${{steps.envs.outputs.ml_version}}-windows.exe
meshlab_windows_installer_double/MeshLab${{steps.envs.outputs.ml_version_d}}-windows.exe

54
.github/workflows/Linux.yml vendored
View File

@ -1,54 +0,0 @@
name: Linux
on:
[push, pull_request]
jobs:
linux_build:
name: Build MeshLab (Linux)
runs-on: ubuntu-16.04 #in order to deploy, need to use oldest supported version
strategy:
matrix:
precision: [single_precision, double_precision]
steps:
- uses: actions/checkout@v2
with:
submodules: true
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Install dependencies
run: |
sudo apt-get install -y mesa-common-dev libglu1-mesa-dev libgmp-dev
#needed by qt 5.15 on linux
sudo apt-get install libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-render-util0-dev libxcb-xinerama0-dev
- name: Setup env variables
id: envs
shell: bash
run: |
if [ "${{matrix.precision}}" == "double_precision" ]; then
echo ::set-output name=version::"$(cat ML_VERSION)d"
echo ::set-output name=artifact_suffix::"_double"
else
echo ::set-output name=version::"$(cat ML_VERSION)"
echo ::set-output name=artifact_suffix::""
fi
- name: Configure and Build
run: |
sh scripts/${{ runner.os }}/1_build.sh --${{ matrix.precision }}
- name: Deploy
run: |
sh scripts/${{ runner.os }}/2_deploy.sh
- name: Build MeshLab AppImage
run : |
sh scripts/${{ runner.os }}/3_appimage.sh --${{ matrix.precision }}
- name: Upload Meshlab Portable
uses: actions/upload-artifact@v1
with:
name: meshlab_linux_portable${{steps.envs.outputs.artifact_suffix}}
path: src/install/
- name: Upload Meshlab AppImage
uses: actions/upload-artifact@v1
with:
name: meshlab_linux_appimage${{steps.envs.outputs.artifact_suffix}}
path: src/MeshLab${{steps.envs.outputs.version}}-linux.AppImage

35
.github/workflows/LinuxSnap.yml vendored
View File

@ -1,35 +0,0 @@
name: LinuxSnap
on:
workflow_dispatch
jobs:
linux_build_snap:
name: Build MeshLab (Linux - Snap)
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
submodules: true
- name: Install dependencies
run: |
#needed for some reason...
curl https://bazel.build/bazel-release.pub.gpg | sudo apt-key add -
sudo apt update
sudo apt-get install -y snapcraft
- name: Setup env variables
id: envs
run: |
echo ::set-output name=date::"$(cat ML_VERSION)"
- name: Build MeshLab Snap
run: |
snapcraft
- name: Rename Snap
run: |
mv ./meshlab*.snap ./MeshLab${{steps.envs.outputs.date}}-linux.snap
- name: Upload Meshlab Snap
uses: actions/upload-artifact@v1
with:
name: meshlab_linux_snap
path: MeshLab${{steps.envs.outputs.date}}-linux.snap

54
.github/workflows/MacOS.yml vendored
View File

@ -1,54 +0,0 @@
name: MacOS
on:
[push, pull_request]
jobs:
macos_build:
name: Build MeshLab (MacOS)
runs-on: macos-latest
strategy:
matrix:
precision: [single_precision, double_precision]
steps:
- uses: actions/checkout@v2
with:
submodules: true
- name: Install dependencies
run: |
brew install libomp
npm install -g appdmg
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Setup env variables
id: envs
shell: bash
run: |
if [ "${{matrix.precision}}" == "double_precision" ]; then
echo ::set-output name=version::"$(cat ML_VERSION)d"
echo ::set-output name=artifact_suffix::"_double"
else
echo ::set-output name=version::"$(cat ML_VERSION)"
echo ::set-output name=artifact_suffix::""
fi
- name: Configure and Build
run: |
sh scripts/${{ runner.os }}/1_build.sh --${{ matrix.precision }}
- name: Deploy
run: |
sh scripts/${{ runner.os }}/2_deploy.sh
- name: Create DMG
run: |
sh scripts/${{ runner.os }}/3_dmg.sh --${{ matrix.precision }}
mv src/install/MeshLab${{steps.envs.outputs.version}}.dmg src/install/MeshLab${{steps.envs.outputs.version}}-macos.dmg
- name: Upload MeshLab Portable
uses: actions/upload-artifact@v1
with:
name: meshlab_macos_portable${{steps.envs.outputs.artifact_suffix}}
path: src/install/meshlab.app
- name: Upload DMG
uses: actions/upload-artifact@v1
with:
name: meshlab_macos_dmg${{steps.envs.outputs.artifact_suffix}}
path: src/install/MeshLab${{steps.envs.outputs.version}}-macos.dmg

139
.github/workflows/QmakeBuilds.yml vendored
View File

@ -1,139 +0,0 @@
name: Qmake builds
on: [push, pull_request]
jobs:
ubuntu_build:
name: Build MeshLab (Ubuntu - QMake)
runs-on: ubuntu-16.04 #in order to deploy, need to use oldest supported version
steps:
- uses: actions/checkout@v2
with:
submodules: true
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Install dependencies
run: |
sudo apt-get install -y mesa-common-dev libglu1-mesa-dev libglew-dev libeigen3-dev libgmp-dev
sudo apt-get install -y libxkbcommon-x11-0 patchelf
#needed by qt 5.15 on linux
sudo apt-get install libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-render-util0-dev libxcb-xinerama0-dev
- name: Setup env variables
id: envs
run: |
echo ::set-output name=date::"$(cat ML_VERSION)"
- name: Build MeshLab
run: |
sh scripts/${{ runner.os }}/qmake/linux_build.sh
- name: Make MeshLab Bundle
run: |
sh scripts/${{ runner.os }}/qmake/linux_make_bundle.sh
- name: Deploy MeshLab and MeshLabServer
run : |
sh scripts/${{ runner.os }}/qmake/linux_deploy.sh
- name: Build MeshLab and MeshLabServer AppImages
run : |
sh scripts/${{ runner.os }}/qmake/linux_appimages.sh
- name: Upload Meshlab Portable
uses: actions/upload-artifact@v1
with:
name: meshlab_linux_portable
path: distrib/
- name: Upload MeshlabServer AppImage
uses: actions/upload-artifact@v1
with:
name: meshlabserver_linux_appimage
path: MeshLabServer${{steps.envs.outputs.date}}-linux.AppImage
- name: Upload Meshlab AppImage
uses: actions/upload-artifact@v1
with:
name: meshlab_linux_appimage
path: MeshLab${{steps.envs.outputs.date}}-linux.AppImage
macos_build_qmake:
name: Build MeshLab (MacOS - QMake)
runs-on: macos-latest
steps:
- uses: actions/checkout@v2
with:
submodules: true
- name: Install dependencies
run: |
brew install libomp
npm install -g appdmg
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Setup env variables
id: envs
shell: bash
run: |
echo ::set-output name=date::"$(cat ML_VERSION)"
- name: Build MeshLab
run: |
sh scripts/${{ runner.os }}/qmake/macos_build.sh
- name: Deploy MeshLab
run: |
sh scripts/${{ runner.os }}/qmake/macos_deploy.sh
- name: Create DMG
run: |
sh scripts/${{ runner.os }}/qmake/macos_dmg.sh
mv distrib/MeshLab${{steps.envs.outputs.date}}.dmg distrib/MeshLab${{steps.envs.outputs.date}}-macos.dmg
- name: Upload DMG
uses: actions/upload-artifact@v1
with:
name: meshlab_macos_dmg
path: distrib/MeshLab${{steps.envs.outputs.date}}-macos.dmg
windows_build_qmake:
name: Build MeshLab (Windows - QMake)
runs-on: windows-latest
steps:
- uses: actions/checkout@v2
with:
submodules: true
- name: Download Jom
run: |
Invoke-WebRequest -Uri "http://download.qt.io/official_releases/jom/jom_1_1_3.zip" -OutFile "jom_1_1_3.zip"
New-Item -Name "jom" -ItemType "directory"
Expand-Archive -Path jom_1_1_3.zip -DestinationPath .\jom
echo "$(Get-Location)\jom" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
#echo "$(Get-Location)\jom" >> GITHUB_PATH
- name: Setup env variables
id: envs
run: |
echo "VCINSTALLDIR=C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC" >> $GITHUB_ENV
#echo '::set-env name=VCINSTALLDIR::C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC'
echo "::set-output name=date::$(type ML_VERSION)"
- name: Setup MSVC
uses: ilammy/msvc-dev-cmd@v1
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Build MeshLab
run: |
.\scripts\${{ runner.os }}\qmake\windows_build.ps1
- name: Deploy MeshLab
run: |
.\scripts\${{ runner.os }}\qmake\windows_deploy.ps1
- name: NSIS script
run: |
.\scripts\${{ runner.os }}\resources\windows_nsis_script.ps1
- name: Create Installer
uses: joncloud/makensis-action@v1
with:
script-file: "scripts/windows/resources/meshlab_final.nsi"
- name: Rename Installer
run: |
Rename-Item -Path scripts\windows\resources\MeshLab${{steps.envs.outputs.date}}.exe -NewName MeshLab${{steps.envs.outputs.date}}-windows.exe
- name: Upload Meshlab Portable
uses: actions/upload-artifact@v1
with:
name: meshlab_windows_portable
path: distrib
- name: Upload Meshlab Installer
uses: actions/upload-artifact@v1
with:
name: meshlab_windows_installer
path: scripts/windows/resources/MeshLab${{steps.envs.outputs.date}}-windows.exe

68
.github/workflows/Windows.yml vendored
View File

@ -1,68 +0,0 @@
name: Windows
on: [push, pull_request]
jobs:
windows_build:
name: Build MeshLab (Windows)
runs-on: windows-latest
strategy:
matrix:
precision: [single_precision, double_precision]
steps:
- uses: actions/checkout@v2
with:
submodules: true
- name: Download Jom
run: |
Invoke-WebRequest -Uri "http://download.qt.io/official_releases/jom/jom_1_1_3.zip" -OutFile "jom_1_1_3.zip"
New-Item -Name "jom" -ItemType "directory"
Expand-Archive -Path jom_1_1_3.zip -DestinationPath .\jom
echo "$(Get-Location)\jom" >> GITHUB_PATH
- name: Setup MSVC
uses: ilammy/msvc-dev-cmd@v1
- name: Install Qt
uses: jurplel/install-qt-action@v2
- name: Setup env variables
shell: bash
id: envs
run: |
if [ "${{matrix.precision}}" == "double_precision" ]; then
echo ::set-output name=version::"$(cat ML_VERSION)d"
echo ::set-output name=artifact_suffix::"_double"
else
echo ::set-output name=version::"$(cat ML_VERSION)"
echo ::set-output name=artifact_suffix::""
fi
echo "VCINSTALLDIR=C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC" >> $GITHUB_ENV
- name: Configure and Build
shell: bash
run: |
sh scripts/${{ runner.os }}/1_build.sh --${{ matrix.precision }}
- name: Deploy
shell: bash
run: |
sh scripts/${{ runner.os }}/2_deploy.sh
- name: NSIS script
shell: bash
run: |
sh scripts/${{ runner.os }}/resources/nsis_script.sh --${{ matrix.precision }}
- name: Create Installer
uses: joncloud/makensis-action@v1
with:
script-file: "src/install/meshlab_final.nsi"
- name: Rename Installer
shell: bash
run: |
mv src/install/MeshLab${{steps.envs.outputs.version}}.exe src/MeshLab${{steps.envs.outputs.version}}-windows.exe
- name: Uploading MeshLab Portable
uses: actions/upload-artifact@v1
with:
name: meshlab_windows_portable${{steps.envs.outputs.artifact_suffix}}
path: src/install
- name: Upload Meshlab Installer
uses: actions/upload-artifact@v1
with:
name: meshlab_windows_installer${{steps.envs.outputs.artifact_suffix}}
path: src/MeshLab${{steps.envs.outputs.version}}-windows.exe

24
.gitignore vendored
View File

@ -17,16 +17,24 @@
*.db-wal
*.AppImage
.DS_Store
distrib*
src/install/*
# build and install directories
build/*
install/*
# external libraries automatically downloaded by cmake
src/external/easyexif*/test-images/*
src/external/glew*/auto/*
src/external/glew*/build/*
src/external/glew*/config/*
src/external/glew*/doc/*
src/external/downloads/*
src/external/tmp.zip
# files created/modified during deploy stage
install/macos/resources/meshlab_dmg_final.json
install/windows/resources/meshlab_final.nsi
install/windows/resources/MeshLab*.exe
#install/snap20????/prime
#install/snap20????/parts
#install/snap20????/stage
#install/snap20????/*.snap
src/common/generated_version_header.h
##Standard cmake gitignore##
CMakeLists.txt.user
@ -95,7 +103,7 @@ target_wrapper.*
# QtCreator CMake
CMakeLists.txt.user*
# QtCreator 4.8< compilation database
# QtCreator 4.8< compilation database
compile_commands.json
# QtCreator local machine specific files for imported projects

19
CMakeLists.txt Normal file
View File

@ -0,0 +1,19 @@
# Copyright 2019, 2020, Collabora, Ltd.
# Copyright 2019, 2021, Visual Computing Lab, ISTI - Italian National Research Council
# SPDX-License-Identifier: BSL-1.0
cmake_minimum_required(VERSION 3.18)
project(MeshLab)
### Build options
option(MESHLAB_BUILD_MINI "Build only common and meshlab - other plugin targets must be set manually" OFF)
option(MESHLAB_BUILD_STRICT "Strictly enforce resolution of all symbols" ON)
option(MESHLAB_BUILD_WITH_DOUBLE_SCALAR "Use double type instead of float type for scalars" OFF)
option(MESHLAB_ENABLE_DEBUG_LOG_FILE "If enabled, all the logs of MeshLab will be also saved into a log file" OFF)
option(MESHLAB_BUILD_ONLY_LIBRARIES "Build only meshlab-common and plugins, excluding executables" OFF)
option(MESHLAB_USE_DEFAULT_BUILD_AND_INSTALL_DIRS "If set to OFF, it expects that you set manually the binary and install directories" ON)
option(MESHLAB_IS_NIGHTLY_VERSION "Nightly version of meshlab will be used instead of ML_VERSION" OFF)
add_subdirectory(src)

2
ML_VERSION
View File

@ -1 +1 @@
2020.12
2022.02

67
README.md
View File

@ -1,37 +1,48 @@
# ![MeshLab Logo](src/meshlab/images/eye64.png) MeshLab
![Linux](https://github.com/cnr-isti-vclab/meshlab/workflows/Linux/badge.svg)
![MacOS](https://github.com/cnr-isti-vclab/meshlab/workflows/MacOS/badge.svg)
![Windows](https://github.com/cnr-isti-vclab/meshlab/workflows/Windows/badge.svg)
[![BuildMeshLab](https://github.com/cnr-isti-vclab/meshlab/actions/workflows/BuildMeshLab.yml/badge.svg)](https://github.com/cnr-isti-vclab/meshlab/actions/workflows/BuildMeshLab.yml)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5114037.svg)](https://doi.org/10.5281/zenodo.5114037)
This is the official repository for the source and the binaries of [MeshLab](https://www.MeshLab.net).
MeshLab is an open source, portable, and extensible system for the processing and editing of unstructured large 3D triangular meshes. It is aimed to help the processing of the typical not-so-small unstructured models arising in 3D scanning, providing a set of tools for editing, cleaning, healing, inspecting, rendering and converting this kind of meshes. These tools include MeshLab proper, a versatile program with a graphical user interface, and [meshlabserver](https://github.com/cnr-isti-vclab/meshlab/blob/master/src/meshlabserver/README.md), a program that can perform mesh processing tasks in batch mode, without a GUI.
MeshLab is an open source, portable, and extensible system for the processing and editing of unstructured large 3D triangular meshes. It is aimed to help the processing of the typical not-so-small unstructured models arising in 3D scanning, providing a set of tools for editing, cleaning, healing, inspecting, rendering and converting this kind of meshes.
MeshLab is mostly based on the open source C++ mesh processing library [VCGlib](http://www.vcglib.net) developed at the [Visual Computing Lab](http://vcg.isti.cnr.it) of [ISTI - CNR](http://www.isti.cnr.it). VCG can be used as a stand-alone large-scale automated mesh processing pipeline, while MeshLab makes it easy to experiment with its algorithms interactively.
MeshLab is available for Windows, MacOS, and Linux.
MeshLab is available for Windows, macOS, and Linux.
# Releases
You can find the last MeshLab release in the [Releases Tab](https://github.com/cnr-isti-vclab/meshlab/releases) for your favourite platform.
You can also test a built version of MeshLab generated by the last commit pushed in this repository, by downloading the artifacts of the last [Github Actions](https://github.com/cnr-isti-vclab/meshlab/actions) workflow.
You can also test the last nightly version of MeshLab, by downloading the artifacts of the last [Github Actions](https://github.com/cnr-isti-vclab/meshlab/actions) workflow. You can find a guide on how to download it [here](https://github.com/cnr-isti-vclab/meshlab/wiki/How-to-install-the-last-nightly-version).
# Build instructions
We provide a set of scripts that build and deploy MeshLab automatically. All the scripts can be found in the [scripts](https://github.com/cnr-isti-vclab/meshlab/tree/master/scripts) folder.
For specific build instructions see the [src](https://github.com/cnr-isti-vclab/meshlab/blob/master/src/README.md) folder.
We provide a set of scripts that build and deploy MeshLab automatically. All the scripts can be found in the [scripts](https://github.com/cnr-isti-vclab/meshlab/tree/main/scripts) folder.
For specific build instructions see the [src](https://github.com/cnr-isti-vclab/meshlab/blob/main/src/README.md) folder.
# Branches and Pull Requests
On this repository, we keep two relevant branches:
- `main`: we keep here the **last release version of MeshLab**, with just bugfixes, optimizations and changes that do not affect the last released MeshLab binary. In case of bugs caught after a release, this branch is used to publish "post-releases".
- `devel`: we add here new features and functionalities of the software that are going to appear in the next release of MeshLab. Bugfixes pushed in `main` are automatically merged into the `devel` branch.
Before committing a new change, or sending a pull request, please choose the branch that better suits for your change.
If it is just a bugfix, or an edit that does not modify the software (e.g. documentation typos, changes to the deploy system, ...), use the `main` branch.
If it is a new feature that will change the behaviour or the usage of the software, use the `devel` branch.
# Structure of the Repository
The MeshLab repository is organized as follows:
* `distrib`: this folder contains a set of prebuilt libraries and shaders that will be used by MeshLab once it is compiled. For more details, check the readme [here](https://github.com/cnr-isti-vclab/meshlab/tree/master/distrib/README.md);
* `docs`: doxygen scripts for generating MeshLab documentation. For more details, check the readme [here](https://github.com/cnr-isti-vclab/meshlab/tree/master/docs);
* `sample` and `textures`: a set of files (meshes, images) used for tests;
* `resources`: contains a set of files used by the software and by the deploy system to produce the final MeshLab binary;
* `scripts`: in this folder there is a set of platform-dependent scripts to build and deploy MeshLab. For more details, check the readme [here](https://github.com/cnr-isti-vclab/meshlab/tree/master/scripts/README.md);
* `src`: this folder contains all the source code of MeshLab, its plugins and the external libraries that it requires. For more details, check the readme [here](https://github.com/cnr-isti-vclab/meshlab/blob/master/src/README.md);
* `src`: this folder contains all the source code of MeshLab and its plugins. For more details, check the readme [here](https://github.com/cnr-isti-vclab/meshlab/blob/master/src/README.md);
* `unsupported`: this folder contains a set of old and unsupported MeshLab plugins that are no longer included and built under MeshLab.
# License
@ -51,28 +62,33 @@ The MeshLab repository is organized as follows:
Paolo Cignoni \/)\/
Visual Computing Lab http://vcg.isti.cnr.it /\/|
ISTI - Italian National Research Council |
Copyright(C) 2005-2018 \
Copyright(C) 2005-2021 \
```
# References
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5114037.svg)](https://doi.org/10.5281/zenodo.5114037)
Please, when using this tool, cite the references listed in the official web page https://www.meshlab.net/#references according to you needs, or if you are lazy just cite:
Meshlab: an open-source mesh processing tool. P. Cignoni, M. Callieri, M. Corsini, M. Dellepiane, F. Ganovelli, G. Ranzuglia
Proceedings of the 2008 Eurographics Italian Chapter Conference, ISBN: 978-3-905673-68-5, pp. 129-136, DOI: 10.2312/LocalChapterEvents/ItalChap/ItalianChapConf2008/129-136
BibTeX format:
```
@software{meshlab,
author = {Paolo Cignoni, Alessandro Muntoni, Guido Ranzuglia, Marco Callieri},
title = {{MeshLab}},
publisher = {Zenodo},
doi = {10.5281/zenodo.5114037}
}
@inproceedings {LocalChapterEvents:ItalChap:ItalianChapConf2008:129-136,
booktitle = {Eurographics Italian Chapter Conference},
editor = {Vittorio Scarano and Rosario De Chiara and Ugo Erra},
title = {{MeshLab: an Open-Source Mesh Processing Tool}},
author = {Cignoni, Paolo and Callieri, Marco and Corsini, Massimiliano and Dellepiane, Matteo and Ganovelli, Fabio and Ranzuglia, Guido},
year = {2008},
publisher = {The Eurographics Association},
ISBN = {978-3-905673-68-5},
DOI = {10.2312/LocalChapterEvents/ItalChap/ItalianChapConf2008/129-136}
booktitle = {Eurographics Italian Chapter Conference},
editor = {Vittorio Scarano and Rosario De Chiara and Ugo Erra},
title = {{MeshLab: an Open-Source Mesh Processing Tool}},
author = {Cignoni, Paolo and Callieri, Marco and Corsini, Massimiliano and Dellepiane, Matteo and Ganovelli, Fabio and Ranzuglia, Guido},
year = {2008},
publisher = {The Eurographics Association},
ISBN = {978-3-905673-68-5},
DOI = {10.2312/LocalChapterEvents/ItalChap/ItalianChapConf2008/129-136}
}
```
@ -86,6 +102,3 @@ DOI = {10.2312/LocalChapterEvents/ItalChap/ItalianChapConf2008/129-136}
For documented and repeatable bugs, feature requests, etc., please use the [GitHub issues](https://github.com/cnr-isti-vclab/meshlab/issues).
For general questions use [StackOverflow](http://stackoverflow.com/questions/tagged/meshlab).

3
distrib/README.md
View File

@ -1,3 +0,0 @@
# distrib folder
The distrib folder contains a set of pre-built libraries and shaders that MeshLab needs to properly run, plus some other txt files and icons.

BIN
distrib/meshlab.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 83 KiB

56
distrib/readme.txt
View File

@ -1,56 +0,0 @@
MeshLab
http://www.meshlab.net
All rights reserved.
VCGLib http://www.vcglib.net o o
Visual and Computer Graphics Library o o
_ O _
Paolo Cignoni \/)\/
Visual Computing Lab http://vcg.isti.cnr.it /\/|
ISTI - Italian National Research Council |
Copyright(C) 2005-2018 \
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License V 3.0 as published by the Free
Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
(http://www.gnu.org/licenses/gpl.txt) for more details.
--- Windows Note ---
If you are running MeshLab portable and you are getting the error “MSVCP140.dll not found”
or related, please install Visual C++ Redist by executing the vc_redist.exe file contained
in the meshlab portable archive.
--- References ----
Please, when using this tool, cite the following reference:
Meshlab: an open-source mesh processing tool.
P. Cignoni, M. Callieri, M. Corsini, M. Dellepiane, F. Ganovelli, G. Ranzuglia
Proceedings of the 2008 Eurographics Italian Chapter Conference,
ISBN: 978-3-905673-68-5, pp. 129-136, DOI: 10.2312/LocalChapterEvents/ItalChap/ItalianChapConf2008/129-136
@inproceedings {LocalChapterEvents:ItalChap:ItalianChapConf2008:129-136,
booktitle = {Eurographics Italian Chapter Conference},
editor = {Vittorio Scarano and Rosario De Chiara and Ugo Erra},
title = {{MeshLab: an Open-Source Mesh Processing Tool}},
author = {Cignoni, Paolo and Callieri, Marco and Corsini, Massimiliano and Dellepiane, Matteo and Ganovelli, Fabio and Ranzuglia, Guido},
year = {2008},
publisher = {The Eurographics Association},
ISBN = {978-3-905673-68-5},
DOI = {10.2312/LocalChapterEvents/ItalChap/ItalianChapConf2008/129-136}
}
Paolo Cignoni (p.cignoni (at) isti.cnr.it)
Guido Ranzuglia (g.ranzuglia (at) isti.cnr.it)
For documented and repeatable bugs, reasonable feature requests and grounded issues, please use the GitHub services
https://github.com/cnr-isti-vclab/meshlab/issues
For general questions use StackOverflow
http://stackoverflow.com/questions/tagged/meshlab

402
docs/dox/filter.dox
View File

@ -13,9 +13,9 @@ Simulates the aging effects due to small collisions or various chipping events
<TR><TD> \c Int </TD> <TD> Fractal Octaves </TD> <TD><i> The number of octaves that are used in the generation of the <br>fractal noise using Perlin noise; reasonalble values are in the <br>1..8 range. Setting it to 1 means using a simple Perlin Noise. -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Noise frequency scale </TD> <TD><i> Changes the noise frequency scale: this affects chip dimensions and <br>the distance between chips. The value denotes the average values <br>between two dents. Smaller number means small and frequent chips. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Noise clamp threshold [0..1] </TD> <TD><i> All the noise values smaller than this parameter will be <br> considered as 0. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Displacement steps </TD> <TD><i> The whole displacement process is performed as a sequence of small <br>offsets applyed on each vertex. This parameter represents the number <br>of steps into which the displacement process will be splitted. <br>Useful to avoid the introduction of self intersections. <br>Bigger number means better accuracy. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Displacement steps </TD> <TD><i> The whole displacement process is performed as a sequence of small <br>offsets applied on each vertex. This parameter represents the number <br>of steps into which the displacement process will be split. <br>Useful to avoid the introduction of self intersections. <br>Bigger number means better accuracy. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Affect only selected faces </TD> <TD><i> The aging procedure will be applied to the selected faces only. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Store erosion informations </TD> <TD><i> Select this option if you want to store the erosion informations <br>over the mesh. A new attribute will be added to each vertex <br>to contain the displacement offset applied to that vertex. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Store erosion information </TD> <TD><i> Select this option if you want to store the erosion information <br>over the mesh. A new attribute will be added to each vertex <br>to contain the displacement offset applied to that vertex. -- </i></TD> </TR>
</TABLE>
\section f1 Ambient Occlusion - Per Vertex
@ -46,12 +46,12 @@ Generates environment occlusions values for the loaded mesh
<TR><TD> \c Int </TD> <TD> Depth texture size(should be 2^n) </TD> <TD><i> Defines the depth texture size used to compute occlusion from each point of view. Higher values means better accuracy usually with low impact on performance -- </i></TD> </TR>
</TABLE>
\section f3 Automatic pair Alignement
\section f3 Automatic pair Alignment
Automatic Rough Alignment of two meshes. Based on the paper <b> 4-Points Congruent Sets for Robust Pairwise Surface Registration</b>, by Aiger,Mitra, Cohen-Or. Siggraph 2008
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Mesh </TD> <TD> First Mesh </TD> <TD><i> The mesh were the coplanar bases are sampled (it will contain the trasformation) -- </i></TD> </TR>
<TR><TD> \c Mesh </TD> <TD> First Mesh </TD> <TD><i> The mesh were the coplanar bases are sampled (it will contain the transformation) -- </i></TD> </TR>
<TR><TD> \c Mesh </TD> <TD> Second Mesh </TD> <TD><i> The mesh were similar coplanar based are searched. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Estimated fraction of the
first mesh overlapped by the second </TD> <TD><i> -- </i></TD> </TR>
@ -66,7 +66,7 @@ Reconstruct a surface using the <b>Ball Pivoting Algorithm</b> (Bernardini et al
<TR><TD> \c AbsPerc </TD> <TD> Pivoting Ball radius (0 autoguess) </TD> <TD><i> The radius of the ball pivoting (rolling) over the set of points. Gaps that are larger than the ball radius will not be filled; similarly the small pits that are smaller than the ball radius will be filled. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Clustering radius (% of ball radius) </TD> <TD><i> To avoid the creation of too small triangles, if a vertex is found too close to a previous one, it is clustered/merged with it. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Angle Threshold (degrees) </TD> <TD><i> If we encounter a crease angle that is too large we should stop the ball rolling -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Delete intial set of faces </TD> <TD><i> if true all the initial faces of the mesh are deleted and the whole surface is rebuilt from scratch, other wise the current faces are used as a starting point. Useful if you run multiple times the algorithm with an incrasing ball radius. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Delete initial set of faces </TD> <TD><i> if true all the initial faces of the mesh are deleted and the whole surface is rebuilt from scratch, other wise the current faces are used as a starting point. Useful if you run multiple times the algorithm with an incrasing ball radius. -- </i></TD> </TR>
</TABLE>
\section f5 Remove vertices wrt quality
@ -102,9 +102,9 @@ Align this mesh with another that has corresponding picked points.
<TR><TD> \c Float </TD> <TD> Minimal Starting Distance </TD> <TD><i> For all the chosen sample on one mesh we consider for ICP only the samples nearer than this value.If MSD is too large outliers could be included, if it is too small convergence will be very slow. A good guess is needed here, suggested values are in the range of 10-100 times of the device scanning error.This value is also dynamically changed by the 'Reduce Distance Factor' -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Target Distance </TD> <TD><i> When 50% of the chosen samples are below this distance we consider the two mesh aligned. Usually it should be a value lower than the error of the scanning device. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Max Iteration Num </TD> <TD><i> The maximum number of iteration that the ICP is allowed to perform. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Normal Equalized Sampling </TD> <TD><i> if true (default) the sample points of icp are choosen with a distribution uniform with respect to the normals of the surface. Otherwise they are distributed in a spatially uniform way. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Normal Equalized Sampling </TD> <TD><i> if true (default) the sample points of icp are chosen with a distribution uniform with respect to the normals of the surface. Otherwise they are distributed in a spatially uniform way. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> MSD Reduce Factor </TD> <TD><i> At each ICP iteration the Minimal Starting Distance is reduced to be 5 times the <Reduce Factor> percentile of the sample distances (e.g. if RF is 0.9 the new Minimal Starting Distance is 5 times the value <X> such that 90% of the sample lies at a distance lower than <X>. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Rigid matching </TD> <TD><i> If true the ICP is cosntrained to perform matching only throug roto-translations (no scaling allowed). If false a more relaxed transformation matrix is allowed (scaling and shearing can appear). -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Rigid matching </TD> <TD><i> If true the ICP is constrained to perform matching only through roto-translations (no scaling allowed). If false a more relaxed transformation matrix is allowed (scaling and shearing can appear). -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Use Markers for Alignment </TD> <TD><i> if true (default), then use the user picked markers to do an alignment (or pre alignment if you also use ICP). -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Scale the mesh </TD> <TD><i> if true (false by default), in addition to the alignment, scale the mesh based on the points picked -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Use ICP for Alignment </TD> <TD><i> if true (default), then use the ICP to align the two meshes. -- </i></TD> </TR>
@ -143,7 +143,7 @@ Removes t-vertices from the mesh by collapsing the shortest of the incident edge
\section f12 Remove Duplicate Faces
Remove all the duplicate faces. Two faces are considered equal if they are composed by the same set of verticies, regardless of the order of the vertices.
Remove all the duplicate faces. Two faces are considered equal if they are composed by the same set of vertices, regardless of the order of the vertices.
<H2> Parameters </h2>
No parameters.<br>
\section f13 Remove Isolated folded face by edge flip
@ -153,10 +153,10 @@ Remove all the single folded faces. A face is considered folded if its normal is
No parameters.<br>
\section f14 Merge Close Vertices
Merge togheter all the vertices that are nearer than the speicified threshold. Like a unify duplicated vertices but with some tolerance.
Merge together all the vertices that are nearer than the specified threshold. Like a unify duplicated vertices but with some tolerance.
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c AbsPerc </TD> <TD> Merging distance </TD> <TD><i> All the vertices that closer than this threshold are merged toghether. Use very small values, default values is 1/10000 of bounding box diagonal. -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Merging distance </TD> <TD><i> All the vertices that closer than this threshold are merged together. Use very small values, default values is 1/10000 of bounding box diagonal. -- </i></TD> </TR>
</TABLE>
\section f15 Clamp Vertex Quality
@ -167,7 +167,7 @@ Clamp vertex quality values to a given range according to specific values or to
<TR><TD> \c Float </TD> <TD> Min </TD> <TD><i> The value that will be mapped with the lower end of the scale (blue) -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Max </TD> <TD><i> The value that will be mapped with the upper end of the scale (red) -- </i></TD> </TR>
<TR><TD> \c DynamicFloat </TD> <TD> Percentile Crop [0..100] </TD> <TD><i> If not zero this value will be used for a percentile cropping of the quality values.<br> If this parameter is set to <i>P</i> the value <i>V</i> for which <i>P</i>% of the vertices have a quality <b>lower</b>(greater) than <i>V</i> is used as min (max) value.<br><br> The automated percentile cropping is very useful for automatically discarding outliers. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Zero Simmetric </TD> <TD><i> If true the min max range will be enlarged to be symmertic (so that green is always Zero) -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Zero Symmetric </TD> <TD><i> If true the min max range will be enlarged to be symmertic (so that green is always Zero) -- </i></TD> </TR>
</TABLE>
\section f16 Saturate Vertex Quality
@ -176,7 +176,7 @@ Saturate vertex quality, so that for each vertex the gradient of the quality is
The saturation is done in a conservative way (quality is always decreased and never increased)
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Float </TD> <TD> Gradient Threshold </TD> <TD><i> The maximum value admitted for the quality gradient (in absolute valu) -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Gradient Threshold </TD> <TD><i> The maximum value admitted for the quality gradient (in absolute value) -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Update ColorMap </TD> <TD><i> if true the color ramp is computed again -- </i></TD> </TR>
</TABLE>
@ -188,7 +188,7 @@ Color vertices depending on their quality field (manually equalized).
<TR><TD> \c Float </TD> <TD> Min </TD> <TD><i> The value that will be mapped with the lower end of the scale (blue) -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Max </TD> <TD><i> The value that will be mapped with the upper end of the scale (red) -- </i></TD> </TR>
<TR><TD> \c DynamicFloat </TD> <TD> Percentile Crop [0..100] </TD> <TD><i> If not zero this value will be used for a percentile cropping of the quality values.<br> If this parameter is set to <i>P</i> the value <i>V</i> for which <i>P</i>% of the vertices have a quality <b>lower</b>(greater) than <i>V</i> is used as min (max) value.<br><br> The automated percentile cropping is very useful for automatically discarding outliers. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Zero Simmetric </TD> <TD><i> If true the min max range will be enlarged to be symmertic (so that green is always Zero) -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Zero Symmetric </TD> <TD><i> If true the min max range will be enlarged to be symmertic (so that green is always Zero) -- </i></TD> </TR>
</TABLE>
\section f18 Colorize by face Quality
@ -199,7 +199,7 @@ Color faces depending on their quality field (manually equalized).
<TR><TD> \c Float </TD> <TD> Min </TD> <TD><i> The value that will be mapped with the lower end of the scale (blue) -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Max </TD> <TD><i> The value that will be mapped with the upper end of the scale (red) -- </i></TD> </TR>
<TR><TD> \c DynamicFloat </TD> <TD> Percentile Crop [0..100] </TD> <TD><i> If not zero this value will be used for a percentile cropping of the quality values.<br> If this parameter is set to <i>P</i> the value <i>V</i> for which <i>P</i>% of the vertices have a quality <b>lower</b>(greater) than <i>V</i> is used as min (max) value.<br><br> The automated percentile cropping is very useful for automatically discarding outliers. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Zero Simmetric </TD> <TD><i> If true the min max range will be enlarged to be symmertic (so that green is always Zero) -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Zero Symmetric </TD> <TD><i> If true the min max range will be enlarged to be symmertic (so that green is always Zero) -- </i></TD> </TR>
</TABLE>
\section f19 Discrete Curvatures
@ -256,7 +256,7 @@ Colorize Faces randomly. If internal edges are present they are used
No parameters.<br>
\section f27 Vertex Color Filling
Fills the color of the vertexes of the mesh with a color choosed by the user.
Fills the color of the vertexes of the mesh with a color chosen by the user.
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c DynamicFloat </TD> <TD> Red: </TD> <TD><i> Sets the red component of the color. -- </i></TD> </TR>
@ -416,71 +416,71 @@ Create a Cone
\section f47 Fractal Terrain
Generates a fractal terrain perturbation with five different algorithms.<br />
Some good parameter values to start with are:<br />
<table align="center">
<tr style="border:1px solid black">
<td></td>
<td align="center"> Seed </td>
<td align="center"> Octaves </td>
<td align="center"> Lacunarity </td>
<td align="center"> Fractal increment </td>
<td align="center"> Offset </td>
<td align="center"> Gain </td>
</tr>
<tr>
<td>fBM</td>
<td align="center">1</td>
<td align="center">10</td>
<td align="center">2</td>
<td align="center">1.2</td>
<td align="center">-</td>
<td align="center">-</td>
</tr>
<tr>
<td>Standard multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">2</td>
<td align="center">0.9</td>
<td align="center">0.9</td>
<td align="center">-</td>
</tr>
<tr>
<td>Heterogeneous multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">3</td>
<td align="center">0.9</td>
<td align="center">0.4</td>
<td align="center">-</td>
</tr>
<tr>
<td>Hybrid multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">4</td>
<td align="center">0.1</td>
<td align="center">0.3</td>
<td align="center">-</td>
</tr>
<tr>
<td>Ridged multifractal</td>
<td align="center">2</td>
<td align="center">8</td>
<td align="center">4</td>
<td align="center">0.5</td>
<td align="center">0.9</td>
<td align="center">2</td>
</tr>
</table>
<br /><br />
Detailed algorithms descriptions can be found in:<br /><br />
<span style="font-variant: small-caps;">Ebert, D.S., Musgrave, F.K., Peachey, D., Perlin, K., and Worley, S.</span><br />
Texturing and Modeling: A Procedural Approach.<br />
<i>Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2002.</i>
Generates a fractal terrain perturbation with five different algorithms.<br />
Some good parameter values to start with are:<br />
<table align="center">
<tr style="border:1px solid black">
<td></td>
<td align="center"> Seed </td>
<td align="center"> Octaves </td>
<td align="center"> Lacunarity </td>
<td align="center"> Fractal increment </td>
<td align="center"> Offset </td>
<td align="center"> Gain </td>
</tr>
<tr>
<td>fBM</td>
<td align="center">1</td>
<td align="center">10</td>
<td align="center">2</td>
<td align="center">1.2</td>
<td align="center">-</td>
<td align="center">-</td>
</tr>
<tr>
<td>Standard multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">2</td>
<td align="center">0.9</td>
<td align="center">0.9</td>
<td align="center">-</td>
</tr>
<tr>
<td>Heterogeneous multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">3</td>
<td align="center">0.9</td>
<td align="center">0.4</td>
<td align="center">-</td>
</tr>
<tr>
<td>Hybrid multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">4</td>
<td align="center">0.1</td>
<td align="center">0.3</td>
<td align="center">-</td>
</tr>
<tr>
<td>Ridged multifractal</td>
<td align="center">2</td>
<td align="center">8</td>
<td align="center">4</td>
<td align="center">0.5</td>
<td align="center">0.9</td>
<td align="center">2</td>
</tr>
</table>
<br /><br />
Detailed algorithms descriptions can be found in:<br /><br />
<span style="font-variant: small-caps;">Ebert, D.S., Musgrave, F.K., Peachey, D., Perlin, K., and Worley, S.</span><br />
Texturing and Modeling: A Procedural Approach.<br />
<i>Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2002.</i>
<H2> Parameters </h2>
<TABLE>
@ -500,71 +500,71 @@ Don't change the seed if you want to refine the current terrain morphology by ch
\section f48 Fractal Displacement
Generates a fractal terrain perturbation with five different algorithms.<br />
Some good parameter values to start with are:<br />
<table align="center">
<tr style="border:1px solid black">
<td></td>
<td align="center"> Seed </td>
<td align="center"> Octaves </td>
<td align="center"> Lacunarity </td>
<td align="center"> Fractal increment </td>
<td align="center"> Offset </td>
<td align="center"> Gain </td>
</tr>
<tr>
<td>fBM</td>
<td align="center">1</td>
<td align="center">10</td>
<td align="center">2</td>
<td align="center">1.2</td>
<td align="center">-</td>
<td align="center">-</td>
</tr>
<tr>
<td>Standard multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">2</td>
<td align="center">0.9</td>
<td align="center">0.9</td>
<td align="center">-</td>
</tr>
<tr>
<td>Heterogeneous multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">3</td>
<td align="center">0.9</td>
<td align="center">0.4</td>
<td align="center">-</td>
</tr>
<tr>
<td>Hybrid multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">4</td>
<td align="center">0.1</td>
<td align="center">0.3</td>
<td align="center">-</td>
</tr>
<tr>
<td>Ridged multifractal</td>
<td align="center">2</td>
<td align="center">8</td>
<td align="center">4</td>
<td align="center">0.5</td>
<td align="center">0.9</td>
<td align="center">2</td>
</tr>
</table>
<br /><br />
Detailed algorithms descriptions can be found in:<br /><br />
<span style="font-variant: small-caps;">Ebert, D.S., Musgrave, F.K., Peachey, D., Perlin, K., and Worley, S.</span><br />
Texturing and Modeling: A Procedural Approach.<br />
<i>Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2002.</i>
Generates a fractal terrain perturbation with five different algorithms.<br />
Some good parameter values to start with are:<br />
<table align="center">
<tr style="border:1px solid black">
<td></td>
<td align="center"> Seed </td>
<td align="center"> Octaves </td>
<td align="center"> Lacunarity </td>
<td align="center"> Fractal increment </td>
<td align="center"> Offset </td>
<td align="center"> Gain </td>
</tr>
<tr>
<td>fBM</td>
<td align="center">1</td>
<td align="center">10</td>
<td align="center">2</td>
<td align="center">1.2</td>
<td align="center">-</td>
<td align="center">-</td>
</tr>
<tr>
<td>Standard multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">2</td>
<td align="center">0.9</td>
<td align="center">0.9</td>
<td align="center">-</td>
</tr>
<tr>
<td>Heterogeneous multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">3</td>
<td align="center">0.9</td>
<td align="center">0.4</td>
<td align="center">-</td>
</tr>
<tr>
<td>Hybrid multifractal</td>
<td align="center">1</td>
<td align="center">8</td>
<td align="center">4</td>
<td align="center">0.1</td>
<td align="center">0.3</td>
<td align="center">-</td>
</tr>
<tr>
<td>Ridged multifractal</td>
<td align="center">2</td>
<td align="center">8</td>
<td align="center">4</td>
<td align="center">0.5</td>
<td align="center">0.9</td>
<td align="center">2</td>
</tr>
</table>
<br /><br />
Detailed algorithms descriptions can be found in:<br /><br />
<span style="font-variant: small-caps;">Ebert, D.S., Musgrave, F.K., Peachey, D., Perlin, K., and Worley, S.</span><br />
Texturing and Modeling: A Procedural Approach.<br />
<i>Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2002.</i>
<br /><br />Hint: search a good compromise between offset and height factor parameter.
<H2> Parameters </h2>
<TABLE>
@ -584,18 +584,18 @@ Don't change the seed if you want to refine the current terrain morphology by ch
\section f49 Craters Generation
Generates craters onto a mesh using radial functions.<br />
There must be at least two layers to apply this filter:<br />
<ul>
<li>the layer that contains the target mesh; we assume that this mesh is sufficiently refined;</li>
<li>the layer that contains the samples which represent the central points of craters.</li>
</ul>
There are three radial functions available to generate craters, two of which are Gaussian and Multiquadric,
and the third is a variant of multiquadric. Blending functions are also provided to blend
the crater elevation towards the mesh surface.
If you want the preview to work, be sure to select the target mesh layer before launching the
filter. You can select this layer by clicking on it in the layer dialog.
Generates craters onto a mesh using radial functions.<br />
There must be at least two layers to apply this filter:<br />
<ul>
<li>the layer that contains the target mesh; we assume that this mesh is sufficiently refined;</li>
<li>the layer that contains the samples which represent the central points of craters.</li>
</ul>
There are three radial functions available to generate craters, two of which are Gaussian and Multiquadric,
and the third is a variant of multiquadric. Blending functions are also provided to blend
the crater elevation towards the mesh surface.
If you want the preview to work, be sure to select the target mesh layer before launching the
filter. You can select this layer by clicking on it in the layer dialog.
<H2> Parameters </h2>
<TABLE>
@ -619,7 +619,7 @@ filter. You can select this layer by clicking on it in the layer dialog.
\section f50 Conditional Vertex Selection
Boolean function using muparser lib to perform vertex selection over current mesh.<br>It's possibile to use parenthesis, per-vertex variables and boolean operator:<br><b>(</b>,<b>)</b>,<b>and</b>,<b>or</b>,<b><</b><b>></b>,<b>=</b><br>It's possibile to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
Boolean function using muparser lib to perform vertex selection over current mesh.<br>It's possible to use parenthesis, per-vertex variables and boolean operator:<br><b>(</b>,<b>)</b>,<b>and</b>,<b>or</b>,<b><</b><b>></b>,<b>=</b><br>It's possible to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c String </TD> <TD> boolean function </TD> <TD><i> type a boolean function that will be evaluated in order to select a subset of vertices<br>example: (y > 0) and (ny > 0) -- </i></TD> </TR>
@ -628,7 +628,7 @@ Boolean function using muparser lib to perform vertex selection over current mes
\section f51 Conditional Face Selection
Boolean function using muparser lib to perform faces selection over current mesh.<br>It's possibile to use parenthesis, per-vertex variables and boolean operator:<br><b>(</b>,<b>)</b>,<b>and</b>,<b>or</b>,<b><</b><b>></b>,<b>=</b><br>It's possibile to use per-face variables like attributes associated to the three vertex of every face.<br><b>x0,y0,z0</b> for <b>first vertex</b>; x1,y1,z1 for second vertex; x2,y2,z2 for third vertex.<br>and also <b>nx0,ny0,nz0</b> nx1,ny1,nz1 etc. for <b>normals</b> and <b>r0,g0,b0</b> for <b>color</b>,<b>q0,q1,q2</b> for <b>quality</b>.<br>
Boolean function using muparser lib to perform faces selection over current mesh.<br>It's possible to use parenthesis, per-vertex variables and boolean operator:<br><b>(</b>,<b>)</b>,<b>and</b>,<b>or</b>,<b><</b><b>></b>,<b>=</b><br>It's possible to use per-face variables like attributes associated to the three vertex of every face.<br><b>x0,y0,z0</b> for <b>first vertex</b>; x1,y1,z1 for second vertex; x2,y2,z2 for third vertex.<br>and also <b>nx0,ny0,nz0</b> nx1,ny1,nz1 etc. for <b>normals</b> and <b>r0,g0,b0</b> for <b>color</b>,<b>q0,q1,q2</b> for <b>quality</b>.<br>
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c String </TD> <TD> boolean function </TD> <TD><i> type a boolean function that will be evaluated in order to select a subset of faces<br> -- </i></TD> </TR>
@ -636,7 +636,7 @@ Boolean function using muparser lib to perform faces selection over current mesh
\section f52 Geometric Function
Geometric function using muparser lib to generate new Coord<br>You can change x,y,z for every vertex according to the function specified.<br>It's possibile to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
Geometric function using muparser lib to generate new Coord<br>You can change x,y,z for every vertex according to the function specified.<br>It's possible to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c String </TD> <TD> func x = </TD> <TD><i> insert function to generate new coord for x -- </i></TD> </TR>
@ -646,7 +646,7 @@ Geometric function using muparser lib to generate new Coord<br>You can change x,
\section f53 Per Face Color Function
Color function using muparser lib to generate new RGB color for every face<br>Insert three function each one for red, green and blue channel respectively.<br>It's possibile to use per-face variables like attributes associated to the three vertex of every face.<br><b>x0,y0,z0</b> for <b>first vertex</b>; x1,y1,z1 for second vertex; x2,y2,z2 for third vertex.<br>and also <b>nx0,ny0,nz0</b> nx1,ny1,nz1 etc. for <b>normals</b> and <b>r0,g0,b0</b> for <b>color</b>,<b>q0,q1,q2</b> for <b>quality</b>.<br>
Color function using muparser lib to generate new RGB color for every face<br>Insert three function each one for red, green and blue channel respectively.<br>It's possible to use per-face variables like attributes associated to the three vertex of every face.<br><b>x0,y0,z0</b> for <b>first vertex</b>; x1,y1,z1 for second vertex; x2,y2,z2 for third vertex.<br>and also <b>nx0,ny0,nz0</b> nx1,ny1,nz1 etc. for <b>normals</b> and <b>r0,g0,b0</b> for <b>color</b>,<b>q0,q1,q2</b> for <b>quality</b>.<br>
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c String </TD> <TD> func r = </TD> <TD><i> function to generate Red component. Expected Range 0-255 -- </i></TD> </TR>
@ -656,7 +656,7 @@ Color function using muparser lib to generate new RGB color for every face<br>In
\section f54 Per Vertex Color Function
Color function using muparser lib to generate new RGB color for every vertex<br>Insert three function each one for red, green and blue channel respectively.<br>It's possibile to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
Color function using muparser lib to generate new RGB color for every vertex<br>Insert three function each one for red, green and blue channel respectively.<br>It's possible to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c String </TD> <TD> func r = </TD> <TD><i> function to generate Red component. Expected Range 0-255 -- </i></TD> </TR>
@ -666,7 +666,7 @@ Color function using muparser lib to generate new RGB color for every vertex<br>
\section f55 Per Vertex Quality Function
Quality function using muparser to generate new Quality for every vertex<br>It's possibile to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
Quality function using muparser to generate new Quality for every vertex<br>It's possible to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c String </TD> <TD> func q = </TD> <TD><i> function to generate new Quality for every vertex -- </i></TD> </TR>
@ -676,7 +676,7 @@ Quality function using muparser to generate new Quality for every vertex<br>It's
\section f56 Per Face Quality Function
Quality function using muparser to generate new Quality for every face<br>Insert three function each one for quality of the three vertex of a face<br>It's possibile to use per-face variables like attributes associated to the three vertex of every face.<br><b>x0,y0,z0</b> for <b>first vertex</b>; x1,y1,z1 for second vertex; x2,y2,z2 for third vertex.<br>and also <b>nx0,ny0,nz0</b> nx1,ny1,nz1 etc. for <b>normals</b> and <b>r0,g0,b0</b> for <b>color</b>,<b>q0,q1,q2</b> for <b>quality</b>.<br>
Quality function using muparser to generate new Quality for every face<br>Insert three function each one for quality of the three vertex of a face<br>It's possible to use per-face variables like attributes associated to the three vertex of every face.<br><b>x0,y0,z0</b> for <b>first vertex</b>; x1,y1,z1 for second vertex; x2,y2,z2 for third vertex.<br>and also <b>nx0,ny0,nz0</b> nx1,ny1,nz1 etc. for <b>normals</b> and <b>r0,g0,b0</b> for <b>color</b>,<b>q0,q1,q2</b> for <b>quality</b>.<br>
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c String </TD> <TD> func q0 = </TD> <TD><i> function to generate new Quality foreach face -- </i></TD> </TR>
@ -686,7 +686,7 @@ Quality function using muparser to generate new Quality for every face<br>Insert
\section f57 Define New Per Vertex Attribute
Add a new Per-Vertex scalar attribute to current mesh and fill it with the defined function.<br>The name specified below can be used in other filter functionIt's possibile to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
Add a new Per-Vertex scalar attribute to current mesh and fill it with the defined function.<br>The name specified below can be used in other filter functionIt's possible to use the following per-vertex variables in the expression:<br>x, y, z, nx, ny, nz (normal), r, g, b (color), q (quality), rad, vi, <br>and all custom <i>vertex attributes</i> already defined by user.<br>
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c String </TD> <TD> Name </TD> <TD><i> the name of new attribute. you can access attribute in other filters through this name -- </i></TD> </TR>
@ -748,7 +748,7 @@ The filter build the abstract Isoparameterization of a two-manifold triangular m
<TR><TD> \c Int </TD> <TD> Abstract Min Mesh Size </TD> <TD><i> This number and the following one indicate the range face number of the abstract mesh that is used for the parametrization process.<br>The algorithm will choose the best abstract mesh with the number of triangles within the specified interval.<br>If the mesh has a very simple structure this range can be very low and strict;for a roughly spherical object if you can specify a range of [8,8] faces you get a octahedral abstract mesh, e.g. a geometry image.<br>Large numbers (greater than 400) are usually not of practical use. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Abstract Max Mesh Size </TD> <TD><i> See above. -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Optimization Criteria </TD> <TD><i> Choose a metric to stop the parametrization within the interval<br>1: Best Heuristic : stop considering both isometry and number of faces of base domain<br>2: Area + Angle : stop at minimum area and angle distorsion<br>3: Regularity : stop at minimum number of irregular vertices<br>4: L2 : stop at minimum OneWay L2 Stretch Eff -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Convergence Precision </TD> <TD><i> This parameter controls the convergence speed/precision of the optimization of the texture coordinates. Larger the number slower the processing and ,eventually, slighly better results -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Convergence Precision </TD> <TD><i> This parameter controls the convergence speed/precision of the optimization of the texture coordinates. Larger the number slower the processing and, eventually, slightly better results -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Double Step </TD> <TD><i> Use this bool to divide the parameterization in 2 steps. Double step makes the overall process faster and robust, but it may increase the distorsion -- </i></TD> </TR>
</TABLE>
@ -765,7 +765,7 @@ Remeshing based on an Abstract Isoparameterization, each triangle of the domain
The filter build a new mesh with a standard atlased per wedge texture. The atlas is simply done by splitting each triangle of the abstract domain<br>For more details see: <br>Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>IEEE Transaction of Visualization and Computer Graphics 2010
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c DynamicFloat </TD> <TD> BorderSize ratio </TD> <TD><i> This parameter controls the amount of space that must be left between each diamond when building the atlas.It directly affects how many triangle are splitted during this conversion. <br>In abstract parametrization mesh triangles can naturally cross the triangles of the abstract domain, so when converting to a standard parametrization we must cut all the triangles that protrudes outside each diamond more than the specified threshold.The unit of the threshold is in percentage of the size of the diamond,The bigger the threshold the less triangles are splitted, but the more UV space is used (wasted). -- </i></TD> </TR>
<TR><TD> \c DynamicFloat </TD> <TD> BorderSize ratio </TD> <TD><i> This parameter controls the amount of space that must be left between each diamond when building the atlas.It directly affects how many triangle are split during this conversion. <br>In abstract parametrization mesh triangles can naturally cross the triangles of the abstract domain, so when converting to a standard parametrization we must cut all the triangles that protrudes outside each diamond more than the specified threshold.The unit of the threshold is in percentage of the size of the diamond,The bigger the threshold the less triangles are split, but the more UV space is used (wasted). -- </i></TD> </TR>
</TABLE>
\section f65 Iso Parametrization Load Abstract Domain
@ -881,7 +881,7 @@ Removes null faces (the one with area equal to zero)
No parameters.<br>
\section f81 Select Faces with edges longer than...
Select all triangles having an edge with lenght greater or equal than a given threshold
Select all triangles having an edge with length greater or equal than a given threshold
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c DynamicFloat </TD> <TD> Edge Threshold </TD> <TD><i> All the faces with an edge <b>longer</b> than this threshold will be deleted. Useful for removing long skinny faces obtained by bad triangulation of range maps. -- </i></TD> </TR>
@ -944,7 +944,7 @@ If disabled edges are collapsed onto one of the two original vertices and the fi
\section f85 Subdivision Surfaces: Midpoint
Apply a plain subdivision scheme where every edge is splitted on its midpoint
Apply a plain subdivision scheme where every edge is split on its midpoint
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Int </TD> <TD> Iterations </TD> <TD><i> Number of time the model is subdivided. -- </i></TD> </TR>
@ -978,8 +978,8 @@ Generate a matrix transformation that rotates the mesh. The mesh can be rotated
<TABLE>
<TR><TD> \c Enum </TD> <TD> Rotation on: </TD> <TD><i> Choose a method -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Center of rotation: </TD> <TD><i> Choose a method -- </i></TD> </TR>
<TR><TD> \c DynamicFloat </TD> <TD> Rotation Angle </TD> <TD><i> Angle of rotation (in <b>degree</b>). If snapping is enable this vaule is rounded according to the snap value -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Snap angle </TD> <TD><i> If selected, before starting the filter will remove anyy unreference vertex (for which curvature values are not defined) -- </i></TD> </TR>
<TR><TD> \c DynamicFloat </TD> <TD> Rotation Angle </TD> <TD><i> Angle of rotation (in <b>degree</b>). If snapping is enable this value is rounded according to the snap value -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Snap angle </TD> <TD><i> If selected, before starting the filter will remove any unreference vertex (for which curvature values are not defined) -- </i></TD> </TR>
<TR><TD> \c Point3f </TD> <TD> Custom axis </TD> <TD><i> This rotation axis is used only if the 'custom axis' option is chosen. -- </i></TD> </TR>
<TR><TD> \c Point3f </TD> <TD> Custom center </TD> <TD><i> This rotation center is used only if the 'custom point' option is chosen. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Snapping Value </TD> <TD><i> This value is used to snap the rotation angle. -- </i></TD> </TR>
@ -1010,7 +1010,7 @@ Generate a matrix transformation that scale the mesh. The mesh can be also autom
<TR><TD> \c Bool </TD> <TD> Uniform Scaling </TD> <TD><i> If selected an uniform scaling (the same for all the three axis) is applied (the X axis value is used) -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Center of rotation: </TD> <TD><i> Choose a method -- </i></TD> </TR>
<TR><TD> \c Point3f </TD> <TD> Custom center </TD> <TD><i> This rotation center is used only if the 'custom point' option is chosen. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Scale to Unit bbox </TD> <TD><i> If selected, the object is scaled to a box whose sides are at most 1 unit lenght -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Scale to Unit bbox </TD> <TD><i> If selected, the object is scaled to a box whose sides are at most 1 unit length -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Freeze Matrix </TD> <TD><i> The transformation is explicitly applied and the vertex coords are actually changed -- </i></TD> </TR>
</TABLE>
@ -1022,7 +1022,7 @@ Generate a matrix transformation that translate the mesh. The mesh can be transl
<TR><TD> \c DynamicFloat </TD> <TD> X Axis </TD> <TD><i> Absolute translation amount along the X axis -- </i></TD> </TR>
<TR><TD> \c DynamicFloat </TD> <TD> Y Axis </TD> <TD><i> Absolute translation amount along the Y axis -- </i></TD> </TR>
<TR><TD> \c DynamicFloat </TD> <TD> Z Axis </TD> <TD><i> Absolute translation amount along the Z axis -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> translate center of bbox to the origin </TD> <TD><i> If selected, the object is scaled to a box whose sides are at most 1 unit lenght -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> translate center of bbox to the origin </TD> <TD><i> If selected, the object is scaled to a box whose sides are at most 1 unit length -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Freeze Matrix </TD> <TD><i> The transformation is explicitly applied and the vertex coords are actually changed -- </i></TD> </TR>
</TABLE>
@ -1036,7 +1036,7 @@ No parameters.<br>
Compute the normals of the vertices of a mesh without exploiting the triangle connectivity, useful for dataset with no faces
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Int </TD> <TD> Number of neigbors </TD> <TD><i> The number of neighbors used to estimate and propagate normals. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Number of neighbors </TD> <TD><i> The number of neighbors used to estimate and propagate normals. -- </i></TD> </TR>
</TABLE>
\section f95 Compute curvature principal directions
@ -1045,7 +1045,7 @@ Compute the principal directions of curvature with several algorithms
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Enum </TD> <TD> Method: </TD> <TD><i> Choose a method -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Remove Unreferenced Vertices </TD> <TD><i> If selected, before starting the filter will remove anyy unreference vertex (for which curvature values are not defined) -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Remove Unreferenced Vertices </TD> <TD><i> If selected, before starting the filter will remove any unreference vertex (for which curvature values are not defined) -- </i></TD> </TR>
</TABLE>
\section f96 Close Holes
@ -1158,7 +1158,7 @@ It is relative to the radius (local point spacing) of the vertices. -- </i></TD>
<TR><TD> \c Float </TD> <TD> Projection - Accuracy (adv) </TD> <TD><i> Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Projection - Max iterations (adv) </TD> <TD><i> Max number of iterations for the projection. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> MLS - Spherical parameter </TD> <TD><i> Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while others real values might give interresting results, but take care with extremesettings ! -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> MLS - Spherical parameter </TD> <TD><i> Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while others real values might give interesting results, but take care with extremesettings ! -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Accurate normals </TD> <TD><i> If checked, use the accurate MLS gradient instead of the local approximationto compute the normals. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Refinement - Max subdivisions </TD> <TD><i> Max number of subdivisions. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Refinement - Crease angle (degree) </TD> <TD><i> Threshold angle between two faces controlling the refinement. -- </i></TD> </TR>
@ -1189,7 +1189,7 @@ It is relative to the radius (local point spacing) of the vertices. -- </i></TD>
<TR><TD> \c Float </TD> <TD> Projection - Accuracy (adv) </TD> <TD><i> Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Projection - Max iterations (adv) </TD> <TD><i> Max number of iterations for the projection. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> MLS - Spherical parameter </TD> <TD><i> Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while others real values might give interresting results, but take care with extremesettings ! -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> MLS - Spherical parameter </TD> <TD><i> Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while others real values might give interesting results, but take care with extremesettings ! -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Accurate normals </TD> <TD><i> If checked, use the accurate MLS gradient instead of the local approximationto compute the normals. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Grid Resolution </TD> <TD><i> The resolution of the grid on which we run the marching cubes.This marching cube is memory friendly, so you can safely set large values up to 1000 or even more. -- </i></TD> </TR>
</TABLE>
@ -1221,7 +1221,7 @@ It is relative to the radius (local point spacing) of the vertices. -- </i></TD>
<TR><TD> \c Float </TD> <TD> Projection - Accuracy (adv) </TD> <TD><i> Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Projection - Max iterations (adv) </TD> <TD><i> Max number of iterations for the projection. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> MLS - Spherical parameter </TD> <TD><i> Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while others real values might give interresting results, but take care with extremesettings ! -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> MLS - Spherical parameter </TD> <TD><i> Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while others real values might give interesting results, but take care with extremesettings ! -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Curvature type </TD> <TD><i> The type of the curvature to plot.<br>ApproxMean uses the radius of the fitted sphere as an approximation of the mean curvature. -- </i></TD> </TR>
</TABLE>
@ -1259,7 +1259,7 @@ The surface reconstrction algorithm that have been used for a long time inside t
\section f115 Simplfication: MC Edge Collapse
A simplification/cleaning algoritm tailored for meshes generated by Marching Cubes algorithm.
A simplification/cleaning algorithm tailored for meshes generated by Marching Cubes algorithm.
<H2> Parameters </h2>
No parameters.<br>
\section f116 Surface Reconstruction: Poisson
@ -1315,7 +1315,7 @@ Calculate the <b>Alpha Shape</b> of the mesh(Edelsbrunner and P.Mucke 1994) with
\section f121 Select Visible Points
Select the <b>visible points</b> in a point cloud, as viewed from a given viewpoint.<br>It uses the Qhull library (http://www.qhull.org/ <br><br>The algorithm used (Katz, Tal and Basri 2007) determines visibility without reconstructing a surface or estimating normals.A point is considered visible if its transformed point lies on the convex hull of a trasformed points cloud from the original mesh points.
Select the <b>visible points</b> in a point cloud, as viewed from a given viewpoint.<br>It uses the Qhull library (http://www.qhull.org/ <br><br>The algorithm used (Katz, Tal and Basri 2007) determines visibility without reconstructing a surface or estimating normals.A point is considered visible if its transformed point lies on the convex hull of a transformed points cloud from the original mesh points.
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c DynamicFloat </TD> <TD> radius threshold </TD> <TD><i> Bounds the radius of the sphere used to select visible points.It is used to adjust the radius of the sphere (calculated as distance between the center and the farthest point from it) according to the following equation: <br>radius = radius * pow(10,threshold); <br>As the radius increases more points are marked as visible.Use a big threshold for dense point clouds, a small one for sparse clouds. -- </i></TD> </TR>
@ -1332,8 +1332,8 @@ Select the <b>visible points</b> in a point cloud, as viewed from a given viewpo
The filter maps quality levels into colors using a colorband built from a transfer function (may be loaded from an external file) and colorizes the mesh vertexes. The minimum, medium and maximum quality values can be set by user to obtain a custom quality range for mapping
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Float </TD> <TD> Minimum mesh quality </TD> <TD><i> The specified quality value is mapped in the <b>lower</b> end of the choosen color scale. Default value: the minumum quality value found on the mesh. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Maximum mesh quality </TD> <TD><i> The specified quality value is mapped in the <b>upper</b> end of the choosen color scale. Default value: the maximum quality value found on the mesh. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Minimum mesh quality </TD> <TD><i> The specified quality value is mapped in the <b>lower</b> end of the chosen color scale. Default value: the minimum quality value found on the mesh. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Maximum mesh quality </TD> <TD><i> The specified quality value is mapped in the <b>upper</b> end of the chosen color scale. Default value: the maximum quality value found on the mesh. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Gamma biasing (0..100) </TD> <TD><i> Defines a gamma compression of the quality values, by setting the position of the middle of the color scale. Value is defined as a percentage (0..100). Default value is 50, that corresponds to a linear mapping. -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Mesh brightness </TD> <TD><i> must be between 0 and 2. 0 represents a completely dark mesh, 1 represents a mesh colorized with original colors, 2 represents a completely bright mesh -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Transfer Function type to apply to filter </TD> <TD><i> Choose the Transfer Function to apply to the filter -- </i></TD> </TR>
@ -1342,7 +1342,7 @@ The filter maps quality levels into colors using a colorband built from a transf
\section f123 Mesh Element Subsampling
Create a new layer populated with a point sampling of the current mesh, At most one sample for each element of the mesh is created. Samples are taking in a uniform way, one for each element (vertex/edge/face); all the elements have the same probabilty of being choosen.
Create a new layer populated with a point sampling of the current mesh, At most one sample for each element of the mesh is created. Samples are taking in a uniform way, one for each element (vertex/edge/face); all the elements have the same probability of being chosen.
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Enum </TD> <TD> Element to sample: </TD> <TD><i> Choose what mesh element has to be used for the subsampling. At most one point sample will be added for each one of the chosen elements -- </i></TD> </TR>
@ -1354,7 +1354,7 @@ Create a new layer populated with a point sampling of the current mesh, At most
Create a new layer populated with a point sampling of the current mesh; samples are generated in a randomly uniform way, or with a distribution biased by the per-vertex quality values of the mesh.
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Int </TD> <TD> Number of samples </TD> <TD><i> The desired number of samples. It can be smaller or larger than the mesh size, and according to the choosed sampling strategy it will try to adapt. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Number of samples </TD> <TD><i> The desired number of samples. It can be smaller or larger than the mesh size, and according to the chosen sampling strategy it will try to adapt. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Quality Weighted Sampling </TD> <TD><i> Use per vertex quality to drive the vertex sampling. The number of samples falling in each face is proportional to the face area multiplied by the average quality of the face vertices. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Exact Sample Num </TD> <TD><i> If the required total number of samples is not a strict exact requirement we can exploit a different algorithmbased on the choice of the number of samples inside each triangle by a random Poisson-distributed number with mean equal to the expected number of samples times the area of the triangle over the surface of the whole mesh. -- </i></TD> </TR>
</TABLE>
@ -1364,7 +1364,7 @@ Create a new layer populated with a point sampling of the current mesh; samples
Create a new layer populated with a point sampling of the current mesh; to generate multiple samples inside a triangle each triangle is subdivided according to various <i> stratified</i> strategies. Distribution is often biased by triangle shape.
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Int </TD> <TD> Number of samples </TD> <TD><i> The desired number of samples. It can be smaller or larger than the mesh size, and according to the choosed sampling strategy it will try to adapt. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Number of samples </TD> <TD><i> The desired number of samples. It can be smaller or larger than the mesh size, and according to the chosen sampling strategy it will try to adapt. -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Element to sample: </TD> <TD><i> <b>Similar Triangle</b>: each triangle is subdivided into similar triangles and the internal vertices of these triangles are considered. This sampling leave space around edges and vertices for separate sampling of these entities.<br><b>Dual Similar Triangle</b>: each triangle is subdivided into similar triangles and the internal vertices of these triangles are considered. <br><b>Long Edge Subdiv</b> each triangle is recursively subdivided along the longest edge. <br><b>Sample Edges</b> Only the edges of the mesh are uniformly sampled. <br><b>Sample NonFaux Edges</b> Only the non-faux edges of the mesh are uniformly sampled. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Random Sampling </TD> <TD><i> if true, for each (virtual) face we draw a random point, otherwise we pick the face midpoint. -- </i></TD> </TR>
</TABLE>
@ -1375,7 +1375,7 @@ Create a new layer populated with a subsampling of the vertexes of the current
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c AbsPerc </TD> <TD> Cell Size </TD> <TD><i> The size of the cell of the clustering grid. Smaller the cell finer the resulting mesh. For obtaining a very coarse mesh use larger values. -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Representative Strataegy: </TD> <TD><i> <b>Average</b>: for each cell we take the average of the sample falling into. The resulting point is a new point.<br><b>Closes to center</b>: for each cell we take the sample that is closest to the center of the cell. Choosen vertices are a subset of the original ones. -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Representative Strataegy: </TD> <TD><i> <b>Average</b>: for each cell we take the average of the sample falling into. The resulting point is a new point.<br><b>Closes to center</b>: for each cell we take the sample that is closest to the center of the cell. Chosen vertices are a subset of the original ones. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Selected </TD> <TD><i> If true only for the filter is applied only on the selected subset of the mesh. -- </i></TD> </TR>
</TABLE>
@ -1386,7 +1386,7 @@ Create a new layer populated with a point sampling of the current mesh; samples
<TABLE>
<TR><TD> \c Int </TD> <TD> Number of samples </TD> <TD><i> The desired number of samples. The ray of the disk is calculated according to the sampling density. -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Explicit Radius </TD> <TD><i> If not zero this parameter override the previous parameter to allow exact radius specification -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> MonterCarlo OverSampling </TD> <TD><i> The over-sampling rate that is used to generate the intial Montecarlo samples (e.g. if this parameter is <i>K</i> means that<i>K</i> x <i>poisson sample</i> points will be used). The generated Poisson-disk samples are a subset of these initial Montecarlo samples. Larger this number slows the process but make it a bit more accurate. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> MonterCarlo OverSampling </TD> <TD><i> The over-sampling rate that is used to generate the initial Montecarlo samples (e.g. if this parameter is <i>K</i> means that<i>K</i> x <i>poisson sample</i> points will be used). The generated Poisson-disk samples are a subset of these initial Montecarlo samples. Larger this number slows the process but make it a bit more accurate. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Base Mesh Subsampling </TD> <TD><i> If true the original vertices of the base mesh are used as base set of points. In this case the SampleNum should be obviously much smaller than the original vertex number.<br>Note that this option is very useful in the case you want to subsample a dense point cloud. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Refine Existing Samples </TD> <TD><i> If true the vertices of the below mesh are used as starting vertices, and they will utterly refined by adding more and more points until possible. -- </i></TD> </TR>
<TR><TD> \c Mesh </TD> <TD> Samples to be refined </TD> <TD><i> Used only if the above option is checked. -- </i></TD> </TR>
@ -1400,7 +1400,7 @@ Create a new layer populated with a point sampling of the current mesh; samples
<TR><TD> \c Int </TD> <TD> Number of samples </TD> <TD><i> The desired number of samples. The ray of the disk is calculated according to the sampling density. -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Explicit Radius </TD> <TD><i> If not zero this parameter override the previous parameter to allow exact radius specification -- </i></TD> </TR>
<TR><TD> \c Float </TD> <TD> Radius Variance </TD> <TD><i> The radius of the disk is allowed to vary between r/var and r*var. If this parameter is 1 the sampling is the same of the Poisson Disk Sampling -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> MonterCarlo OverSampling </TD> <TD><i> The over-sampling rate that is used to generate the intial Montecarlo samples (e.g. if this parameter is x means that x * <i>poisson sample</i> points will be used). The generated Poisson-disk samples are a subset of these initial Montecarlo samples. Larger this number slows the process but make it a bit more accurate. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> MonterCarlo OverSampling </TD> <TD><i> The over-sampling rate that is used to generate the initial Montecarlo samples (e.g. if this parameter is x means that x * <i>poisson sample</i> points will be used). The generated Poisson-disk samples are a subset of these initial Montecarlo samples. Larger this number slows the process but make it a bit more accurate. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Base Mesh Subsampling </TD> <TD><i> If true the original vertices of the base mesh are used as base set of points. In this case the SampleNum should be obviously much smaller than the original vertex number. -- </i></TD> </TR>
</TABLE>
@ -1416,8 +1416,8 @@ Compute the Hausdorff Distance between two meshes, sampling one of the two and f
<TR><TD> \c Bool </TD> <TD> Sample Edges </TD> <TD><i> See the above comment. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Sample FauxEdge </TD> <TD><i> See the above comment. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Sample Faces </TD> <TD><i> See the above comment. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Number of samples </TD> <TD><i> The desired number of samples. It can be smaller or larger than the mesh size, and according to the choosed sampling strategy it will try to adapt. -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Max Distance </TD> <TD><i> Sample points for which we do not find anything whithin this distance are rejected and not considered neither for averaging nor for max. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Number of samples </TD> <TD><i> The desired number of samples. It can be smaller or larger than the mesh size, and according to the chosen sampling strategy it will try to adapt. -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Max Distance </TD> <TD><i> Sample points for which we do not find anything within this distance are rejected and not considered neither for averaging nor for max. -- </i></TD> </TR>
</TABLE>
\section f130 Texel Sampling
@ -1426,7 +1426,7 @@ Create a new layer with a point sampling of the current mesh, a sample for each
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Int </TD> <TD> Texture Width </TD> <TD><i> A sample for each texel is generated, so the desired texture size is need, only samples for the texels falling inside some faces are generated.
Setting this param to 256 means that you get at most 256x256 = 65536 samples).<br>If this parameter is 0 the size of the current texture is choosen. -- </i></TD> </TR>
Setting this param to 256 means that you get at most 256x256 = 65536 samples).<br>If this parameter is 0 the size of the current texture is chosen. -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Texture Height </TD> <TD><i> A sample for each texel is generated, so the desired texture size is need, only samples for the texels falling inside some faces are generated.
Setting this param to 256 means that you get at most 256x256 = 65536 samples) -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> UV Space Sampling </TD> <TD><i> The generated texel samples have their UV coords as point positions. The resulting point set is has a square domain, the texels/points, even if on a flat domain retain the original vertex normal to help a better perception of the original provenience. -- </i></TD> </TR>
@ -1435,7 +1435,7 @@ Create a new layer with a point sampling of the current mesh, a sample for each
\section f131 Vertex Attribute Transfer
Transfer the choosen per-vertex attributes from one mesh to another. Useful to transfer attributes to different representations of a same object.<br>For each vertex of the target mesh the closest point (not vertex!) on the source mesh is computed, and the requested interpolated attributes from that source point are copied into the target vertex.<br>The algorithm assumes that the two meshes are reasonably similar and aligned.
Transfer the chosen per-vertex attributes from one mesh to another. Useful to transfer attributes to different representations of a same object.<br>For each vertex of the target mesh the closest point (not vertex!) on the source mesh is computed, and the requested interpolated attributes from that source point are copied into the target vertex.<br>The algorithm assumes that the two meshes are reasonably similar and aligned.
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Mesh </TD> <TD> Source Mesh </TD> <TD><i> The mesh that contains the source data that we want to transfer. -- </i></TD> </TR>
@ -1445,7 +1445,7 @@ Transfer the choosen per-vertex attributes from one mesh to another. Useful to t
<TR><TD> \c Bool </TD> <TD> Transfer Color </TD> <TD><i> if enabled, the color of each vertex of the target mesh will become the color of the corresponding closest point on the source mesh -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Transfer quality </TD> <TD><i> if enabled, the quality of each vertex of the target mesh will become the quality of the corresponding closest point on the source mesh -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Store dist. as quality </TD> <TD><i> if enabled, we store the distance of the transferred value as in the vertex quality -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Max Dist Search </TD> <TD><i> Sample points for which we do not find anything whithin this distance are rejected and not considered for recovering attributes. -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Max Dist Search </TD> <TD><i> Sample points for which we do not find anything within this distance are rejected and not considered for recovering attributes. -- </i></TD> </TR>
</TABLE>
\section f132 Uniform Mesh Resampling
@ -1458,7 +1458,7 @@ Create a new mesh that is a resampled version of the current one.<br>The resampl
<TR><TD> \c Bool </TD> <TD> Clean Vertices </TD> <TD><i> If true the mesh generated by MC will be cleaned by unifying vertices that are almost coincident -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Discretize </TD> <TD><i> If true the position of the intersected edge of the marching cube grid is not computed by linear interpolation, but it is placed in fixed middle position. As a consequence the resampled object will look severely aliased by a stairstep appearance.<br>Useful only for simulating the output of 3D printing devices. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Multisample </TD> <TD><i> If true the distance field is more accurately compute by multisampling the volume (7 sample for each voxel). Much slower but less artifacts. -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Absolute Distance </TD> <TD><i> If true a <b> not</b> signed distance field is computed. In this case you have to choose a not zero Offset and a double surface is built around the original surface, inside and outside. Is useful to convrt thin floating surfaces into <i> solid, thick meshes.</i>. t -- </i></TD> </TR>
<TR><TD> \c Bool </TD> <TD> Absolute Distance </TD> <TD><i> If true a <b> not</b> signed distance field is computed. In this case you have to choose a not zero Offset and a double surface is built around the original surface, inside and outside. Is useful to convert thin floating surfaces into <i> solid, thick meshes.</i>. t -- </i></TD> </TR>
</TABLE>
\section f133 Voronoi Vertex Clustering
@ -1494,7 +1494,7 @@ Given a Mesh <b>M</b> and a Pointset <b>P</b>, The filter project each vertex of
\section f136 Regular Recursive Sampling
The bbox is recrusively partitioned in a octree style, center of bbox are considered, when the center is nearer to the surface than a given thr it is projected on it. It works also for building ofsetted samples.
The bbox is recursively partitioned in a octree style, center of bbox are considered, when the center is nearer to the surface than a given thr it is projected on it. It works also for building offsetted samples.
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c AbsPerc </TD> <TD> Precision </TD> <TD><i> Size of the cell, the default is 1/50 of the box diag. Smaller cells give better precision at a higher computational cost. Remember that halving the cell size means that you build a volume 8 times larger. -- </i></TD> </TR>
@ -1672,7 +1672,7 @@ Structure Synth mesh creation based on Eisen Script.
<TABLE>
<TR><TD> \c String </TD> <TD> Eisen Script grammar </TD> <TD><i> Write a grammar according to Eisen Script specification and using the primitives box, sphere, mesh, dot and triangle -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> seed for random construction </TD> <TD><i> Seed needed to build the mesh -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> set maximum resolution of sphere primitves, it must be included between 1 and 4 </TD> <TD><i> increasing the resolution of the spheres will improve the quality of the mesh -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> set maximum resolution of sphere primitives, it must be included between 1 and 4 </TD> <TD><i> increasing the resolution of the spheres will improve the quality of the mesh -- </i></TD> </TR>
</TABLE>
\section f160 UV to Color
@ -1729,7 +1729,7 @@ Transfer texture/vertex color from one mesh to another's texture.
<TR><TD> \c Mesh </TD> <TD> Source Mesh </TD> <TD><i> The mesh that contains the source data that we want to transfer -- </i></TD> </TR>
<TR><TD> \c Mesh </TD> <TD> Target Mesh </TD> <TD><i> The mesh whose texture will be filled according to source mesh texture or vertex color -- </i></TD> </TR>
<TR><TD> \c Enum </TD> <TD> Color Data Source </TD> <TD><i> Choose to transfer color information from source mesh texture or vertex color -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Max Dist Search </TD> <TD><i> Sample points for which we do not find anything whithin this distance are rejected and not considered for recovering data -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Max Dist Search </TD> <TD><i> Sample points for which we do not find anything within this distance are rejected and not considered for recovering data -- </i></TD> </TR>
<TR><TD> \c String </TD> <TD> Texture file </TD> <TD><i> The texture file to be created -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Texture width (px) </TD> <TD><i> The texture width -- </i></TD> </TR>
<TR><TD> \c Int </TD> <TD> Texture height (px) </TD> <TD><i> The texture height -- </i></TD> </TR>
@ -1744,7 +1744,7 @@ Generates Vertex Color values picking color from another mesh texture.
<TABLE>
<TR><TD> \c Mesh </TD> <TD> Source Mesh </TD> <TD><i> The mesh with associated texture that we want to sample from -- </i></TD> </TR>
<TR><TD> \c Mesh </TD> <TD> Target Mesh </TD> <TD><i> The mesh whose vertex color will be filled according to source mesh texture -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Max Dist Search </TD> <TD><i> Sample points for which we do not find anything whithin this distance are rejected and not considered for recovering color -- </i></TD> </TR>
<TR><TD> \c AbsPerc </TD> <TD> Max Dist Search </TD> <TD><i> Sample points for which we do not find anything within this distance are rejected and not considered for recovering color -- </i></TD> </TR>
</TABLE>
\section f167 Planar flipping optimization
@ -1813,7 +1813,7 @@ Scale Dependent Laplacian Smoothing, extended version of Laplacian Smoothing, ba
\section f174 TwoStep Smooth
Two Step Smoothing, a feature preserving/enhancing fairing filter. It is based on a Normal Smoothing step where similar normals are averaged toghether and a step where the vertexes are fitted on the new normals
Two Step Smoothing, a feature preserving/enhancing fairing filter. It is based on a Normal Smoothing step where similar normals are averaged together and a step where the vertexes are fitted on the new normals
<H2> Parameters </h2>
<TABLE>
<TR><TD> \c Int </TD> <TD> Smoothing steps </TD> <TD><i> The number of times that the whole algorithm (normal smoothing + vertex fitting) is iterated. -- </i></TD> </TR>
@ -1932,12 +1932,12 @@ Recompute face normals as the normal of the average of the normals of the triang
No parameters.<br>
\section f189 Normalize Face Normals
Normalize Face Normal Lenghts
Normalize Face Normal Lengths
<H2> Parameters </h2>
No parameters.<br>
\section f190 Normalize Vertex Normals
Normalize Vertex Normal Lenghts
Normalize Vertex Normal Lengths
<H2> Parameters </h2>
No parameters.<br>
\section f191 Vertex Linear Morphing

0
distrib/LICENSE.txt → resources/LICENSE.txt
View File

10
resources/README.md Normal file
View File

@ -0,0 +1,10 @@
# MeshLab resources
The `resources` folder contains a set of files, binaries and shaders that MeshLab needs to be correctly built, deployed and packaged.
Examples of contained files:
- icons;
- deployment software binaries;
- configuration files for packaging;
- shaders;
- license, privacy and readme files that are bundled in the final MeshLab packages.

BIN
resources/icons/eye_cropped.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 76 KiB

BIN
resources/icons/meshlab.icns Normal file
View File

Binary file not shown.

BIN
resources/icons/meshlab.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 143 KiB

BIN
resources/icons/meshlab.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 139 KiB

BIN
resources/icons/meshlab100.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
resources/icons/meshlab16.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.9 KiB

BIN
resources/icons/meshlab200.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 42 KiB

BIN
resources/icons/meshlab22.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 13 KiB

BIN
resources/icons/meshlab24.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
resources/icons/meshlab256.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 57 KiB

BIN
resources/icons/meshlab32.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 7.9 KiB

BIN
resources/icons/meshlab44.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
resources/icons/meshlab48.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 15 KiB

BIN
resources/icons/meshlab50.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
resources/icons/meshlab512.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 139 KiB

BIN
resources/icons/meshlab63.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 18 KiB

BIN
resources/icons/meshlab64.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
resources/icons/meshlab75.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 19 KiB

BIN
resources/icons/meshlab8.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.2 KiB

BIN
resources/icons/meshlab96.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 21 KiB

BIN
resources/linux/linuxdeploy Executable file
View File

Binary file not shown.

BIN
resources/linux/linuxdeploy-plugin-appimage Executable file
View File

Binary file not shown.

BIN
scripts/Linux/resources/linuxdeployqt → resources/linux/linuxdeploy-plugin-qt
View File

Binary file not shown.

11
scripts/Linux/resources/meshlab.desktop → resources/linux/meshlab.desktop
View File

@ -1,13 +1,12 @@
[Desktop Entry]
Version=1.0
Name=MeshLab
Name[en_GB]=MeshLab
GenericName=Mesh processing
GenericName[en_GB]=Mesh processing
Comment=View and process meshes
Type=Application
Name=MeshLab
GenericName=Mesh processing
Comment=View and process meshes
Exec=meshlab %F
Icon=/usr/share/pixmaps/meshlab.png
Icon=meshlab
Terminal=false
MimeType=model/mesh;application/x-3ds;image/x-3ds;model/x-ply;application/sla;model/x-quad-object;model/x-geomview-off;application/x-cyclone-ptx;application/x-vmi;application/x-bre;model/vnd.collada+xml;model/openctm;application/x-expe-binary;application/x-expe-ascii;application/x-xyz;application/x-gts;chemical/x-pdb;application/x-tri;application/x-asc;model/x3d+xml;model/x3d+vrml;model/vrml;model/u3d;model/idtf;
Categories=Graphics;3DGraphics;Viewer;Qt;
Name[en_US]=MeshLab

0
scripts/macOS/resources/dmg-background.svg → resources/macos/dmg-background.svg
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 31 KiB

After

Width:  |  Height:  |  Size: 31 KiB

0
scripts/macOS/resources/meshlab_dmg_background.png → resources/macos/meshlab_dmg_background.png
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 52 KiB

After

Width:  |  Height:  |  Size: 52 KiB

0
scripts/macOS/resources/meshlab_dmg_background@2x.png → resources/macos/meshlab_dmg_background@2x.png
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 27 KiB

After

Width:  |  Height:  |  Size: 27 KiB

8
scripts/macOS/resources/meshlab_dmg_latest.json → resources/macos/meshlab_dmg_latest.json
View File

@ -1,12 +1,12 @@
{
"title": "MeshLab",
"icon": "SOURCE_PATH/meshlab/images/meshlab.icns",
"icon": "RESOURCES_PATH/icons/meshlab.icns",
"background": "meshlab_dmg_background.png",
"window" : { "size" : { "width" : 500, "height" : 400 } },
"contents": [
{ "x": 112, "y": 100, "type": "file", "path": "DISTRIB_PATH/meshlab.app" },
{ "x": 112, "y": 100, "type": "file", "path": "DISTRIB_PATH/MeshLabML_VERSION.app" },
{ "x": 385, "y": 100, "type": "link", "path": "/Applications" },
{ "x": 250, "y": 280, "type": "file", "path": "LICENSE.txt" },
{ "x": 385, "y": 280, "type": "file", "path": "readme.txt" }
{ "x": 250, "y": 280, "type": "file", "path": "RESOURCES_PATH/LICENSE.txt" },
{ "x": 385, "y": 280, "type": "file", "path": "RESOURCES_PATH/readme.txt" }
]
}

4
distrib/privacy.txt → resources/privacy.txt
View File

@ -2,8 +2,8 @@
Privacy Disclaimer
Please read it carefully.
MeshLab will automatically check for the availability of updated versions and will notify the need of upgrading the software to the users. For this reason, from time to time, MeshLab will issue a http network connection. If you prefer that MeshLab does not communicate in any way with its developers, simply use a plain firewall and prevent any MeshLab access to the network. This will not limit in any way the normal behaviour of MeshLab. When using MeshLab some aggregated statistical data about only the specific usage of MeshLab are collected: the number and size of the opened/saved meshes; nothing more. Periodically this information is sent back to the developers. This data will be used for statistical analysis only.
Paranoids can also look at the sources for seeing what is transmitted.
MeshLab will automatically check for the availability of updated versions and will notify the need of upgrading the software to the users. For this reason, from time to time, MeshLab will issue a http network connection. If you prefer that MeshLab does not communicate in any way with its developers, simply use a plain firewall and prevent any MeshLab access to the network, or disable the update check in the system preferences. This will not limit in any way the normal behaviour of MeshLab apart from getting notified when new releases are distributed.
Important: when using MeshLab the following aggregated statistical data are collected: the number of opened meshes, the number of saved meshes, and the total sum of the number of vertices opened by the user. This statistically aggregated information (three integers) is sent back to the developer when checking for updates. Disabling the check for updates also disable this data collection.
We would like to remark that the kind of aggregated information collected by MeshLab is probably by far less sensitive than the information that is silently collected by most web sites when you surf them: ip address, visited pages, frequency of return. We would also like to stress that we really need this information in order to assess how diffusely MeshLab is used and what is its impact on the 3D community.

18
scripts/macOS/resources/readme.txt → resources/readme.txt
View File

@ -2,13 +2,13 @@
http://www.meshlab.net
All rights reserved.
VCGLib http://www.vcglib.net o o
VCGLib http://www.vcglib.net o o
Visual and Computer Graphics Library o o
_ O _
Paolo Cignoni \/)\/
Visual Computing Lab http://vcg.isti.cnr.it /\/|
ISTI - Italian National Research Council |
Copyright(C) 2005-2018 \
Copyright(C) 2005-2022 \
This program is free software; you can redistribute it and/or modify it
@ -22,9 +22,9 @@ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
--- Windows Note ---
If you are running MeshLab portable and you are getting the error “MSVCP140.dll not found”
or related, please install Visual C++ Redist by executing the vc_redist.exe file contained
in the meshlab portable archive.
If you are running MeshLab portable and you are getting the error “MSVCP140.dll not found”
or related, please install Visual C++ Redist by executing the vc_redist.exe file contained
in the meshlab portable archive.
--- References ----
@ -32,7 +32,7 @@ Please, when using this tool, cite the following reference:
Meshlab: an open-source mesh processing tool.
P. Cignoni, M. Callieri, M. Corsini, M. Dellepiane, F. Ganovelli, G. Ranzuglia
Proceedings of the 2008 Eurographics Italian Chapter Conference,
Proceedings of the 2008 Eurographics Italian Chapter Conference,
ISBN: 978-3-905673-68-5, pp. 129-136, DOI: 10.2312/LocalChapterEvents/ItalChap/ItalianChapConf2008/129-136
@inproceedings {LocalChapterEvents:ItalChap:ItalianChapConf2008:129-136,
@ -46,11 +46,11 @@ ISBN = {978-3-905673-68-5},
DOI = {10.2312/LocalChapterEvents/ItalChap/ItalianChapConf2008/129-136}
}
Paolo Cignoni (p.cignoni (at) isti.cnr.it)
Guido Ranzuglia (g.ranzuglia (at) isti.cnr.it)
Paolo Cignoni (paolo.cignoni (at) isti.cnr.it)
Alessandro Muntoni (alessandro.muntoni (at) isti.cnr.it)
For documented and repeatable bugs, reasonable feature requests and grounded issues, please use the GitHub services
https://github.com/cnr-isti-vclab/meshlab/issues
For general questions use StackOverflow
For general questions use StackOverflow
http://stackoverflow.com/questions/tagged/meshlab

0
distrib/shaders/3Dlabs-license.txt → resources/shaders/3Dlabs-license.txt
View File

2
distrib/shaders/Cook-Torrance.frag → resources/shaders/Cook-Torrance.frag
View File

@ -40,7 +40,7 @@ uniform float ni;
void main()
{
// the material propertise are embedded in the shader (for now)
// the material properties are embedded in the shader (for now)
vec4 mat_ambient = vec4(1.0, 1.0, 1.0, 1.0);
vec4 mat_diffuse = gl_Color;//vec4(1.0, 1.0, 1.0, 1.0);
vec4 mat_specular= vec4(1.0, 1.0, 1.0, 1.0);

0
distrib/shaders/Cook-Torrance.gdp → resources/shaders/Cook-Torrance.gdp
View File

0
distrib/shaders/Cook-Torrance.vert → resources/shaders/Cook-Torrance.vert
View File

0
distrib/shaders/Hatch.frag → resources/shaders/Hatch.frag
View File

0
distrib/shaders/Hatch.gdp → resources/shaders/Hatch.gdp
View File

0
distrib/shaders/Hatch.vert → resources/shaders/Hatch.vert
View File

0
distrib/shaders/LightworkDesign-license.txt → resources/shaders/LightworkDesign-license.txt
View File

0
distrib/shaders/Oren-Nayar.frag → resources/shaders/Oren-Nayar.frag
View File

0
distrib/shaders/Oren-Nayar.gdp → resources/shaders/Oren-Nayar.gdp
View File

0
distrib/shaders/Oren-Nayar.vert → resources/shaders/Oren-Nayar.vert
View File

0
distrib/shaders/SEM.frag → resources/shaders/SEM.frag
View File

0
distrib/shaders/SEM.vert → resources/shaders/SEM.vert
View File

0
distrib/shaders/ambient_occlusion.vert → resources/shaders/ambient_occlusion.vert
View File

0
distrib/shaders/ambient_occlusion4.frag → resources/shaders/ambient_occlusion4.frag
View File

0
distrib/shaders/ambient_occlusion8.frag → resources/shaders/ambient_occlusion8.frag
View File

0
distrib/shaders/decorate_shadow/sm/depth.frag → resources/shaders/decorate_shadow/sm/depth.frag
View File

0
distrib/shaders/decorate_shadow/sm/depth.vert → resources/shaders/decorate_shadow/sm/depth.vert
View File

0
distrib/shaders/decorate_shadow/sm/object.frag → resources/shaders/decorate_shadow/sm/object.frag
View File

0
distrib/shaders/decorate_shadow/sm/object.vert → resources/shaders/decorate_shadow/sm/object.vert
View File

0
distrib/shaders/decorate_shadow/ssao/blur.frag → resources/shaders/decorate_shadow/ssao/blur.frag
View File

0
distrib/shaders/decorate_shadow/ssao/blur.vert → resources/shaders/decorate_shadow/ssao/blur.vert
View File

0
distrib/shaders/decorate_shadow/ssao/normalMap.frag → resources/shaders/decorate_shadow/ssao/normalMap.frag
View File

0
distrib/shaders/decorate_shadow/ssao/normalMap.vert → resources/shaders/decorate_shadow/ssao/normalMap.vert
View File

0
distrib/shaders/decorate_shadow/ssao/ssao.frag → resources/shaders/decorate_shadow/ssao/ssao.frag
View File

0
distrib/shaders/decorate_shadow/ssao/ssao.vert → resources/shaders/decorate_shadow/ssao/ssao.vert
View File

0
distrib/shaders/decorate_shadow/vsm/depthVSM.frag → resources/shaders/decorate_shadow/vsm/depthVSM.frag
View File

0
distrib/shaders/decorate_shadow/vsm/depthVSM.vert → resources/shaders/decorate_shadow/vsm/depthVSM.vert
View File

2
distrib/shaders/decorate_shadow/vsm/objectVSM.frag → resources/shaders/decorate_shadow/vsm/objectVSM.frag
View File

@ -6,7 +6,7 @@ uniform float shadowIntensity; // 1.0 black, 0, transparent
vec4 shadowCoordPostW;
float chebyshevUpperBound( float distance) {
// We retrive the two moments previously stored (depth and depth*depth)
// We retrieve the two moments previously stored (depth and depth*depth)
vec2 moments = texture2D(shadowMap,shadowCoordPostW.xy).rb;
// Surface is fully lit. as the current fragment is before the light occluder
if (distance <= moments.x)

0
distrib/shaders/decorate_shadow/vsm/objectVSM.vert → resources/shaders/decorate_shadow/vsm/objectVSM.vert
View File

0
distrib/shaders/decorate_shadow/vsmb/blurVSM.frag → resources/shaders/decorate_shadow/vsmb/blurVSM.frag
View File

0
distrib/shaders/decorate_shadow/vsmb/blurVSM.vert → resources/shaders/decorate_shadow/vsmb/blurVSM.vert
View File

0
distrib/shaders/decorate_shadow/vsmb/depthVSM.frag → resources/shaders/decorate_shadow/vsmb/depthVSM.frag
View File

0
distrib/shaders/decorate_shadow/vsmb/depthVSM.vert → resources/shaders/decorate_shadow/vsmb/depthVSM.vert
View File

2
distrib/shaders/decorate_shadow/vsmb/objectVSM.frag → resources/shaders/decorate_shadow/vsmb/objectVSM.frag
View File

@ -7,7 +7,7 @@ uniform float shadowIntensity; // 1.0 black, 0, transparent
vec4 shadowCoordPostW;
float chebyshevUpperBound( float distance) {
// We retrive the two moments previously stored (depth and depth*depth)
// We retrieve the two moments previously stored (depth and depth*depth)
vec2 moments = texture2D(shadowMap,shadowCoordPostW.xy).rb;
// Surface is fully lit. as the current fragment is before the light occluder
if (distance <= moments.x)

0
distrib/shaders/decorate_shadow/vsmb/objectVSM.vert → resources/shaders/decorate_shadow/vsmb/objectVSM.vert
View File

0
distrib/shaders/depthmap.frag → resources/shaders/depthmap.frag
View File

0
distrib/shaders/depthmap.gdp → resources/shaders/depthmap.gdp
View File

0
distrib/shaders/depthmap.vert → resources/shaders/depthmap.vert
View File

0
distrib/shaders/dimple.frag → resources/shaders/dimple.frag
View File

0
distrib/shaders/dimple.gdp → resources/shaders/dimple.gdp
View File

0
distrib/shaders/dimple.vert → resources/shaders/dimple.vert
View File

0
distrib/shaders/electronic microscope.gdp → resources/shaders/electronic microscope.gdp
View File

0
distrib/shaders/envmap.frag → resources/shaders/envmap.frag
View File

0
distrib/shaders/envmap.gdp → resources/shaders/envmap.gdp
View File

0
distrib/shaders/envmap.vert → resources/shaders/envmap.vert
View File

0
distrib/shaders/glass.frag → resources/shaders/glass.frag
View File

Some files were not shown because too many files have changed in this diff Show More