Rename vector type.
Refactor file layout of extperimental code.
This commit is contained in:
Syoyo Fujita
16
experimental/multithreaded/README.md
Normal file
16
experimental/multithreaded/README.md
Normal file
@@ -0,0 +1,16 @@
|
||||
# Experimental code for .obj loader.
|
||||
|
||||
* Multi-threaded optimized parser : tinyobj_loader_opt.h
|
||||
|
||||
## Requirements
|
||||
|
||||
* C++-11 compiler
|
||||
|
||||
## Compile options
|
||||
|
||||
* zstd compressed .obj support. `--with-zstd` premake option.
|
||||
* gzip compressed .obj support. `--with-zlib` premake option.
|
||||
|
||||
## Licenses
|
||||
|
||||
* lfpAlloc : MIT license.
|
||||
89
experimental/multithreaded/lfpAlloc/Allocator.hpp
Normal file
89
experimental/multithreaded/lfpAlloc/Allocator.hpp
Normal file
@@ -0,0 +1,89 @@
|
||||
#ifndef LF_POOL_ALLOCATOR
|
||||
#define LF_POOL_ALLOCATOR
|
||||
|
||||
#include <memory>
|
||||
#include <thread>
|
||||
#include <lfpAlloc/PoolDispatcher.hpp>
|
||||
|
||||
namespace lfpAlloc {
|
||||
template <typename T, std::size_t NumPools = 70>
|
||||
class lfpAllocator {
|
||||
public:
|
||||
using value_type = T;
|
||||
using pointer = T*;
|
||||
using const_pointer = const T*;
|
||||
using reference = T&;
|
||||
using const_reference = T const&;
|
||||
|
||||
template <typename U>
|
||||
struct rebind {
|
||||
typedef lfpAllocator<U, NumPools> other;
|
||||
};
|
||||
|
||||
lfpAllocator() {}
|
||||
|
||||
template <typename U>
|
||||
lfpAllocator(lfpAllocator<U, NumPools>&&) noexcept {}
|
||||
|
||||
template <typename U>
|
||||
lfpAllocator(const lfpAllocator<U, NumPools>&) noexcept {}
|
||||
|
||||
T* allocate(std::size_t count) {
|
||||
if (sizeof(T) * count <=
|
||||
alignof(std::max_align_t) * NumPools - sizeof(void*)) {
|
||||
return reinterpret_cast<T*>(
|
||||
dispatcher_.allocate(sizeof(T) * count));
|
||||
} else {
|
||||
return new T[count];
|
||||
}
|
||||
}
|
||||
|
||||
void deallocate(T* p, std::size_t count) noexcept {
|
||||
if (sizeof(T) * count <=
|
||||
alignof(std::max_align_t) * NumPools - sizeof(void*)) {
|
||||
dispatcher_.deallocate(p, sizeof(T) * count);
|
||||
} else {
|
||||
delete[] p;
|
||||
}
|
||||
}
|
||||
|
||||
// Should not be required, but allocator_traits is not complete in
|
||||
// gcc 4.9.1
|
||||
template <typename U>
|
||||
void destroy(U* p) {
|
||||
p->~U();
|
||||
}
|
||||
|
||||
template <typename U, typename... Args>
|
||||
void construct(U* p, Args&&... args) {
|
||||
new (p) U(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <typename Ty, typename U, std::size_t N, std::size_t M>
|
||||
friend bool operator==(const lfpAllocator<Ty, N>&,
|
||||
const lfpAllocator<U, M>&) noexcept;
|
||||
|
||||
template <typename U, std::size_t M>
|
||||
friend class lfpAllocator;
|
||||
|
||||
private:
|
||||
static PoolDispatcher<NumPools> dispatcher_;
|
||||
};
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
PoolDispatcher<N> lfpAllocator<T, N>::dispatcher_;
|
||||
|
||||
template <typename T, typename U, std::size_t N, std::size_t M>
|
||||
inline bool operator==(const lfpAllocator<T, N>&,
|
||||
const lfpAllocator<U, M>&) noexcept {
|
||||
return N == M;
|
||||
}
|
||||
|
||||
template <typename T, typename U, std::size_t N, std::size_t M>
|
||||
inline bool operator!=(const lfpAllocator<T, N>& left,
|
||||
const lfpAllocator<U, M>& right) noexcept {
|
||||
return !(left == right);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
116
experimental/multithreaded/lfpAlloc/ChunkList.hpp
Normal file
116
experimental/multithreaded/lfpAlloc/ChunkList.hpp
Normal file
@@ -0,0 +1,116 @@
|
||||
#ifndef LF_POOL_ALLOC_CHUNK_LIST
|
||||
#define LF_POOL_ALLOC_CHUNK_LIST
|
||||
|
||||
#include <cstdint>
|
||||
#include <atomic>
|
||||
#include <type_traits>
|
||||
|
||||
#ifndef LFP_ALLOW_BLOCKING
|
||||
static_assert(ATOMIC_POINTER_LOCK_FREE == 2,
|
||||
"Atomic pointer is not lock-free.");
|
||||
#endif
|
||||
|
||||
namespace lfpAlloc {
|
||||
|
||||
template <std::size_t Size>
|
||||
struct Cell {
|
||||
uint8_t val_[Size];
|
||||
Cell* next_ = this + 1;
|
||||
};
|
||||
|
||||
// For small types (less than the size of void*), no additional
|
||||
// space is needed, so union val_ with next_ to avoid overhead.
|
||||
template <>
|
||||
struct Cell<0> {
|
||||
Cell() : next_{this + 1} {}
|
||||
union {
|
||||
uint8_t val_[sizeof(Cell*)];
|
||||
Cell* next_;
|
||||
};
|
||||
};
|
||||
|
||||
template <std::size_t Size, std::size_t AllocationsPerChunk>
|
||||
struct Chunk {
|
||||
Chunk() noexcept {
|
||||
auto& last = memBlock_[AllocationsPerChunk - 1];
|
||||
last.next_ = nullptr;
|
||||
}
|
||||
Cell<Size> memBlock_[AllocationsPerChunk];
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct Node {
|
||||
Node() : val_(), next_(nullptr) {}
|
||||
Node(const T& val) : val_(val), next_(nullptr) {}
|
||||
T val_;
|
||||
std::atomic<Node<T>*> next_;
|
||||
};
|
||||
|
||||
template <std::size_t Size, std::size_t AllocationsPerChunk>
|
||||
class ChunkList {
|
||||
static constexpr auto CellSize =
|
||||
(Size > sizeof(void*)) ? Size - sizeof(void*) : 0;
|
||||
using Chunk_t = Chunk<CellSize, AllocationsPerChunk>;
|
||||
using Cell_t = Cell<CellSize>;
|
||||
|
||||
using ChunkNode = Node<Chunk_t>;
|
||||
using CellNode = Node<Cell_t*>;
|
||||
|
||||
public:
|
||||
static ChunkList& getInstance() {
|
||||
static ChunkList c;
|
||||
return c;
|
||||
}
|
||||
|
||||
Cell_t* allocateChain() {
|
||||
CellNode* recentHead = head_.load();
|
||||
CellNode* currentNext = nullptr;
|
||||
do {
|
||||
// If there are no available chains, allocate a new chunk
|
||||
if (!recentHead) {
|
||||
ChunkNode* currentHandle;
|
||||
|
||||
// Make a new node
|
||||
auto newChunk = new ChunkNode();
|
||||
|
||||
// Add the chunk to the chain
|
||||
do {
|
||||
currentHandle = handle_.load();
|
||||
newChunk->next_ = currentHandle;
|
||||
} while (
|
||||
!handle_.compare_exchange_weak(currentHandle, newChunk));
|
||||
return &newChunk->val_.memBlock_[0];
|
||||
}
|
||||
|
||||
currentNext = recentHead->next_;
|
||||
} while (!head_.compare_exchange_weak(recentHead, currentNext));
|
||||
|
||||
auto retnValue = recentHead->val_;
|
||||
delete recentHead;
|
||||
return retnValue;
|
||||
}
|
||||
|
||||
void deallocateChain(Cell_t* newCell) {
|
||||
if (!newCell) {
|
||||
return;
|
||||
}
|
||||
CellNode* currentHead = head_.load();
|
||||
|
||||
// Construct a new node to be added to the linked list
|
||||
CellNode* newHead = new CellNode(newCell);
|
||||
|
||||
// Add the chain to the linked list
|
||||
do {
|
||||
newHead->next_.store(currentHead, std::memory_order_release);
|
||||
} while (!head_.compare_exchange_weak(currentHead, newHead));
|
||||
}
|
||||
|
||||
private:
|
||||
ChunkList() : handle_(nullptr), head_(nullptr) {}
|
||||
|
||||
std::atomic<ChunkNode*> handle_;
|
||||
std::atomic<CellNode*> head_;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
21
experimental/multithreaded/lfpAlloc/LICENSE
Normal file
21
experimental/multithreaded/lfpAlloc/LICENSE
Normal file
@@ -0,0 +1,21 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2014 Adam Schwalm
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
48
experimental/multithreaded/lfpAlloc/Pool.hpp
Normal file
48
experimental/multithreaded/lfpAlloc/Pool.hpp
Normal file
@@ -0,0 +1,48 @@
|
||||
#ifndef LF_POOL_ALLOC_POOL
|
||||
#define LF_POOL_ALLOC_POOL
|
||||
|
||||
#include <lfpAlloc/Utils.hpp>
|
||||
#include <lfpAlloc/ChunkList.hpp>
|
||||
|
||||
namespace lfpAlloc {
|
||||
template <std::size_t Size, std::size_t AllocationsPerChunk>
|
||||
class Pool {
|
||||
using ChunkList_t = ChunkList<Size, AllocationsPerChunk>;
|
||||
|
||||
public:
|
||||
static constexpr auto CellSize =
|
||||
(Size > sizeof(void*)) ? Size - sizeof(void*) : 0;
|
||||
using Cell_t = Cell<CellSize>;
|
||||
|
||||
Pool() : head_(nullptr) {}
|
||||
|
||||
~Pool() { ChunkList_t::getInstance().deallocateChain(head_); }
|
||||
|
||||
void* allocate() {
|
||||
// Head loaded from head_
|
||||
Cell_t* currentHead = head_;
|
||||
Cell_t* next;
|
||||
|
||||
// Out of cells to allocate
|
||||
if (!currentHead) {
|
||||
currentHead = ChunkList_t::getInstance().allocateChain();
|
||||
}
|
||||
|
||||
next = currentHead->next_;
|
||||
head_ = next;
|
||||
return ¤tHead->val_;
|
||||
}
|
||||
|
||||
void deallocate(void* p) noexcept {
|
||||
auto newHead = reinterpret_cast<Cell_t*>(p);
|
||||
Cell_t* currentHead = head_;
|
||||
newHead->next_ = currentHead;
|
||||
head_ = newHead;
|
||||
}
|
||||
|
||||
private:
|
||||
Cell_t* head_;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
79
experimental/multithreaded/lfpAlloc/PoolDispatcher.hpp
Normal file
79
experimental/multithreaded/lfpAlloc/PoolDispatcher.hpp
Normal file
@@ -0,0 +1,79 @@
|
||||
#ifndef LF_POOL_DISPATCHER
|
||||
#define LF_POOL_DISPATCHER
|
||||
|
||||
#include <tuple>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <lfpAlloc/Pool.hpp>
|
||||
|
||||
#ifndef LFP_ALLOCATIONS_PER_CHUNK
|
||||
#define LFP_ALLOCATIONS_PER_CHUNK 64 * 100
|
||||
#endif
|
||||
|
||||
namespace lfpAlloc {
|
||||
namespace detail {
|
||||
|
||||
template <std::size_t Num, uint16_t... Ts>
|
||||
struct Pools : Pools<Num - 1, alignof(std::max_align_t) * Num, Ts...> {};
|
||||
|
||||
template <uint16_t... Size>
|
||||
struct Pools<0, Size...> {
|
||||
using type = std::tuple<Pool<Size, LFP_ALLOCATIONS_PER_CHUNK>...>;
|
||||
};
|
||||
}
|
||||
|
||||
template <std::size_t NumPools>
|
||||
class PoolDispatcher {
|
||||
public:
|
||||
void* allocate(std::size_t size) { return dispatchAllocate<0>(size); }
|
||||
|
||||
void deallocate(void* p, std::size_t size) noexcept {
|
||||
dispatchDeallocate<0>(p, size);
|
||||
}
|
||||
|
||||
private:
|
||||
thread_local static typename detail::Pools<NumPools>::type pools_;
|
||||
static_assert(NumPools > 0, "Invalid number of pools");
|
||||
|
||||
template <std::size_t Index>
|
||||
typename std::enable_if <
|
||||
Index<NumPools, void*>::type
|
||||
dispatchAllocate(std::size_t const& requestSize) {
|
||||
if (requestSize <= std::get<Index>(pools_).CellSize) {
|
||||
return std::get<Index>(pools_).allocate();
|
||||
} else {
|
||||
return dispatchAllocate<Index + 1>(requestSize);
|
||||
}
|
||||
}
|
||||
|
||||
template <std::size_t Index>
|
||||
typename std::enable_if<!(Index < NumPools), void*>::type
|
||||
dispatchAllocate(std::size_t const&) {
|
||||
assert(false && "Invalid allocation size.");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
template <std::size_t Index>
|
||||
typename std::enable_if <
|
||||
Index<NumPools>::type
|
||||
dispatchDeallocate(void* p, std::size_t const& requestSize) noexcept {
|
||||
if (requestSize <= std::get<Index>(pools_).CellSize) {
|
||||
std::get<Index>(pools_).deallocate(p);
|
||||
} else {
|
||||
dispatchDeallocate<Index + 1>(p, requestSize);
|
||||
}
|
||||
}
|
||||
|
||||
template <std::size_t Index>
|
||||
typename std::enable_if<!(Index < NumPools)>::type
|
||||
dispatchDeallocate(void*, std::size_t const&) noexcept {
|
||||
assert(false && "Invalid deallocation size.");
|
||||
}
|
||||
};
|
||||
|
||||
template <std::size_t NumPools>
|
||||
thread_local typename detail::Pools<NumPools>::type
|
||||
PoolDispatcher<NumPools>::pools_;
|
||||
}
|
||||
|
||||
#endif
|
||||
20
experimental/multithreaded/lfpAlloc/Utils.hpp
Normal file
20
experimental/multithreaded/lfpAlloc/Utils.hpp
Normal file
@@ -0,0 +1,20 @@
|
||||
#include <cstdint>
|
||||
|
||||
namespace lfpAlloc {
|
||||
namespace detail {
|
||||
template <std::size_t Val, std::size_t base = 2>
|
||||
struct Log {
|
||||
enum { value = 1 + Log<Val / base, base>::value };
|
||||
};
|
||||
|
||||
template <std::size_t base>
|
||||
struct Log<1, base> {
|
||||
enum { value = 0 };
|
||||
};
|
||||
|
||||
template <std::size_t base>
|
||||
struct Log<0, base> {
|
||||
enum { value = 0 };
|
||||
};
|
||||
}
|
||||
}
|
||||
94
experimental/multithreaded/premake5.lua
Normal file
94
experimental/multithreaded/premake5.lua
Normal file
@@ -0,0 +1,94 @@
|
||||
newoption {
|
||||
trigger = "with-zlib",
|
||||
description = "Build with zlib."
|
||||
}
|
||||
|
||||
newoption {
|
||||
trigger = "with-zstd",
|
||||
description = "Build with ZStandard compression."
|
||||
}
|
||||
|
||||
newoption {
|
||||
trigger = "clang",
|
||||
description = "Use clang compiler."
|
||||
}
|
||||
|
||||
newoption {
|
||||
trigger = "asan",
|
||||
description = "Enable AddressSanitizer(gcc or clang only)."
|
||||
}
|
||||
|
||||
solution "objview"
|
||||
-- location ( "build" )
|
||||
configurations { "Release", "Debug" }
|
||||
platforms {"native", "x64", "x32"}
|
||||
|
||||
project "objview"
|
||||
|
||||
kind "ConsoleApp"
|
||||
language "C++"
|
||||
files { "viewer.cc", "trackball.cc" }
|
||||
includedirs { "./" }
|
||||
includedirs { "../../" }
|
||||
|
||||
flags { "c++11" }
|
||||
|
||||
if _OPTIONS['clang'] then
|
||||
toolset "clang"
|
||||
end
|
||||
|
||||
if _OPTIONS['with-zlib'] then
|
||||
defines { 'ENABLE_ZLIB' }
|
||||
links { 'z' }
|
||||
end
|
||||
|
||||
if _OPTIONS['asan'] then
|
||||
buildoptions { '-fsanitize=address' }
|
||||
linkoptions { '-fsanitize=address' }
|
||||
end
|
||||
|
||||
if _OPTIONS['with-zstd'] then
|
||||
print("with-zstd")
|
||||
defines { 'ENABLE_ZSTD' }
|
||||
-- Set path to zstd installed dir.
|
||||
includedirs { '$$HOME/local/include' }
|
||||
libdirs { '$$HOME/local/lib' }
|
||||
links { 'zstd' }
|
||||
end
|
||||
|
||||
-- Uncomment if you want address sanitizer(gcc/clang only)
|
||||
--buildoptions { "-fsanitize=address" }
|
||||
--linkoptions { "-fsanitize=address" }
|
||||
|
||||
configuration { "linux" }
|
||||
linkoptions { "`pkg-config --libs glfw3`" }
|
||||
links { "GL", "GLU", "m", "GLEW", "X11", "Xrandr", "Xinerama", "Xi", "Xxf86vm", "Xcursor", "dl" }
|
||||
linkoptions { "-pthread" }
|
||||
|
||||
configuration { "windows" }
|
||||
-- Path to GLFW3
|
||||
includedirs { '../../../local/glfw-3.2.bin.WIN64/include' }
|
||||
libdirs { '../../../local/glfw-3.2.bin.WIN64/lib-vc2015' }
|
||||
-- Path to GLEW
|
||||
includedirs { '../../../local/glew-1.13.0/include' }
|
||||
libdirs { '../../../local/glew-1.13.0/lib/Release/x64' }
|
||||
|
||||
links { "glfw3", "glew32", "gdi32", "winmm", "user32", "glu32","opengl32", "kernel32" }
|
||||
defines { "_CRT_SECURE_NO_WARNINGS" }
|
||||
defines { "NOMINMAX" }
|
||||
|
||||
configuration { "macosx" }
|
||||
includedirs { "/usr/local/include" }
|
||||
buildoptions { "-Wno-deprecated-declarations" }
|
||||
libdirs { "/usr/local/lib" }
|
||||
links { "glfw3", "GLEW" }
|
||||
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo" }
|
||||
|
||||
configuration "Debug"
|
||||
defines { "DEBUG" }
|
||||
flags { "Symbols"}
|
||||
|
||||
configuration "Release"
|
||||
defines { "NDEBUG" }
|
||||
flags { "Optimize"}
|
||||
|
||||
1684
experimental/multithreaded/tinyobj_loader_opt.h
Normal file
1684
experimental/multithreaded/tinyobj_loader_opt.h
Normal file
File diff suppressed because it is too large
Load Diff
292
experimental/multithreaded/trackball.cc
Normal file
292
experimental/multithreaded/trackball.cc
Normal file
@@ -0,0 +1,292 @@
|
||||
/*
|
||||
* (c) Copyright 1993, 1994, Silicon Graphics, Inc.
|
||||
* ALL RIGHTS RESERVED
|
||||
* Permission to use, copy, modify, and distribute this software for
|
||||
* any purpose and without fee is hereby granted, provided that the above
|
||||
* copyright notice appear in all copies and that both the copyright notice
|
||||
* and this permission notice appear in supporting documentation, and that
|
||||
* the name of Silicon Graphics, Inc. not be used in advertising
|
||||
* or publicity pertaining to distribution of the software without specific,
|
||||
* written prior permission.
|
||||
*
|
||||
* THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
|
||||
* AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
|
||||
* INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
|
||||
* GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
|
||||
* SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
|
||||
* KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
|
||||
* LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
|
||||
* THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
|
||||
* ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
|
||||
* POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* US Government Users Restricted Rights
|
||||
* Use, duplication, or disclosure by the Government is subject to
|
||||
* restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
|
||||
* (c)(1)(ii) of the Rights in Technical Data and Computer Software
|
||||
* clause at DFARS 252.227-7013 and/or in similar or successor
|
||||
* clauses in the FAR or the DOD or NASA FAR Supplement.
|
||||
* Unpublished-- rights reserved under the copyright laws of the
|
||||
* United States. Contractor/manufacturer is Silicon Graphics,
|
||||
* Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311.
|
||||
*
|
||||
* OpenGL(TM) is a trademark of Silicon Graphics, Inc.
|
||||
*/
|
||||
/*
|
||||
* Trackball code:
|
||||
*
|
||||
* Implementation of a virtual trackball.
|
||||
* Implemented by Gavin Bell, lots of ideas from Thant Tessman and
|
||||
* the August '88 issue of Siggraph's "Computer Graphics," pp. 121-129.
|
||||
*
|
||||
* Vector manip code:
|
||||
*
|
||||
* Original code from:
|
||||
* David M. Ciemiewicz, Mark Grossman, Henry Moreton, and Paul Haeberli
|
||||
*
|
||||
* Much mucking with by:
|
||||
* Gavin Bell
|
||||
*/
|
||||
#include <math.h>
|
||||
#include "trackball.h"
|
||||
|
||||
/*
|
||||
* This size should really be based on the distance from the center of
|
||||
* rotation to the point on the object underneath the mouse. That
|
||||
* point would then track the mouse as closely as possible. This is a
|
||||
* simple example, though, so that is left as an Exercise for the
|
||||
* Programmer.
|
||||
*/
|
||||
#define TRACKBALLSIZE (0.8)
|
||||
|
||||
/*
|
||||
* Local function prototypes (not defined in trackball.h)
|
||||
*/
|
||||
static float tb_project_to_sphere(float, float, float);
|
||||
static void normalize_quat(float[4]);
|
||||
|
||||
static void vzero(float *v) {
|
||||
v[0] = 0.0;
|
||||
v[1] = 0.0;
|
||||
v[2] = 0.0;
|
||||
}
|
||||
|
||||
static void vset(float *v, float x, float y, float z) {
|
||||
v[0] = x;
|
||||
v[1] = y;
|
||||
v[2] = z;
|
||||
}
|
||||
|
||||
static void vsub(const float *src1, const float *src2, float *dst) {
|
||||
dst[0] = src1[0] - src2[0];
|
||||
dst[1] = src1[1] - src2[1];
|
||||
dst[2] = src1[2] - src2[2];
|
||||
}
|
||||
|
||||
static void vcopy(const float *v1, float *v2) {
|
||||
int i;
|
||||
for (i = 0; i < 3; i++)
|
||||
v2[i] = v1[i];
|
||||
}
|
||||
|
||||
static void vcross(const float *v1, const float *v2, float *cross) {
|
||||
float temp[3];
|
||||
|
||||
temp[0] = (v1[1] * v2[2]) - (v1[2] * v2[1]);
|
||||
temp[1] = (v1[2] * v2[0]) - (v1[0] * v2[2]);
|
||||
temp[2] = (v1[0] * v2[1]) - (v1[1] * v2[0]);
|
||||
vcopy(temp, cross);
|
||||
}
|
||||
|
||||
static float vlength(const float *v) {
|
||||
return sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
|
||||
}
|
||||
|
||||
static void vscale(float *v, float div) {
|
||||
v[0] *= div;
|
||||
v[1] *= div;
|
||||
v[2] *= div;
|
||||
}
|
||||
|
||||
static void vnormal(float *v) { vscale(v, 1.0 / vlength(v)); }
|
||||
|
||||
static float vdot(const float *v1, const float *v2) {
|
||||
return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
|
||||
}
|
||||
|
||||
static void vadd(const float *src1, const float *src2, float *dst) {
|
||||
dst[0] = src1[0] + src2[0];
|
||||
dst[1] = src1[1] + src2[1];
|
||||
dst[2] = src1[2] + src2[2];
|
||||
}
|
||||
|
||||
/*
|
||||
* Ok, simulate a track-ball. Project the points onto the virtual
|
||||
* trackball, then figure out the axis of rotation, which is the cross
|
||||
* product of P1 P2 and O P1 (O is the center of the ball, 0,0,0)
|
||||
* Note: This is a deformed trackball-- is a trackball in the center,
|
||||
* but is deformed into a hyperbolic sheet of rotation away from the
|
||||
* center. This particular function was chosen after trying out
|
||||
* several variations.
|
||||
*
|
||||
* It is assumed that the arguments to this routine are in the range
|
||||
* (-1.0 ... 1.0)
|
||||
*/
|
||||
void trackball(float q[4], float p1x, float p1y, float p2x, float p2y) {
|
||||
float a[3]; /* Axis of rotation */
|
||||
float phi; /* how much to rotate about axis */
|
||||
float p1[3], p2[3], d[3];
|
||||
float t;
|
||||
|
||||
if (p1x == p2x && p1y == p2y) {
|
||||
/* Zero rotation */
|
||||
vzero(q);
|
||||
q[3] = 1.0;
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* First, figure out z-coordinates for projection of P1 and P2 to
|
||||
* deformed sphere
|
||||
*/
|
||||
vset(p1, p1x, p1y, tb_project_to_sphere(TRACKBALLSIZE, p1x, p1y));
|
||||
vset(p2, p2x, p2y, tb_project_to_sphere(TRACKBALLSIZE, p2x, p2y));
|
||||
|
||||
/*
|
||||
* Now, we want the cross product of P1 and P2
|
||||
*/
|
||||
vcross(p2, p1, a);
|
||||
|
||||
/*
|
||||
* Figure out how much to rotate around that axis.
|
||||
*/
|
||||
vsub(p1, p2, d);
|
||||
t = vlength(d) / (2.0 * TRACKBALLSIZE);
|
||||
|
||||
/*
|
||||
* Avoid problems with out-of-control values...
|
||||
*/
|
||||
if (t > 1.0)
|
||||
t = 1.0;
|
||||
if (t < -1.0)
|
||||
t = -1.0;
|
||||
phi = 2.0 * asin(t);
|
||||
|
||||
axis_to_quat(a, phi, q);
|
||||
}
|
||||
|
||||
/*
|
||||
* Given an axis and angle, compute quaternion.
|
||||
*/
|
||||
void axis_to_quat(float a[3], float phi, float q[4]) {
|
||||
vnormal(a);
|
||||
vcopy(a, q);
|
||||
vscale(q, sin(phi / 2.0));
|
||||
q[3] = cos(phi / 2.0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet
|
||||
* if we are away from the center of the sphere.
|
||||
*/
|
||||
static float tb_project_to_sphere(float r, float x, float y) {
|
||||
float d, t, z;
|
||||
|
||||
d = sqrt(x * x + y * y);
|
||||
if (d < r * 0.70710678118654752440) { /* Inside sphere */
|
||||
z = sqrt(r * r - d * d);
|
||||
} else { /* On hyperbola */
|
||||
t = r / 1.41421356237309504880;
|
||||
z = t * t / d;
|
||||
}
|
||||
return z;
|
||||
}
|
||||
|
||||
/*
|
||||
* Given two rotations, e1 and e2, expressed as quaternion rotations,
|
||||
* figure out the equivalent single rotation and stuff it into dest.
|
||||
*
|
||||
* This routine also normalizes the result every RENORMCOUNT times it is
|
||||
* called, to keep error from creeping in.
|
||||
*
|
||||
* NOTE: This routine is written so that q1 or q2 may be the same
|
||||
* as dest (or each other).
|
||||
*/
|
||||
|
||||
#define RENORMCOUNT 97
|
||||
|
||||
void add_quats(float q1[4], float q2[4], float dest[4]) {
|
||||
static int count = 0;
|
||||
float t1[4], t2[4], t3[4];
|
||||
float tf[4];
|
||||
|
||||
vcopy(q1, t1);
|
||||
vscale(t1, q2[3]);
|
||||
|
||||
vcopy(q2, t2);
|
||||
vscale(t2, q1[3]);
|
||||
|
||||
vcross(q2, q1, t3);
|
||||
vadd(t1, t2, tf);
|
||||
vadd(t3, tf, tf);
|
||||
tf[3] = q1[3] * q2[3] - vdot(q1, q2);
|
||||
|
||||
dest[0] = tf[0];
|
||||
dest[1] = tf[1];
|
||||
dest[2] = tf[2];
|
||||
dest[3] = tf[3];
|
||||
|
||||
if (++count > RENORMCOUNT) {
|
||||
count = 0;
|
||||
normalize_quat(dest);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Quaternions always obey: a^2 + b^2 + c^2 + d^2 = 1.0
|
||||
* If they don't add up to 1.0, dividing by their magnitued will
|
||||
* renormalize them.
|
||||
*
|
||||
* Note: See the following for more information on quaternions:
|
||||
*
|
||||
* - Shoemake, K., Animating rotation with quaternion curves, Computer
|
||||
* Graphics 19, No 3 (Proc. SIGGRAPH'85), 245-254, 1985.
|
||||
* - Pletinckx, D., Quaternion calculus as a basic tool in computer
|
||||
* graphics, The Visual Computer 5, 2-13, 1989.
|
||||
*/
|
||||
static void normalize_quat(float q[4]) {
|
||||
int i;
|
||||
float mag;
|
||||
|
||||
mag = (q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3]);
|
||||
for (i = 0; i < 4; i++)
|
||||
q[i] /= mag;
|
||||
}
|
||||
|
||||
/*
|
||||
* Build a rotation matrix, given a quaternion rotation.
|
||||
*
|
||||
*/
|
||||
void build_rotmatrix(float m[4][4], const float q[4]) {
|
||||
m[0][0] = 1.0 - 2.0 * (q[1] * q[1] + q[2] * q[2]);
|
||||
m[0][1] = 2.0 * (q[0] * q[1] - q[2] * q[3]);
|
||||
m[0][2] = 2.0 * (q[2] * q[0] + q[1] * q[3]);
|
||||
m[0][3] = 0.0;
|
||||
|
||||
m[1][0] = 2.0 * (q[0] * q[1] + q[2] * q[3]);
|
||||
m[1][1] = 1.0 - 2.0 * (q[2] * q[2] + q[0] * q[0]);
|
||||
m[1][2] = 2.0 * (q[1] * q[2] - q[0] * q[3]);
|
||||
m[1][3] = 0.0;
|
||||
|
||||
m[2][0] = 2.0 * (q[2] * q[0] - q[1] * q[3]);
|
||||
m[2][1] = 2.0 * (q[1] * q[2] + q[0] * q[3]);
|
||||
m[2][2] = 1.0 - 2.0 * (q[1] * q[1] + q[0] * q[0]);
|
||||
m[2][3] = 0.0;
|
||||
|
||||
m[3][0] = 0.0;
|
||||
m[3][1] = 0.0;
|
||||
m[3][2] = 0.0;
|
||||
m[3][3] = 1.0;
|
||||
}
|
||||
75
experimental/multithreaded/trackball.h
Normal file
75
experimental/multithreaded/trackball.h
Normal file
@@ -0,0 +1,75 @@
|
||||
/*
|
||||
* (c) Copyright 1993, 1994, Silicon Graphics, Inc.
|
||||
* ALL RIGHTS RESERVED
|
||||
* Permission to use, copy, modify, and distribute this software for
|
||||
* any purpose and without fee is hereby granted, provided that the above
|
||||
* copyright notice appear in all copies and that both the copyright notice
|
||||
* and this permission notice appear in supporting documentation, and that
|
||||
* the name of Silicon Graphics, Inc. not be used in advertising
|
||||
* or publicity pertaining to distribution of the software without specific,
|
||||
* written prior permission.
|
||||
*
|
||||
* THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
|
||||
* AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
|
||||
* INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
|
||||
* GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
|
||||
* SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
|
||||
* KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
|
||||
* LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
|
||||
* THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
|
||||
* ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
|
||||
* POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* US Government Users Restricted Rights
|
||||
* Use, duplication, or disclosure by the Government is subject to
|
||||
* restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
|
||||
* (c)(1)(ii) of the Rights in Technical Data and Computer Software
|
||||
* clause at DFARS 252.227-7013 and/or in similar or successor
|
||||
* clauses in the FAR or the DOD or NASA FAR Supplement.
|
||||
* Unpublished-- rights reserved under the copyright laws of the
|
||||
* United States. Contractor/manufacturer is Silicon Graphics,
|
||||
* Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311.
|
||||
*
|
||||
* OpenGL(TM) is a trademark of Silicon Graphics, Inc.
|
||||
*/
|
||||
/*
|
||||
* trackball.h
|
||||
* A virtual trackball implementation
|
||||
* Written by Gavin Bell for Silicon Graphics, November 1988.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Pass the x and y coordinates of the last and current positions of
|
||||
* the mouse, scaled so they are from (-1.0 ... 1.0).
|
||||
*
|
||||
* The resulting rotation is returned as a quaternion rotation in the
|
||||
* first paramater.
|
||||
*/
|
||||
void trackball(float q[4], float p1x, float p1y, float p2x, float p2y);
|
||||
|
||||
void negate_quat(float *q, float *qn);
|
||||
|
||||
/*
|
||||
* Given two quaternions, add them together to get a third quaternion.
|
||||
* Adding quaternions to get a compound rotation is analagous to adding
|
||||
* translations to get a compound translation. When incrementally
|
||||
* adding rotations, the first argument here should be the new
|
||||
* rotation, the second and third the total rotation (which will be
|
||||
* over-written with the resulting new total rotation).
|
||||
*/
|
||||
void add_quats(float *q1, float *q2, float *dest);
|
||||
|
||||
/*
|
||||
* A useful function, builds a rotation matrix in Matrix based on
|
||||
* given quaternion.
|
||||
*/
|
||||
void build_rotmatrix(float m[4][4], const float q[4]);
|
||||
|
||||
/*
|
||||
* This function computes a quaternion based on an axis (defined by
|
||||
* the given vector) and an angle about which to rotate. The angle is
|
||||
* expressed in radians. The result is put into the third argument.
|
||||
*/
|
||||
void axis_to_quat(float a[3], float phi, float q[4]);
|
||||
748
experimental/multithreaded/viewer.cc
Normal file
748
experimental/multithreaded/viewer.cc
Normal file
@@ -0,0 +1,748 @@
|
||||
//
|
||||
// Simple .obj viewer(vertex only)
|
||||
//
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <limits>
|
||||
#include <cmath>
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
|
||||
#if defined(ENABLE_ZLIB)
|
||||
#include <zlib.h>
|
||||
#endif
|
||||
|
||||
#if defined(ENABLE_ZSTD)
|
||||
#include <zstd.h>
|
||||
#endif
|
||||
|
||||
#include <GL/glew.h>
|
||||
|
||||
#ifdef __APPLE__
|
||||
#include <OpenGL/glu.h>
|
||||
#else
|
||||
#include <GL/glu.h>
|
||||
#endif
|
||||
|
||||
#include <GLFW/glfw3.h>
|
||||
|
||||
#include "trackball.h"
|
||||
|
||||
#define TINYOBJ_LOADER_OPT_IMPLEMENTATION
|
||||
#include "tinyobj_loader_opt.h"
|
||||
|
||||
typedef struct {
|
||||
GLuint vb; // vertex buffer
|
||||
int numTriangles;
|
||||
} DrawObject;
|
||||
|
||||
std::vector<DrawObject> gDrawObjects;
|
||||
|
||||
int width = 768;
|
||||
int height = 768;
|
||||
|
||||
double prevMouseX, prevMouseY;
|
||||
bool mouseLeftPressed;
|
||||
bool mouseMiddlePressed;
|
||||
bool mouseRightPressed;
|
||||
float curr_quat[4];
|
||||
float prev_quat[4];
|
||||
float eye[3], lookat[3], up[3];
|
||||
|
||||
GLFWwindow* window;
|
||||
|
||||
void CheckErrors(std::string desc) {
|
||||
GLenum e = glGetError();
|
||||
if (e != GL_NO_ERROR) {
|
||||
fprintf(stderr, "OpenGL error in \"%s\": %d (%d)\n", desc.c_str(), e, e);
|
||||
exit(20);
|
||||
}
|
||||
}
|
||||
|
||||
void CalcNormal(float N[3], float v0[3], float v1[3], float v2[3]) {
|
||||
float v10[3];
|
||||
v10[0] = v1[0] - v0[0];
|
||||
v10[1] = v1[1] - v0[1];
|
||||
v10[2] = v1[2] - v0[2];
|
||||
|
||||
float v20[3];
|
||||
v20[0] = v2[0] - v0[0];
|
||||
v20[1] = v2[1] - v0[1];
|
||||
v20[2] = v2[2] - v0[2];
|
||||
|
||||
N[0] = v20[1] * v10[2] - v20[2] * v10[1];
|
||||
N[1] = v20[2] * v10[0] - v20[0] * v10[2];
|
||||
N[2] = v20[0] * v10[1] - v20[1] * v10[0];
|
||||
|
||||
float len2 = N[0] * N[0] + N[1] * N[1] + N[2] * N[2];
|
||||
if (len2 > 0.0f) {
|
||||
float len = sqrtf(len2);
|
||||
|
||||
N[0] /= len;
|
||||
N[1] /= len;
|
||||
}
|
||||
}
|
||||
|
||||
const char *mmap_file(size_t *len, const char* filename)
|
||||
{
|
||||
(*len) = 0;
|
||||
#ifdef _WIN32
|
||||
HANDLE file = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
|
||||
assert(file != INVALID_HANDLE_VALUE);
|
||||
|
||||
HANDLE fileMapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
|
||||
assert(fileMapping != INVALID_HANDLE_VALUE);
|
||||
|
||||
LPVOID fileMapView = MapViewOfFile(fileMapping, FILE_MAP_READ, 0, 0, 0);
|
||||
auto fileMapViewChar = (const char*)fileMapView;
|
||||
assert(fileMapView != NULL);
|
||||
|
||||
LARGE_INTEGER fileSize;
|
||||
fileSize.QuadPart = 0;
|
||||
GetFileSizeEx(file, &fileSize);
|
||||
|
||||
(*len) = static_cast<size_t>(fileSize.QuadPart);
|
||||
return fileMapViewChar;
|
||||
|
||||
#else
|
||||
|
||||
FILE* f = fopen(filename, "rb" );
|
||||
if (!f) {
|
||||
fprintf(stderr, "Failed to open file : %s\n", filename);
|
||||
return nullptr;
|
||||
}
|
||||
fseek(f, 0, SEEK_END);
|
||||
long fileSize = ftell(f);
|
||||
fclose(f);
|
||||
|
||||
if (fileSize < 16) {
|
||||
fprintf(stderr, "Empty or invalid .obj : %s\n", filename);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
struct stat sb;
|
||||
char *p;
|
||||
int fd;
|
||||
|
||||
fd = open (filename, O_RDONLY);
|
||||
if (fd == -1) {
|
||||
perror ("open");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (fstat (fd, &sb) == -1) {
|
||||
perror ("fstat");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!S_ISREG (sb.st_mode)) {
|
||||
fprintf (stderr, "%s is not a file\n", "lineitem.tbl");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
p = (char*)mmap (0, fileSize, PROT_READ, MAP_SHARED, fd, 0);
|
||||
|
||||
if (p == MAP_FAILED) {
|
||||
perror ("mmap");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (close (fd) == -1) {
|
||||
perror ("close");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
(*len) = fileSize;
|
||||
|
||||
return p;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
bool gz_load(std::vector<char>* buf, const char* filename)
|
||||
{
|
||||
#ifdef ENABLE_ZLIB
|
||||
gzFile file;
|
||||
file = gzopen (filename, "r");
|
||||
if (! file) {
|
||||
fprintf (stderr, "gzopen of '%s' failed: %s.\n", filename,
|
||||
strerror (errno));
|
||||
exit (EXIT_FAILURE);
|
||||
return false;
|
||||
}
|
||||
while (1) {
|
||||
int err;
|
||||
int bytes_read;
|
||||
unsigned char buffer[1024];
|
||||
bytes_read = gzread (file, buffer, 1024);
|
||||
buf->insert(buf->end(), buffer, buffer + 1024);
|
||||
//printf ("%s", buffer);
|
||||
if (bytes_read < 1024) {
|
||||
if (gzeof (file)) {
|
||||
break;
|
||||
}
|
||||
else {
|
||||
const char * error_string;
|
||||
error_string = gzerror (file, & err);
|
||||
if (err) {
|
||||
fprintf (stderr, "Error: %s.\n", error_string);
|
||||
exit (EXIT_FAILURE);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
gzclose (file);
|
||||
return true;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef ENABLE_ZSTD
|
||||
static off_t fsize_X(const char *filename)
|
||||
{
|
||||
struct stat st;
|
||||
if (stat(filename, &st) == 0) return st.st_size;
|
||||
/* error */
|
||||
printf("stat: %s : %s \n", filename, strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
static FILE* fopen_X(const char *filename, const char *instruction)
|
||||
{
|
||||
FILE* const inFile = fopen(filename, instruction);
|
||||
if (inFile) return inFile;
|
||||
/* error */
|
||||
printf("fopen: %s : %s \n", filename, strerror(errno));
|
||||
exit(2);
|
||||
}
|
||||
|
||||
static void* malloc_X(size_t size)
|
||||
{
|
||||
void* const buff = malloc(size);
|
||||
if (buff) return buff;
|
||||
/* error */
|
||||
printf("malloc: %s \n", strerror(errno));
|
||||
exit(3);
|
||||
}
|
||||
#endif
|
||||
|
||||
bool zstd_load(std::vector<char>* buf, const char* filename)
|
||||
{
|
||||
#ifdef ENABLE_ZSTD
|
||||
off_t const buffSize = fsize_X(filename);
|
||||
FILE* const inFile = fopen_X(filename, "rb");
|
||||
void* const buffer = malloc_X(buffSize);
|
||||
size_t const readSize = fread(buffer, 1, buffSize, inFile);
|
||||
if (readSize != (size_t)buffSize) {
|
||||
printf("fread: %s : %s \n", filename, strerror(errno));
|
||||
exit(4);
|
||||
}
|
||||
fclose(inFile);
|
||||
|
||||
unsigned long long const rSize = ZSTD_getDecompressedSize(buffer, buffSize);
|
||||
if (rSize==0) {
|
||||
printf("%s : original size unknown \n", filename);
|
||||
exit(5);
|
||||
}
|
||||
|
||||
buf->resize(rSize);
|
||||
|
||||
size_t const dSize = ZSTD_decompress(buf->data(), rSize, buffer, buffSize);
|
||||
|
||||
if (dSize != rSize) {
|
||||
printf("error decoding %s : %s \n", filename, ZSTD_getErrorName(dSize));
|
||||
exit(7);
|
||||
}
|
||||
|
||||
free(buffer);
|
||||
|
||||
return true;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
const char* get_file_data(size_t *len, const char* filename)
|
||||
{
|
||||
|
||||
const char *ext = strrchr(filename, '.');
|
||||
|
||||
size_t data_len = 0;
|
||||
const char* data = nullptr;
|
||||
|
||||
if (strcmp(ext, ".gz") == 0) {
|
||||
// gzipped data.
|
||||
|
||||
std::vector<char> buf;
|
||||
bool ret = gz_load(&buf, filename);
|
||||
|
||||
if (ret) {
|
||||
char *p = static_cast<char*>(malloc(buf.size() + 1)); // @fixme { implement deleter }
|
||||
memcpy(p, &buf.at(0), buf.size());
|
||||
p[buf.size()] = '\0';
|
||||
data = p;
|
||||
data_len = buf.size();
|
||||
}
|
||||
|
||||
} else if (strcmp(ext, ".zst") == 0) {
|
||||
printf("zstd\n");
|
||||
// Zstandard data.
|
||||
|
||||
std::vector<char> buf;
|
||||
bool ret = zstd_load(&buf, filename);
|
||||
|
||||
if (ret) {
|
||||
char *p = static_cast<char*>(malloc(buf.size() + 1)); // @fixme { implement deleter }
|
||||
memcpy(p, &buf.at(0), buf.size());
|
||||
p[buf.size()] = '\0';
|
||||
data = p;
|
||||
data_len = buf.size();
|
||||
}
|
||||
} else {
|
||||
|
||||
data = mmap_file(&data_len, filename);
|
||||
|
||||
}
|
||||
|
||||
(*len) = data_len;
|
||||
return data;
|
||||
}
|
||||
|
||||
|
||||
bool LoadObjAndConvert(float bmin[3], float bmax[3], const char* filename, int num_threads, bool verbose)
|
||||
{
|
||||
tinyobj_opt::attrib_t attrib;
|
||||
std::vector<tinyobj_opt::shape_t> shapes;
|
||||
std::vector<tinyobj_opt::material_t> materials;
|
||||
|
||||
auto load_t_begin = std::chrono::high_resolution_clock::now();
|
||||
size_t data_len = 0;
|
||||
const char* data = get_file_data(&data_len, filename);
|
||||
if (data == nullptr) {
|
||||
printf("failed to load file\n");
|
||||
exit(-1);
|
||||
return false;
|
||||
}
|
||||
auto load_t_end = std::chrono::high_resolution_clock::now();
|
||||
std::chrono::duration<double, std::milli> load_ms = load_t_end - load_t_begin;
|
||||
if (verbose) {
|
||||
std::cout << "filesize: " << data_len << std::endl;
|
||||
std::cout << "load time: " << load_ms.count() << " [msecs]" << std::endl;
|
||||
}
|
||||
|
||||
|
||||
tinyobj_opt::LoadOption option;
|
||||
option.req_num_threads = num_threads;
|
||||
option.verbose = verbose;
|
||||
bool ret = parseObj(&attrib, &shapes, &materials, data, data_len, option);
|
||||
|
||||
if (!ret) {
|
||||
std::cerr << "Failed to parse .obj" << std::endl;
|
||||
return false;
|
||||
}
|
||||
bmin[0] = bmin[1] = bmin[2] = std::numeric_limits<float>::max();
|
||||
bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits<float>::max();
|
||||
|
||||
//std::cout << "vertices.size() = " << attrib.vertices.size() << std::endl;
|
||||
//std::cout << "normals.size() = " << attrib.normals.size() << std::endl;
|
||||
|
||||
{
|
||||
DrawObject o;
|
||||
std::vector<float> vb; // pos(3float), normal(3float), color(3float)
|
||||
size_t face_offset = 0;
|
||||
for (size_t v = 0; v < attrib.face_num_verts.size(); v++) {
|
||||
assert(attrib.face_num_verts[v] % 3 == 0); // assume all triangle face.
|
||||
for (size_t f = 0; f < attrib.face_num_verts[v] / 3; f++) {
|
||||
tinyobj_opt::index_t idx0 = attrib.indices[face_offset+3*f+0];
|
||||
tinyobj_opt::index_t idx1 = attrib.indices[face_offset+3*f+1];
|
||||
tinyobj_opt::index_t idx2 = attrib.indices[face_offset+3*f+2];
|
||||
|
||||
float v[3][3];
|
||||
for (int k = 0; k < 3; k++) {
|
||||
int f0 = idx0.vertex_index;
|
||||
int f1 = idx1.vertex_index;
|
||||
int f2 = idx2.vertex_index;
|
||||
assert(f0 >= 0);
|
||||
assert(f1 >= 0);
|
||||
assert(f2 >= 0);
|
||||
|
||||
v[0][k] = attrib.vertices[3*f0+k];
|
||||
v[1][k] = attrib.vertices[3*f1+k];
|
||||
v[2][k] = attrib.vertices[3*f2+k];
|
||||
bmin[k] = std::min(v[0][k], bmin[k]);
|
||||
bmin[k] = std::min(v[1][k], bmin[k]);
|
||||
bmin[k] = std::min(v[2][k], bmin[k]);
|
||||
bmax[k] = std::max(v[0][k], bmax[k]);
|
||||
bmax[k] = std::max(v[1][k], bmax[k]);
|
||||
bmax[k] = std::max(v[2][k], bmax[k]);
|
||||
}
|
||||
|
||||
float n[3][3];
|
||||
|
||||
if (attrib.normals.size() > 0) {
|
||||
int nf0 = idx0.normal_index;
|
||||
int nf1 = idx1.normal_index;
|
||||
int nf2 = idx2.normal_index;
|
||||
|
||||
if (nf0 >= 0 && nf1 >= 0 && nf2 >= 0) {
|
||||
assert(3*nf0+2 < attrib.normals.size());
|
||||
assert(3*nf1+2 < attrib.normals.size());
|
||||
assert(3*nf2+2 < attrib.normals.size());
|
||||
for (int k = 0; k < 3; k++) {
|
||||
n[0][k] = attrib.normals[3*nf0+k];
|
||||
n[1][k] = attrib.normals[3*nf1+k];
|
||||
n[2][k] = attrib.normals[3*nf2+k];
|
||||
}
|
||||
} else {
|
||||
// compute geometric normal
|
||||
CalcNormal(n[0], v[0], v[1], v[2]);
|
||||
n[1][0] = n[0][0]; n[1][1] = n[0][1]; n[1][2] = n[0][2];
|
||||
n[2][0] = n[0][0]; n[2][1] = n[0][1]; n[2][2] = n[0][2];
|
||||
}
|
||||
} else {
|
||||
// compute geometric normal
|
||||
CalcNormal(n[0], v[0], v[1], v[2]);
|
||||
n[1][0] = n[0][0]; n[1][1] = n[0][1]; n[1][2] = n[0][2];
|
||||
n[2][0] = n[0][0]; n[2][1] = n[0][1]; n[2][2] = n[0][2];
|
||||
}
|
||||
|
||||
for (int k = 0; k < 3; k++) {
|
||||
vb.push_back(v[k][0]);
|
||||
vb.push_back(v[k][1]);
|
||||
vb.push_back(v[k][2]);
|
||||
vb.push_back(n[k][0]);
|
||||
vb.push_back(n[k][1]);
|
||||
vb.push_back(n[k][2]);
|
||||
// Use normal as color.
|
||||
float c[3] = {n[k][0], n[k][1], n[k][2]};
|
||||
float len2 = c[0] * c[0] + c[1] * c[1] + c[2] * c[2];
|
||||
if (len2 > 1.0e-6f) {
|
||||
float len = sqrtf(len2);
|
||||
|
||||
c[0] /= len;
|
||||
c[1] /= len;
|
||||
c[2] /= len;
|
||||
}
|
||||
vb.push_back(c[0] * 0.5 + 0.5);
|
||||
vb.push_back(c[1] * 0.5 + 0.5);
|
||||
vb.push_back(c[2] * 0.5 + 0.5);
|
||||
}
|
||||
}
|
||||
face_offset += attrib.face_num_verts[v];
|
||||
}
|
||||
|
||||
o.vb = 0;
|
||||
o.numTriangles = 0;
|
||||
if (vb.size() > 0) {
|
||||
glGenBuffers(1, &o.vb);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, o.vb);
|
||||
glBufferData(GL_ARRAY_BUFFER, vb.size() * sizeof(float), &vb.at(0), GL_STATIC_DRAW);
|
||||
o.numTriangles = vb.size() / 9 / 3;
|
||||
}
|
||||
|
||||
gDrawObjects.push_back(o);
|
||||
}
|
||||
|
||||
printf("bmin = %f, %f, %f\n", bmin[0], bmin[1], bmin[2]);
|
||||
printf("bmax = %f, %f, %f\n", bmax[0], bmax[1], bmax[2]);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void reshapeFunc(GLFWwindow* window, int w, int h)
|
||||
{
|
||||
(void)window;
|
||||
// for retinal display.
|
||||
int fb_w, fb_h;
|
||||
glfwGetFramebufferSize(window, &fb_w, &fb_h);
|
||||
|
||||
glViewport(0, 0, fb_w, fb_h);
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glLoadIdentity();
|
||||
gluPerspective(45.0, (float)w / (float)h, 0.01f, 100.0f);
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
|
||||
width = w;
|
||||
height = h;
|
||||
}
|
||||
|
||||
void keyboardFunc(GLFWwindow *window, int key, int scancode, int action, int mods) {
|
||||
(void)window;
|
||||
(void)scancode;
|
||||
(void)mods;
|
||||
if(action == GLFW_PRESS || action == GLFW_REPEAT){
|
||||
// Move camera
|
||||
float mv_x = 0, mv_y = 0, mv_z = 0;
|
||||
if(key == GLFW_KEY_K) mv_x += 1;
|
||||
else if(key == GLFW_KEY_J) mv_x += -1;
|
||||
else if(key == GLFW_KEY_L) mv_y += 1;
|
||||
else if(key == GLFW_KEY_H) mv_y += -1;
|
||||
else if(key == GLFW_KEY_P) mv_z += 1;
|
||||
else if(key == GLFW_KEY_N) mv_z += -1;
|
||||
//camera.move(mv_x * 0.05, mv_y * 0.05, mv_z * 0.05);
|
||||
// Close window
|
||||
if(key == GLFW_KEY_Q || key == GLFW_KEY_ESCAPE) glfwSetWindowShouldClose(window, GL_TRUE);
|
||||
|
||||
//init_frame = true;
|
||||
}
|
||||
}
|
||||
|
||||
void clickFunc(GLFWwindow* window, int button, int action, int mods){
|
||||
(void)window;
|
||||
(void)mods;
|
||||
if(button == GLFW_MOUSE_BUTTON_LEFT){
|
||||
if(action == GLFW_PRESS){
|
||||
mouseLeftPressed = true;
|
||||
trackball(prev_quat, 0.0, 0.0, 0.0, 0.0);
|
||||
} else if(action == GLFW_RELEASE){
|
||||
mouseLeftPressed = false;
|
||||
}
|
||||
}
|
||||
if(button == GLFW_MOUSE_BUTTON_RIGHT){
|
||||
if(action == GLFW_PRESS){
|
||||
mouseRightPressed = true;
|
||||
} else if(action == GLFW_RELEASE){
|
||||
mouseRightPressed = false;
|
||||
}
|
||||
}
|
||||
if(button == GLFW_MOUSE_BUTTON_MIDDLE){
|
||||
if(action == GLFW_PRESS){
|
||||
mouseMiddlePressed = true;
|
||||
} else if(action == GLFW_RELEASE){
|
||||
mouseMiddlePressed = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void motionFunc(GLFWwindow* window, double mouse_x, double mouse_y){
|
||||
(void)window;
|
||||
float rotScale = 1.0f;
|
||||
float transScale = 2.0f;
|
||||
|
||||
if(mouseLeftPressed){
|
||||
trackball(prev_quat,
|
||||
rotScale * (2.0f * prevMouseX - width) / (float)width,
|
||||
rotScale * (height - 2.0f * prevMouseY) / (float)height,
|
||||
rotScale * (2.0f * mouse_x - width) / (float)width,
|
||||
rotScale * (height - 2.0f * mouse_y) / (float)height);
|
||||
|
||||
add_quats(prev_quat, curr_quat, curr_quat);
|
||||
} else if (mouseMiddlePressed) {
|
||||
eye[0] -= transScale * (mouse_x - prevMouseX) / (float)width;
|
||||
lookat[0] -= transScale * (mouse_x - prevMouseX) / (float)width;
|
||||
eye[1] += transScale * (mouse_y - prevMouseY) / (float)height;
|
||||
lookat[1] += transScale * (mouse_y - prevMouseY) / (float)height;
|
||||
} else if (mouseRightPressed) {
|
||||
eye[2] += transScale * (mouse_y - prevMouseY) / (float)height;
|
||||
lookat[2] += transScale * (mouse_y - prevMouseY) / (float)height;
|
||||
}
|
||||
|
||||
// Update mouse point
|
||||
prevMouseX = mouse_x;
|
||||
prevMouseY = mouse_y;
|
||||
}
|
||||
|
||||
void Draw(const std::vector<DrawObject>& drawObjects)
|
||||
{
|
||||
glPolygonMode(GL_FRONT, GL_FILL);
|
||||
glPolygonMode(GL_BACK, GL_FILL);
|
||||
|
||||
glEnable(GL_POLYGON_OFFSET_FILL);
|
||||
glPolygonOffset(1.0, 1.0);
|
||||
glColor3f(1.0f, 1.0f, 1.0f);
|
||||
for (size_t i = 0; i < drawObjects.size(); i++) {
|
||||
DrawObject o = drawObjects[i];
|
||||
if (o.vb < 1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, o.vb);
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glEnableClientState(GL_NORMAL_ARRAY);
|
||||
glEnableClientState(GL_COLOR_ARRAY);
|
||||
glVertexPointer(3, GL_FLOAT, 36, (const void*)0);
|
||||
glNormalPointer(GL_FLOAT, 36, (const void*)(sizeof(float)*3));
|
||||
glColorPointer(3, GL_FLOAT, 36, (const void*)(sizeof(float)*6));
|
||||
|
||||
glDrawArrays(GL_TRIANGLES, 0, 3 * o.numTriangles);
|
||||
CheckErrors("drawarrays");
|
||||
}
|
||||
|
||||
// draw wireframe
|
||||
glDisable(GL_POLYGON_OFFSET_FILL);
|
||||
glPolygonMode(GL_FRONT, GL_LINE);
|
||||
glPolygonMode(GL_BACK, GL_LINE);
|
||||
|
||||
glColor3f(0.0f, 0.0f, 0.4f);
|
||||
for (size_t i = 0; i < drawObjects.size(); i++) {
|
||||
DrawObject o = drawObjects[i];
|
||||
if (o.vb < 1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, o.vb);
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glEnableClientState(GL_NORMAL_ARRAY);
|
||||
glDisableClientState(GL_COLOR_ARRAY);
|
||||
glVertexPointer(3, GL_FLOAT, 36, (const void*)0);
|
||||
glNormalPointer(GL_FLOAT, 36, (const void*)(sizeof(float)*3));
|
||||
|
||||
glDrawArrays(GL_TRIANGLES, 0, 3 * o.numTriangles);
|
||||
CheckErrors("drawarrays");
|
||||
}
|
||||
}
|
||||
|
||||
static void Init() {
|
||||
trackball(curr_quat, 0, 0, 0, 0);
|
||||
|
||||
eye[0] = 0.0f;
|
||||
eye[1] = 0.0f;
|
||||
eye[2] = 3.0f;
|
||||
|
||||
lookat[0] = 0.0f;
|
||||
lookat[1] = 0.0f;
|
||||
lookat[2] = 0.0f;
|
||||
|
||||
up[0] = 0.0f;
|
||||
up[1] = 1.0f;
|
||||
up[2] = 0.0f;
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
if (argc < 2) {
|
||||
std::cout << "view input.obj <num_threads> <benchark_only> <verbose>" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool benchmark_only = false;
|
||||
int num_threads = -1;
|
||||
bool verbose = false;
|
||||
|
||||
if (argc > 2) {
|
||||
num_threads = atoi(argv[2]);
|
||||
}
|
||||
|
||||
if (argc > 3) {
|
||||
benchmark_only = (atoi(argv[3]) > 0) ? true : false;
|
||||
}
|
||||
|
||||
if (argc > 4) {
|
||||
verbose = true;
|
||||
}
|
||||
|
||||
if (benchmark_only) {
|
||||
|
||||
tinyobj_opt::attrib_t attrib;
|
||||
std::vector<tinyobj_opt::shape_t> shapes;
|
||||
std::vector<tinyobj_opt::material_t> materials;
|
||||
|
||||
size_t data_len = 0;
|
||||
const char* data = get_file_data(&data_len, argv[1]);
|
||||
if (data == nullptr) {
|
||||
printf("failed to load file\n");
|
||||
exit(-1);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (data_len < 4) {
|
||||
printf("Empty file\n");
|
||||
exit(-1);
|
||||
return false;
|
||||
}
|
||||
printf("filesize: %d\n", (int)data_len);
|
||||
tinyobj_opt::LoadOption option;
|
||||
option.req_num_threads = num_threads;
|
||||
option.verbose = true;
|
||||
|
||||
bool ret = parseObj(&attrib, &shapes, &materials, data, data_len, option);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
Init();
|
||||
|
||||
std::cout << "Initialize GLFW..." << std::endl;
|
||||
|
||||
if(!glfwInit()){
|
||||
std::cerr << "Failed to initialize GLFW." << std::endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::cout << "GLFW OK." << std::endl;
|
||||
|
||||
|
||||
window = glfwCreateWindow(width, height, "Obj viewer", NULL, NULL);
|
||||
if(window == NULL){
|
||||
std::cerr << "Failed to open GLFW window. " << std::endl;
|
||||
glfwTerminate();
|
||||
return 1;
|
||||
}
|
||||
|
||||
glfwMakeContextCurrent(window);
|
||||
glfwSwapInterval(1);
|
||||
|
||||
// Callback
|
||||
glfwSetWindowSizeCallback(window, reshapeFunc);
|
||||
glfwSetKeyCallback(window, keyboardFunc);
|
||||
glfwSetMouseButtonCallback(window, clickFunc);
|
||||
glfwSetCursorPosCallback(window, motionFunc);
|
||||
|
||||
glewExperimental = true;
|
||||
if (glewInit() != GLEW_OK) {
|
||||
std::cerr << "Failed to initialize GLEW." << std::endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
reshapeFunc(window, width, height);
|
||||
|
||||
float bmin[3], bmax[3];
|
||||
if (false == LoadObjAndConvert(bmin, bmax, argv[1], num_threads, verbose)) {
|
||||
printf("failed to load & conv\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
float maxExtent = 0.5f * (bmax[0] - bmin[0]);
|
||||
if (maxExtent < 0.5f * (bmax[1] - bmin[1])) {
|
||||
maxExtent = 0.5f * (bmax[1] - bmin[1]);
|
||||
}
|
||||
if (maxExtent < 0.5f * (bmax[2] - bmin[2])) {
|
||||
maxExtent = 0.5f * (bmax[2] - bmin[2]);
|
||||
}
|
||||
|
||||
while(glfwWindowShouldClose(window) == GL_FALSE) {
|
||||
glfwPollEvents();
|
||||
glClearColor(0.1f, 0.2f, 0.3f, 1.0f);
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
|
||||
// camera & rotate
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
GLfloat mat[4][4];
|
||||
gluLookAt(eye[0], eye[1], eye[2], lookat[0], lookat[1], lookat[2], up[0], up[1], up[2]);
|
||||
build_rotmatrix(mat, curr_quat);
|
||||
glMultMatrixf(&mat[0][0]);
|
||||
|
||||
// Fit to -1, 1
|
||||
glScalef(1.0f / maxExtent, 1.0f / maxExtent, 1.0f / maxExtent);
|
||||
|
||||
// Centerize object.
|
||||
glTranslatef(-0.5*(bmax[0] + bmin[0]), -0.5*(bmax[1] + bmin[1]), -0.5*(bmax[2] + bmin[2]));
|
||||
|
||||
Draw(gDrawObjects);
|
||||
|
||||
glfwSwapBuffers(window);
|
||||
}
|
||||
|
||||
glfwTerminate();
|
||||
}
|
||||
Reference in New Issue
Block a user