Merge branch 'master' into gltf2_blendshape_export
Kim Kulling
GitHub
commit
3c97447c9c
|
|
@ -583,17 +583,19 @@ ENDIF()
|
|||
ADD_SUBDIRECTORY( code/ )
|
||||
IF ( ASSIMP_BUILD_ASSIMP_TOOLS )
|
||||
# The viewer for windows only
|
||||
IF ( WIN32 AND DirectX_D3DX9_LIBRARY )
|
||||
OPTION ( ASSIMP_BUILD_ASSIMP_VIEW "If the Assimp view tool is built. (requires DirectX)" ${DirectX_FOUND} )
|
||||
IF ( WIN32 )
|
||||
OPTION ( ASSIMP_BUILD_ASSIMP_VIEW "If the Assimp view tool is built. (requires DirectX)" OFF )
|
||||
IF ( ASSIMP_BUILD_ASSIMP_VIEW )
|
||||
ADD_SUBDIRECTORY( tools/assimp_view/ )
|
||||
ENDIF ()
|
||||
ENDIF ()
|
||||
# Te command line tool
|
||||
# The command line tool
|
||||
ADD_SUBDIRECTORY( tools/assimp_cmd/ )
|
||||
ENDIF ()
|
||||
|
||||
IF ( ASSIMP_BUILD_SAMPLES)
|
||||
SET( SAMPLES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/samples )
|
||||
SET( SAMPLES_SHARED_CODE_DIR ${SAMPLES_DIR}/SharedCode )
|
||||
IF ( WIN32 )
|
||||
ADD_SUBDIRECTORY( samples/SimpleTexturedOpenGL/ )
|
||||
ADD_SUBDIRECTORY( samples/SimpleTexturedDirectx11 )
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ if(MSVC)
|
|||
endif()
|
||||
set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" )
|
||||
|
||||
file(TO_NATIVE_PATH ${_IMPORT_PREFIX} _IMPORT_PREFIX)
|
||||
file(TO_NATIVE_PATH "${_IMPORT_PREFIX}" _IMPORT_PREFIX)
|
||||
|
||||
if(ASSIMP_BUILD_SHARED_LIBS)
|
||||
set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@")
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ if(MSVC)
|
|||
endif()
|
||||
set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" )
|
||||
|
||||
file(TO_NATIVE_PATH ${_IMPORT_PREFIX} _IMPORT_PREFIX)
|
||||
file(TO_NATIVE_PATH "${_IMPORT_PREFIX}" _IMPORT_PREFIX)
|
||||
|
||||
if(ASSIMP_BUILD_SHARED_LIBS)
|
||||
set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_SHARED_LIBRARY_SUFFIX@")
|
||||
|
|
|
|||
|
|
@ -185,8 +185,6 @@ SET( Common_SRCS
|
|||
Common/ScenePreprocessor.cpp
|
||||
Common/ScenePreprocessor.h
|
||||
Common/SkeletonMeshBuilder.cpp
|
||||
Common/SplitByBoneCountProcess.cpp
|
||||
Common/SplitByBoneCountProcess.h
|
||||
Common/StandardShapes.cpp
|
||||
Common/TargetAnimation.cpp
|
||||
Common/TargetAnimation.h
|
||||
|
|
@ -737,6 +735,8 @@ SET( PostProcessing_SRCS
|
|||
PostProcessing/ArmaturePopulate.h
|
||||
PostProcessing/GenBoundingBoxesProcess.cpp
|
||||
PostProcessing/GenBoundingBoxesProcess.h
|
||||
PostProcessing/SplitByBoneCountProcess.cpp
|
||||
PostProcessing/SplitByBoneCountProcess.h
|
||||
)
|
||||
SOURCE_GROUP( PostProcessing FILES ${PostProcessing_SRCS})
|
||||
|
||||
|
|
|
|||
|
|
@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
|
|||
|
||||
Copyright (c) 2006-2020, assimp team
|
||||
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
|
|
@ -43,42 +41,40 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
/** @file Implementation of BaseProcess */
|
||||
|
||||
#include <assimp/BaseImporter.h>
|
||||
#include "BaseProcess.h"
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
#include <assimp/scene.h>
|
||||
#include "Importer.h"
|
||||
#include <assimp/BaseImporter.h>
|
||||
#include <assimp/scene.h>
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
|
||||
using namespace Assimp;
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Constructor to be privately used by Importer
|
||||
BaseProcess::BaseProcess() AI_NO_EXCEPT
|
||||
: shared()
|
||||
, progress()
|
||||
{
|
||||
: shared(),
|
||||
progress() {
|
||||
// empty
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Destructor, private as well
|
||||
BaseProcess::~BaseProcess()
|
||||
{
|
||||
BaseProcess::~BaseProcess() {
|
||||
// nothing to do here
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BaseProcess::ExecuteOnScene( Importer* pImp)
|
||||
{
|
||||
ai_assert(NULL != pImp && NULL != pImp->Pimpl()->mScene);
|
||||
void BaseProcess::ExecuteOnScene(Importer *pImp) {
|
||||
ai_assert( nullptr != pImp );
|
||||
ai_assert( nullptr != pImp->Pimpl()->mScene);
|
||||
|
||||
progress = pImp->GetProgressHandler();
|
||||
ai_assert(progress);
|
||||
ai_assert(nullptr != progress);
|
||||
|
||||
SetupProperties(pImp);
|
||||
|
||||
// catch exceptions thrown inside the PostProcess-Step
|
||||
try
|
||||
{
|
||||
try {
|
||||
Execute(pImp->Pimpl()->mScene);
|
||||
|
||||
} catch (const std::exception &err) {
|
||||
|
|
@ -94,14 +90,11 @@ void BaseProcess::ExecuteOnScene( Importer* pImp)
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BaseProcess::SetupProperties(const Importer* /*pImp*/)
|
||||
{
|
||||
void BaseProcess::SetupProperties(const Importer * /*pImp*/) {
|
||||
// the default implementation does nothing
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool BaseProcess::RequireVerboseFormat() const
|
||||
{
|
||||
bool BaseProcess::RequireVerboseFormat() const {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
|
|||
|
||||
Copyright (c) 2006-2020, assimp team
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
|
|
@ -44,9 +43,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#ifndef INCLUDED_AI_BASEPROCESS_H
|
||||
#define INCLUDED_AI_BASEPROCESS_H
|
||||
|
||||
#include <map>
|
||||
#include <assimp/GenericProperty.h>
|
||||
|
||||
#include <map>
|
||||
|
||||
struct aiScene;
|
||||
|
||||
namespace Assimp {
|
||||
|
|
@ -60,26 +60,19 @@ class Importer;
|
|||
* to provide additional information to other steps. This is primarily
|
||||
* intended for cross-step optimizations.
|
||||
*/
|
||||
class SharedPostProcessInfo
|
||||
{
|
||||
class SharedPostProcessInfo {
|
||||
public:
|
||||
|
||||
struct Base
|
||||
{
|
||||
virtual ~Base()
|
||||
{}
|
||||
struct Base {
|
||||
virtual ~Base() {}
|
||||
};
|
||||
|
||||
//! Represents data that is allocated on the heap, thus needs to be deleted
|
||||
template <typename T>
|
||||
struct THeapData : public Base
|
||||
{
|
||||
explicit THeapData(T* in)
|
||||
: data (in)
|
||||
{}
|
||||
struct THeapData : public Base {
|
||||
explicit THeapData(T *in) :
|
||||
data(in) {}
|
||||
|
||||
~THeapData()
|
||||
{
|
||||
~THeapData() {
|
||||
delete data;
|
||||
}
|
||||
T *data;
|
||||
|
|
@ -87,14 +80,11 @@ public:
|
|||
|
||||
//! Represents static, by-value data not allocated on the heap
|
||||
template <typename T>
|
||||
struct TStaticData : public Base
|
||||
{
|
||||
explicit TStaticData(T in)
|
||||
: data (in)
|
||||
{}
|
||||
struct TStaticData : public Base {
|
||||
explicit TStaticData(T in) :
|
||||
data(in) {}
|
||||
|
||||
~TStaticData()
|
||||
{}
|
||||
~TStaticData() {}
|
||||
|
||||
T data;
|
||||
};
|
||||
|
|
@ -104,20 +94,16 @@ public:
|
|||
typedef std::map<KeyType, Base *> PropertyMap;
|
||||
|
||||
public:
|
||||
|
||||
//! Destructor
|
||||
~SharedPostProcessInfo()
|
||||
{
|
||||
~SharedPostProcessInfo() {
|
||||
Clean();
|
||||
}
|
||||
|
||||
//! Remove all stored properties from the table
|
||||
void Clean()
|
||||
{
|
||||
void Clean() {
|
||||
// invoke the virtual destructor for all stored properties
|
||||
for (PropertyMap::iterator it = pmap.begin(), end = pmap.end();
|
||||
it != end; ++it)
|
||||
{
|
||||
it != end; ++it) {
|
||||
delete (*it).second;
|
||||
}
|
||||
pmap.clear();
|
||||
|
|
@ -135,14 +121,11 @@ public:
|
|||
AddProperty(name, (Base *)new TStaticData<T>(in));
|
||||
}
|
||||
|
||||
|
||||
//! Get a heap property
|
||||
template <typename T>
|
||||
bool GetProperty( const char* name, T*& out ) const
|
||||
{
|
||||
bool GetProperty(const char *name, T *&out) const {
|
||||
THeapData<T> *t = (THeapData<T> *)GetPropertyInternal(name);
|
||||
if(!t)
|
||||
{
|
||||
if (!t) {
|
||||
out = NULL;
|
||||
return false;
|
||||
}
|
||||
|
|
@ -152,53 +135,34 @@ public:
|
|||
|
||||
//! Get a static, by-value property
|
||||
template <typename T>
|
||||
bool GetProperty( const char* name, T& out ) const
|
||||
{
|
||||
bool GetProperty(const char *name, T &out) const {
|
||||
TStaticData<T> *t = (TStaticData<T> *)GetPropertyInternal(name);
|
||||
if(!t)return false;
|
||||
if ( nullptr == t) {
|
||||
return false;
|
||||
}
|
||||
out = t->data;
|
||||
return true;
|
||||
}
|
||||
|
||||
//! Remove a property of a specific type
|
||||
void RemoveProperty(const char *name) {
|
||||
SetGenericPropertyPtr<Base>(pmap,name,NULL);
|
||||
SetGenericPropertyPtr<Base>(pmap, name, nullptr );
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
void AddProperty(const char *name, Base *data) {
|
||||
SetGenericPropertyPtr<Base>(pmap, name, data);
|
||||
}
|
||||
|
||||
Base *GetPropertyInternal(const char *name) const {
|
||||
return GetGenericProperty<Base*>(pmap,name,NULL);
|
||||
return GetGenericProperty<Base *>(pmap, name, nullptr );
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
//! Map of all stored properties
|
||||
PropertyMap pmap;
|
||||
};
|
||||
|
||||
#if 0
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** @brief Represents a dependency table for a postprocessing steps.
|
||||
*
|
||||
* For future use.
|
||||
*/
|
||||
struct PPDependencyTable
|
||||
{
|
||||
unsigned int execute_me_before_these;
|
||||
unsigned int execute_me_after_these;
|
||||
unsigned int only_if_these_are_not_specified;
|
||||
unsigned int mutually_exclusive_with;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#define AI_SPP_SPATIAL_SORT "$Spat"
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
|
@ -258,7 +222,6 @@ public:
|
|||
*/
|
||||
virtual void Execute(aiScene *pScene) = 0;
|
||||
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Assign a new SharedPostProcessInfo to the step. This object
|
||||
* allows multiple postprocess steps to share data.
|
||||
|
|
@ -276,7 +239,6 @@ public:
|
|||
}
|
||||
|
||||
protected:
|
||||
|
||||
/** See the doc of #SharedPostProcessInfo for more details */
|
||||
SharedPostProcessInfo *shared;
|
||||
|
||||
|
|
@ -284,7 +246,6 @@ protected:
|
|||
ProgressHandler *progress;
|
||||
};
|
||||
|
||||
|
||||
} // end of namespace Assimp
|
||||
|
||||
#endif // AI_BASEPROCESS_H_INC
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ corresponding preprocessor flag to selectively disable steps.
|
|||
# include "PostProcessing/OptimizeGraph.h"
|
||||
#endif
|
||||
#ifndef ASSIMP_BUILD_NO_SPLITBYBONECOUNT_PROCESS
|
||||
# include "Common/SplitByBoneCountProcess.h"
|
||||
# include "PostProcessing/SplitByBoneCountProcess.h"
|
||||
#endif
|
||||
#ifndef ASSIMP_BUILD_NO_DEBONE_PROCESS
|
||||
# include "PostProcessing/DeboneProcess.h"
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#define AI_SPLITBYBONECOUNTPROCESS_H_INC
|
||||
|
||||
#include <vector>
|
||||
#include "BaseProcess.h"
|
||||
#include "Common/BaseProcess.h"
|
||||
|
||||
#include <assimp/mesh.h>
|
||||
#include <assimp/scene.h>
|
||||
|
|
@ -111,8 +111,9 @@ const aiImporterDesc *glTF2Importer::GetInfo() const {
|
|||
bool glTF2Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /* checkSig */) const {
|
||||
const std::string &extension = GetExtension(pFile);
|
||||
|
||||
if (extension != "gltf" && extension != "glb")
|
||||
if (extension != "gltf" && extension != "glb") {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pIOHandler) {
|
||||
glTF2::Asset asset(pIOHandler);
|
||||
|
|
@ -323,10 +324,11 @@ static inline bool CheckValidFacesIndices(aiFace *faces, unsigned nFaces, unsign
|
|||
for (unsigned i = 0; i < nFaces; ++i) {
|
||||
for (unsigned j = 0; j < faces[i].mNumIndices; ++j) {
|
||||
unsigned idx = faces[i].mIndices[j];
|
||||
if (idx >= nVerts)
|
||||
if (idx >= nVerts) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
#endif // ASSIMP_BUILD_DEBUG
|
||||
|
|
@ -861,7 +863,19 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
|
|||
if (node.skin) {
|
||||
for (int primitiveNo = 0; primitiveNo < count; ++primitiveNo) {
|
||||
aiMesh *mesh = pScene->mMeshes[meshOffsets[mesh_idx] + primitiveNo];
|
||||
mesh->mNumBones = static_cast<unsigned int>(node.skin->jointNames.size());
|
||||
unsigned int numBones =static_cast<unsigned int>(node.skin->jointNames.size());
|
||||
|
||||
std::vector<std::vector<aiVertexWeight>> weighting(numBones);
|
||||
BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
|
||||
|
||||
unsigned int realNumBones = 0;
|
||||
for (uint32_t i = 0; i < numBones; ++i) {
|
||||
if (weighting[i].size() > 0) {
|
||||
realNumBones++;
|
||||
}
|
||||
}
|
||||
|
||||
mesh->mNumBones = static_cast<unsigned int>(realNumBones);
|
||||
mesh->mBones = new aiBone *[mesh->mNumBones];
|
||||
|
||||
// GLTF and Assimp choose to store bone weights differently.
|
||||
|
|
@ -873,13 +887,14 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
|
|||
// both because it's somewhat slow and because, for many applications,
|
||||
// we then need to reconvert the data back into the vertex-to-bone
|
||||
// mapping which makes things doubly-slow.
|
||||
std::vector<std::vector<aiVertexWeight>> weighting(mesh->mNumBones);
|
||||
BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
|
||||
|
||||
mat4 *pbindMatrices = nullptr;
|
||||
node.skin->inverseBindMatrices->ExtractData(pbindMatrices);
|
||||
|
||||
for (uint32_t i = 0; i < mesh->mNumBones; ++i) {
|
||||
int cb = 0;
|
||||
for (uint32_t i = 0; i < numBones; ++i) {
|
||||
const std::vector<aiVertexWeight> &weights = weighting[i];
|
||||
if (weights.size() > 0) {
|
||||
aiBone *bone = new aiBone();
|
||||
|
||||
Ref<Node> joint = node.skin->jointNames[i];
|
||||
|
|
@ -893,23 +908,12 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
|
|||
bone->mName = (kDefaultName + postfix);
|
||||
}
|
||||
GetNodeTransform(bone->mOffsetMatrix, *joint);
|
||||
|
||||
CopyValue(pbindMatrices[i], bone->mOffsetMatrix);
|
||||
|
||||
std::vector<aiVertexWeight> &weights = weighting[i];
|
||||
|
||||
bone->mNumWeights = static_cast<uint32_t>(weights.size());
|
||||
if (bone->mNumWeights > 0) {
|
||||
bone->mWeights = new aiVertexWeight[bone->mNumWeights];
|
||||
memcpy(bone->mWeights, weights.data(), bone->mNumWeights * sizeof(aiVertexWeight));
|
||||
} else {
|
||||
// Assimp expects all bones to have at least 1 weight.
|
||||
bone->mWeights = new aiVertexWeight[1];
|
||||
bone->mNumWeights = 1;
|
||||
bone->mWeights->mVertexId = 0;
|
||||
bone->mWeights->mWeight = 0.f;
|
||||
mesh->mBones[cb++] = bone;
|
||||
}
|
||||
mesh->mBones[i] = bone;
|
||||
}
|
||||
|
||||
if (pbindMatrices) {
|
||||
|
|
@ -1232,9 +1236,10 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset &r) {
|
|||
|
||||
int numEmbeddedTexs = 0;
|
||||
for (size_t i = 0; i < r.images.Size(); ++i) {
|
||||
if (r.images[i].HasData())
|
||||
if (r.images[i].HasData()) {
|
||||
numEmbeddedTexs += 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (numEmbeddedTexs == 0)
|
||||
return;
|
||||
|
|
@ -1244,7 +1249,9 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset &r) {
|
|||
// Add the embedded textures
|
||||
for (size_t i = 0; i < r.images.Size(); ++i) {
|
||||
Image &img = r.images[i];
|
||||
if (!img.HasData()) continue;
|
||||
if (!img.HasData()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
int idx = mScene->mNumTextures++;
|
||||
embeddedTexIdxs[i] = idx;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.0)
|
|||
|
||||
project(zip
|
||||
LANGUAGES C
|
||||
VERSION "0.1.15")
|
||||
VERSION "0.1.18")
|
||||
set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
|
||||
|
||||
option(CMAKE_DISABLE_TESTING "Disable test creation" OFF)
|
||||
|
|
@ -16,10 +16,6 @@ elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR
|
|||
"${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
|
||||
"${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
|
||||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra -Werror -pedantic")
|
||||
if(ENABLE_COVERAGE)
|
||||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
|
||||
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
|
||||
endif()
|
||||
endif (MSVC)
|
||||
|
||||
# zip
|
||||
|
|
@ -35,7 +31,7 @@ if (NOT CMAKE_DISABLE_TESTING)
|
|||
enable_testing()
|
||||
add_subdirectory(test)
|
||||
find_package(Sanitizers)
|
||||
add_sanitizers(${PROJECT_NAME} ${test_out} ${test_miniz_out})
|
||||
add_sanitizers(${PROJECT_NAME} ${test_out})
|
||||
endif()
|
||||
|
||||
####
|
||||
|
|
|
|||
|
|
@ -1,10 +1,8 @@
|
|||
### A portable (OSX/Linux/Windows), simple zip library written in C
|
||||
This is done by hacking awesome [miniz](https://code.google.com/p/miniz) library and layering functions on top of the miniz v1.15 API.
|
||||
|
||||
[](https://ci.appveyor.com/project/kuba--/zip)
|
||||
[](https://travis-ci.org/kuba--/zip)
|
||||
[](https://github.com/kuba--/zip/actions?query=workflow%3Abuild)
|
||||
[](https://github.com/kuba--/zip/releases)
|
||||
[](https://codecov.io/gh/kuba--/zip)
|
||||
|
||||
|
||||
# The Idea
|
||||
|
|
@ -213,6 +211,53 @@ func main() {
|
|||
}
|
||||
```
|
||||
|
||||
### Rust (ffi)
|
||||
```rust
|
||||
extern crate libc;
|
||||
use std::ffi::CString;
|
||||
|
||||
#[repr(C)]
|
||||
pub struct Zip {
|
||||
_private: [u8; 0],
|
||||
}
|
||||
|
||||
#[link(name = "zip")]
|
||||
extern "C" {
|
||||
fn zip_open(path: *const libc::c_char, level: libc::c_int, mode: libc::c_char) -> *mut Zip;
|
||||
fn zip_close(zip: *mut Zip) -> libc::c_void;
|
||||
|
||||
fn zip_entry_open(zip: *mut Zip, entryname: *const libc::c_char) -> libc::c_int;
|
||||
fn zip_entry_close(zip: *mut Zip) -> libc::c_int;
|
||||
fn zip_entry_write(
|
||||
zip: *mut Zip,
|
||||
buf: *const libc::c_void,
|
||||
bufsize: libc::size_t,
|
||||
) -> libc::c_int;
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let path = CString::new("/tmp/test.zip").unwrap();
|
||||
let mode: libc::c_char = 'w' as libc::c_char;
|
||||
|
||||
let entryname = CString::new("test.txt").unwrap();
|
||||
let content = "test content\0";
|
||||
|
||||
unsafe {
|
||||
let zip: *mut Zip = zip_open(path.as_ptr(), 5, mode);
|
||||
{
|
||||
zip_entry_open(zip, entryname.as_ptr());
|
||||
{
|
||||
let buf = content.as_ptr() as *const libc::c_void;
|
||||
let bufsize = content.len() as libc::size_t;
|
||||
zip_entry_write(zip, buf, bufsize);
|
||||
}
|
||||
zip_entry_close(zip);
|
||||
}
|
||||
zip_close(zip);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Ruby (ffi)
|
||||
Install _ffi_ gem.
|
||||
```shell
|
||||
|
|
|
|||
|
|
@ -222,6 +222,20 @@ void zip_close(struct zip_t *zip) {
|
|||
}
|
||||
}
|
||||
|
||||
int zip_is64(struct zip_t *zip) {
|
||||
if (!zip) {
|
||||
// zip_t handler is not initialized
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!zip->archive.m_pState) {
|
||||
// zip state is not initialized
|
||||
return -1;
|
||||
}
|
||||
|
||||
return (int)zip->archive.m_pState->m_zip64;
|
||||
}
|
||||
|
||||
int zip_entry_open(struct zip_t *zip, const char *entryname) {
|
||||
size_t entrylen = 0;
|
||||
mz_zip_archive *pzip = NULL;
|
||||
|
|
@ -794,7 +808,8 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) {
|
|||
|
||||
if (MZ_FILE_STAT(name, &file_stat) != 0) {
|
||||
// problem getting information - check errno
|
||||
return -1;
|
||||
status = -1;
|
||||
break;
|
||||
}
|
||||
|
||||
if ((file_stat.st_mode & 0200) == 0) {
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ extern "C" {
|
|||
|
||||
#if !defined(_SSIZE_T_DEFINED) && !defined(_SSIZE_T_DEFINED_) && \
|
||||
!defined(__DEFINED_ssize_t) && !defined(__ssize_t_defined) && \
|
||||
!defined(_SSIZE_T) && !defined(_SSIZE_T_)
|
||||
!defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(_SSIZE_T_DECLARED)
|
||||
|
||||
// 64-bit Windows is the only mainstream platform
|
||||
// where sizeof(long) != sizeof(void*)
|
||||
|
|
@ -37,6 +37,7 @@ typedef long ssize_t; /* byte count or error */
|
|||
#define __ssize_t_defined
|
||||
#define _SSIZE_T
|
||||
#define _SSIZE_T_
|
||||
#define _SSIZE_T_DECLARED
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -90,6 +91,16 @@ extern struct zip_t *zip_open(const char *zipname, int level, char mode);
|
|||
*/
|
||||
extern void zip_close(struct zip_t *zip);
|
||||
|
||||
/**
|
||||
* Determines if the archive has a zip64 end of central directory headers.
|
||||
*
|
||||
* @param zip zip archive handler.
|
||||
*
|
||||
* @return the return code - 1 (true), 0 (false), negative number (< 0) on
|
||||
* error.
|
||||
*/
|
||||
extern int zip_is64(struct zip_t *zip);
|
||||
|
||||
/**
|
||||
* Opens an entry by name in the zip archive.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -2,15 +2,10 @@ cmake_minimum_required(VERSION 2.8)
|
|||
|
||||
# test
|
||||
set(test_out test.out)
|
||||
set(test_miniz_out test_miniz.out)
|
||||
|
||||
add_executable(${test_out} test.c)
|
||||
target_link_libraries(${test_out} zip)
|
||||
add_executable(${test_miniz_out} test_miniz.c)
|
||||
target_link_libraries(${test_miniz_out} zip)
|
||||
|
||||
add_test(NAME ${test_out} COMMAND ${test_out})
|
||||
add_test(NAME ${test_miniz_out} COMMAND ${test_miniz_out})
|
||||
|
||||
set(test_out ${test_out} PARENT_SCOPE)
|
||||
set(test_miniz_out ${test_miniz_out} PARENT_SCOPE)
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ static void test_write(void) {
|
|||
assert(CRC32DATA1 == zip_entry_crc32(zip));
|
||||
++total_entries;
|
||||
assert(0 == zip_entry_close(zip));
|
||||
|
||||
assert(0 == zip_is64(zip));
|
||||
zip_close(zip);
|
||||
}
|
||||
|
||||
|
|
@ -92,6 +92,7 @@ static void test_read(void) {
|
|||
size_t buftmp;
|
||||
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
||||
assert(zip != NULL);
|
||||
assert(0 == zip_is64(zip));
|
||||
|
||||
assert(0 == zip_entry_open(zip, "test\\test-1.txt"));
|
||||
assert(strlen(TESTDATA1) == zip_entry_size(zip));
|
||||
|
|
@ -310,6 +311,7 @@ static void test_fwrite(void) {
|
|||
assert(0 == zip_entry_open(zip, WFILE));
|
||||
assert(0 == zip_entry_fwrite(zip, WFILE));
|
||||
assert(0 == zip_entry_close(zip));
|
||||
assert(0 == zip_is64(zip));
|
||||
|
||||
zip_close(zip);
|
||||
remove(WFILE);
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
|
|||
|
||||
Copyright (c) 2006-2020, assimp team
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
|
|
@ -48,16 +47,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
# pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#include <assimp/Importer.hpp>
|
||||
#include <assimp/ai_assert.h>
|
||||
#include <assimp/Hash.h>
|
||||
#include <assimp/ai_assert.h>
|
||||
#include <assimp/Importer.hpp>
|
||||
|
||||
#include <map>
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <class T>
|
||||
inline
|
||||
bool SetGenericProperty(std::map< unsigned int, T >& list,
|
||||
inline bool SetGenericProperty(std::map<unsigned int, T> &list,
|
||||
const char *szName, const T &value) {
|
||||
ai_assert(nullptr != szName);
|
||||
const uint32_t hash = SuperFastHash(szName);
|
||||
|
|
@ -74,8 +72,7 @@ bool SetGenericProperty(std::map< unsigned int, T >& list,
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <class T>
|
||||
inline
|
||||
const T& GetGenericProperty(const std::map< unsigned int, T >& list,
|
||||
inline const T &GetGenericProperty(const std::map<unsigned int, T> &list,
|
||||
const char *szName, const T &errorReturn) {
|
||||
ai_assert(nullptr != szName);
|
||||
const uint32_t hash = SuperFastHash(szName);
|
||||
|
|
@ -92,8 +89,7 @@ const T& GetGenericProperty(const std::map< unsigned int, T >& list,
|
|||
// Special version for pointer types - they will be deleted when replaced with another value
|
||||
// passing NULL removes the whole property
|
||||
template <class T>
|
||||
inline
|
||||
void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
|
||||
inline void SetGenericPropertyPtr(std::map<unsigned int, T *> &list,
|
||||
const char *szName, T *value, bool *bWasExisting = nullptr) {
|
||||
ai_assert(nullptr != szName);
|
||||
const uint32_t hash = SuperFastHash(szName);
|
||||
|
|
@ -121,8 +117,7 @@ void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <class T>
|
||||
inline
|
||||
bool HasGenericProperty(const std::map< unsigned int, T >& list,
|
||||
inline bool HasGenericProperty(const std::map<unsigned int, T> &list,
|
||||
const char *szName) {
|
||||
ai_assert(nullptr != szName);
|
||||
const uint32_t hash = SuperFastHash(szName);
|
||||
|
|
|
|||
|
|
@ -93,10 +93,10 @@ public:
|
|||
const TReal* operator[] (unsigned int p_iIndex) const;
|
||||
|
||||
// comparison operators
|
||||
bool operator== (const aiMatrix4x4t<TReal>& m) const;
|
||||
bool operator!= (const aiMatrix4x4t<TReal>& m) const;
|
||||
bool operator== (const aiMatrix3x3t<TReal>& m) const;
|
||||
bool operator!= (const aiMatrix3x3t<TReal>& m) const;
|
||||
|
||||
bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
|
||||
bool Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon = 1e-6) const;
|
||||
|
||||
template <typename TOther>
|
||||
operator aiMatrix3x3t<TOther> () const;
|
||||
|
|
|
|||
|
|
@ -141,7 +141,7 @@ const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename TReal>
|
||||
AI_FORCE_INLINE
|
||||
bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
|
||||
bool aiMatrix3x3t<TReal>::operator== (const aiMatrix3x3t<TReal>& m) const {
|
||||
return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
|
||||
b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
|
||||
c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
|
||||
|
|
@ -150,14 +150,14 @@ bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename TReal>
|
||||
AI_FORCE_INLINE
|
||||
bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const {
|
||||
bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix3x3t<TReal>& m) const {
|
||||
return !(*this == m);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
template<typename TReal>
|
||||
AI_FORCE_INLINE
|
||||
bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
|
||||
bool aiMatrix3x3t<TReal>::Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon) const {
|
||||
return
|
||||
std::abs(a1 - m.a1) <= epsilon &&
|
||||
std::abs(a2 - m.a2) <= epsilon &&
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ def _init(self, target = None, parent = None):
|
|||
logger.debug(str(self) + ": Added array " + str(getattr(target, name)) + " as self." + name.lower())
|
||||
continue
|
||||
|
||||
if m.startswith('m'):
|
||||
if m.startswith('m') and len(m) > 1 and m[1].upper() == m[1]:
|
||||
|
||||
if name == "parent":
|
||||
setattr(target, name, parent)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,52 @@
|
|||
/*
|
||||
---------------------------------------------------------------------------
|
||||
Open Asset Import Library (assimp)
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2020, assimp team
|
||||
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the following
|
||||
conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer in the documentation and/or other
|
||||
materials provided with the distribution.
|
||||
|
||||
* Neither the name of the assimp team, nor the names of its
|
||||
contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior
|
||||
written permission of the assimp team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "UTFConverter.h"
|
||||
|
||||
namespace AssimpSamples {
|
||||
namespace SharedCode {
|
||||
|
||||
typename UTFConverter::UTFConverterImpl UTFConverter::impl_;
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
/*
|
||||
---------------------------------------------------------------------------
|
||||
Open Asset Import Library (assimp)
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2020, assimp team
|
||||
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the following
|
||||
conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer in the documentation and/or other
|
||||
materials provided with the distribution.
|
||||
|
||||
* Neither the name of the assimp team, nor the names of its
|
||||
contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior
|
||||
written permission of the assimp team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef ASSIMP_SAMPLES_SHARED_CODE_UTFCONVERTER_H
|
||||
#define ASSIMP_SAMPLES_SHARED_CODE_UTFCONVERTER_H
|
||||
|
||||
#include <string>
|
||||
#include <locale>
|
||||
#include <codecvt>
|
||||
|
||||
namespace AssimpSamples {
|
||||
namespace SharedCode {
|
||||
|
||||
// Used to convert between multibyte and unicode strings.
|
||||
class UTFConverter {
|
||||
using UTFConverterImpl = std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>;
|
||||
public:
|
||||
UTFConverter(const char* s) :
|
||||
s_(s),
|
||||
ws_(impl_.from_bytes(s)) {
|
||||
}
|
||||
UTFConverter(const wchar_t* s) :
|
||||
s_(impl_.to_bytes(s)),
|
||||
ws_(s) {
|
||||
}
|
||||
UTFConverter(const std::string& s) :
|
||||
s_(s),
|
||||
ws_(impl_.from_bytes(s)) {
|
||||
}
|
||||
UTFConverter(const std::wstring& s) :
|
||||
s_(impl_.to_bytes(s)),
|
||||
ws_(s) {
|
||||
}
|
||||
inline const char* c_str() const {
|
||||
return s_.c_str();
|
||||
}
|
||||
inline const std::string& str() const {
|
||||
return s_;
|
||||
}
|
||||
inline const wchar_t* c_wstr() const {
|
||||
return ws_.c_str();
|
||||
}
|
||||
private:
|
||||
static UTFConverterImpl impl_;
|
||||
std::string s_;
|
||||
std::wstring ws_;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif // ASSIMP_SAMPLES_SHARED_CODE_UTFCONVERTER_H
|
||||
|
|
@ -10,12 +10,12 @@ if ( MSVC )
|
|||
REMOVE_DEFINITIONS( -DUNICODE -D_UNICODE )
|
||||
endif ()
|
||||
|
||||
ADD_COMPILE_DEFINITIONS(SHADER_PATH="${CMAKE_CURRENT_SOURCE_DIR}/SimpleTexturedDirectx11/")
|
||||
|
||||
INCLUDE_DIRECTORIES(
|
||||
${Assimp_SOURCE_DIR}/include
|
||||
${Assimp_SOURCE_DIR}/code
|
||||
${OPENGL_INCLUDE_DIR}
|
||||
${GLUT_INCLUDE_DIR}
|
||||
${Assimp_SOURCE_DIR}/samples/freeglut/include
|
||||
${SAMPLES_SHARED_CODE_DIR}
|
||||
)
|
||||
|
||||
LINK_DIRECTORIES(
|
||||
|
|
@ -32,11 +32,14 @@ ADD_EXECUTABLE( assimp_simpletextureddirectx11 WIN32
|
|||
SimpleTexturedDirectx11/TextureLoader.h
|
||||
#SimpleTexturedDirectx11/VertexShader.hlsl
|
||||
SimpleTexturedDirectx11/main.cpp
|
||||
SimpleTexturedDirectx11/SafeRelease.hpp
|
||||
${SAMPLES_SHARED_CODE_DIR}/UTFConverter.cpp
|
||||
${SAMPLES_SHARED_CODE_DIR}/UTFConverter.h
|
||||
)
|
||||
|
||||
SET_PROPERTY(TARGET assimp_simpletextureddirectx11 PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
|
||||
|
||||
TARGET_LINK_LIBRARIES( assimp_simpletextureddirectx11 assimp ${DirectX_LIBRARY} comctl32.lib winmm.lib )
|
||||
TARGET_LINK_LIBRARIES( assimp_simpletextureddirectx11 assimp comctl32.lib winmm.lib )
|
||||
SET_TARGET_PROPERTIES( assimp_simpletextureddirectx11 PROPERTIES
|
||||
OUTPUT_NAME assimp_simpletextureddirectx11
|
||||
)
|
||||
|
|
|
|||
|
|
@ -6,44 +6,47 @@
|
|||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
|
||||
#include <vector>
|
||||
#include <stdexcept>
|
||||
#include <d3d11_1.h>
|
||||
#include <DirectXMath.h>
|
||||
|
||||
using namespace DirectX;
|
||||
|
||||
#include "SafeRelease.hpp"
|
||||
|
||||
struct VERTEX {
|
||||
FLOAT X, Y, Z;
|
||||
XMFLOAT2 texcoord;
|
||||
};
|
||||
|
||||
struct Texture {
|
||||
string type;
|
||||
string path;
|
||||
std::string type;
|
||||
std::string path;
|
||||
ID3D11ShaderResourceView *texture;
|
||||
|
||||
void Release() {
|
||||
SafeRelease(texture);
|
||||
}
|
||||
};
|
||||
|
||||
class Mesh {
|
||||
public:
|
||||
vector<VERTEX> vertices;
|
||||
vector<UINT> indices;
|
||||
vector<Texture> textures;
|
||||
std::vector<VERTEX> vertices;
|
||||
std::vector<UINT> indices;
|
||||
std::vector<Texture> textures;
|
||||
ID3D11Device *dev;
|
||||
|
||||
Mesh(ID3D11Device *dev, vector<VERTEX> vertices, vector<UINT> indices, vector<Texture> textures)
|
||||
{
|
||||
this->vertices = vertices;
|
||||
this->indices = indices;
|
||||
this->textures = textures;
|
||||
|
||||
this->dev = dev;
|
||||
|
||||
this->setupMesh(dev);
|
||||
Mesh(ID3D11Device *dev, const std::vector<VERTEX>& vertices, const std::vector<UINT>& indices, const std::vector<Texture>& textures) :
|
||||
vertices(vertices),
|
||||
indices(indices),
|
||||
textures(textures),
|
||||
dev(dev),
|
||||
VertexBuffer(nullptr),
|
||||
IndexBuffer(nullptr) {
|
||||
this->setupMesh(this->dev);
|
||||
}
|
||||
|
||||
void Draw(ID3D11DeviceContext *devcon)
|
||||
{
|
||||
void Draw(ID3D11DeviceContext *devcon) {
|
||||
UINT stride = sizeof(VERTEX);
|
||||
UINT offset = 0;
|
||||
|
||||
|
|
@ -52,27 +55,25 @@ public:
|
|||
|
||||
devcon->PSSetShaderResources(0, 1, &textures[0].texture);
|
||||
|
||||
devcon->DrawIndexed(indices.size(), 0, 0);
|
||||
devcon->DrawIndexed(static_cast<UINT>(indices.size()), 0, 0);
|
||||
}
|
||||
|
||||
void Close()
|
||||
{
|
||||
VertexBuffer->Release();
|
||||
IndexBuffer->Release();
|
||||
void Close() {
|
||||
SafeRelease(VertexBuffer);
|
||||
SafeRelease(IndexBuffer);
|
||||
}
|
||||
private:
|
||||
/* Render data */
|
||||
// Render data
|
||||
ID3D11Buffer *VertexBuffer, *IndexBuffer;
|
||||
|
||||
/* Functions */
|
||||
// Functions
|
||||
// Initializes all the buffer objects/arrays
|
||||
bool setupMesh(ID3D11Device *dev)
|
||||
{
|
||||
void setupMesh(ID3D11Device *dev) {
|
||||
HRESULT hr;
|
||||
|
||||
D3D11_BUFFER_DESC vbd;
|
||||
vbd.Usage = D3D11_USAGE_IMMUTABLE;
|
||||
vbd.ByteWidth = sizeof(VERTEX) * vertices.size();
|
||||
vbd.ByteWidth = static_cast<UINT>(sizeof(VERTEX) * vertices.size());
|
||||
vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
|
||||
vbd.CPUAccessFlags = 0;
|
||||
vbd.MiscFlags = 0;
|
||||
|
|
@ -81,12 +82,14 @@ private:
|
|||
initData.pSysMem = &vertices[0];
|
||||
|
||||
hr = dev->CreateBuffer(&vbd, &initData, &VertexBuffer);
|
||||
if (FAILED(hr))
|
||||
return false;
|
||||
if (FAILED(hr)) {
|
||||
Close();
|
||||
throw std::runtime_error("Failed to create vertex buffer.");
|
||||
}
|
||||
|
||||
D3D11_BUFFER_DESC ibd;
|
||||
ibd.Usage = D3D11_USAGE_IMMUTABLE;
|
||||
ibd.ByteWidth = sizeof(UINT) * indices.size();
|
||||
ibd.ByteWidth = static_cast<UINT>(sizeof(UINT) * indices.size());
|
||||
ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
|
||||
ibd.CPUAccessFlags = 0;
|
||||
ibd.MiscFlags = 0;
|
||||
|
|
@ -94,8 +97,10 @@ private:
|
|||
initData.pSysMem = &indices[0];
|
||||
|
||||
hr = dev->CreateBuffer(&ibd, &initData, &IndexBuffer);
|
||||
if (FAILED(hr))
|
||||
return false;
|
||||
if (FAILED(hr)) {
|
||||
Close();
|
||||
throw std::runtime_error("Failed to create index buffer.");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,16 +1,21 @@
|
|||
#include "ModelLoader.h"
|
||||
|
||||
ModelLoader::ModelLoader()
|
||||
{
|
||||
ModelLoader::ModelLoader() :
|
||||
dev(nullptr),
|
||||
devcon(nullptr),
|
||||
meshes(),
|
||||
directory(),
|
||||
textures_loaded(),
|
||||
hwnd(nullptr) {
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
ModelLoader::~ModelLoader()
|
||||
{
|
||||
ModelLoader::~ModelLoader() {
|
||||
// empty
|
||||
}
|
||||
|
||||
bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devcon, std::string filename)
|
||||
{
|
||||
bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devcon, std::string filename) {
|
||||
Assimp::Importer importer;
|
||||
|
||||
const aiScene* pScene = importer.ReadFile(filename,
|
||||
|
|
@ -20,9 +25,10 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc
|
|||
if (pScene == NULL)
|
||||
return false;
|
||||
|
||||
this->directory = filename.substr(0, filename.find_last_of('/'));
|
||||
this->directory = filename.substr(0, filename.find_last_of("/\\"));
|
||||
|
||||
this->dev = dev;
|
||||
this->devcon = devcon;
|
||||
this->hwnd = hwnd;
|
||||
|
||||
processNode(pScene->mRootNode, pScene);
|
||||
|
|
@ -30,41 +36,37 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc
|
|||
return true;
|
||||
}
|
||||
|
||||
void ModelLoader::Draw(ID3D11DeviceContext * devcon)
|
||||
{
|
||||
for (int i = 0; i < meshes.size(); i++)
|
||||
{
|
||||
void ModelLoader::Draw(ID3D11DeviceContext * devcon) {
|
||||
for (int i = 0; i < meshes.size(); ++i ) {
|
||||
meshes[i].Draw(devcon);
|
||||
}
|
||||
}
|
||||
|
||||
string textype;
|
||||
std::string textype;
|
||||
|
||||
Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene)
|
||||
{
|
||||
Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene) {
|
||||
// Data to fill
|
||||
vector<VERTEX> vertices;
|
||||
vector<UINT> indices;
|
||||
vector<Texture> textures;
|
||||
std::vector<VERTEX> vertices;
|
||||
std::vector<UINT> indices;
|
||||
std::vector<Texture> textures;
|
||||
|
||||
if (mesh->mMaterialIndex >= 0)
|
||||
{
|
||||
if (mesh->mMaterialIndex >= 0) {
|
||||
aiMaterial* mat = scene->mMaterials[mesh->mMaterialIndex];
|
||||
|
||||
if (textype.empty()) textype = determineTextureType(scene, mat);
|
||||
if (textype.empty()) {
|
||||
textype = determineTextureType(scene, mat);
|
||||
}
|
||||
}
|
||||
|
||||
// Walk through each of the mesh's vertices
|
||||
for (UINT i = 0; i < mesh->mNumVertices; i++)
|
||||
{
|
||||
for (UINT i = 0; i < mesh->mNumVertices; i++) {
|
||||
VERTEX vertex;
|
||||
|
||||
vertex.X = mesh->mVertices[i].x;
|
||||
vertex.Y = mesh->mVertices[i].y;
|
||||
vertex.Z = mesh->mVertices[i].z;
|
||||
|
||||
if (mesh->mTextureCoords[0])
|
||||
{
|
||||
if (mesh->mTextureCoords[0]) {
|
||||
vertex.texcoord.x = (float)mesh->mTextureCoords[0][i].x;
|
||||
vertex.texcoord.y = (float)mesh->mTextureCoords[0][i].y;
|
||||
}
|
||||
|
|
@ -72,57 +74,47 @@ Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene)
|
|||
vertices.push_back(vertex);
|
||||
}
|
||||
|
||||
for (UINT i = 0; i < mesh->mNumFaces; i++)
|
||||
{
|
||||
for (UINT i = 0; i < mesh->mNumFaces; i++) {
|
||||
aiFace face = mesh->mFaces[i];
|
||||
|
||||
for (UINT j = 0; j < face.mNumIndices; j++)
|
||||
indices.push_back(face.mIndices[j]);
|
||||
}
|
||||
|
||||
if (mesh->mMaterialIndex >= 0)
|
||||
{
|
||||
if (mesh->mMaterialIndex >= 0) {
|
||||
aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
|
||||
|
||||
vector<Texture> diffuseMaps = this->loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse", scene);
|
||||
std::vector<Texture> diffuseMaps = this->loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse", scene);
|
||||
textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
|
||||
}
|
||||
|
||||
return Mesh(dev, vertices, indices, textures);
|
||||
}
|
||||
|
||||
vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureType type, string typeName, const aiScene * scene)
|
||||
{
|
||||
vector<Texture> textures;
|
||||
for (UINT i = 0; i < mat->GetTextureCount(type); i++)
|
||||
{
|
||||
std::vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureType type, std::string typeName, const aiScene * scene) {
|
||||
std::vector<Texture> textures;
|
||||
for (UINT i = 0; i < mat->GetTextureCount(type); i++) {
|
||||
aiString str;
|
||||
mat->GetTexture(type, i, &str);
|
||||
// Check if texture was loaded before and if so, continue to next iteration: skip loading a new texture
|
||||
bool skip = false;
|
||||
for (UINT j = 0; j < textures_loaded.size(); j++)
|
||||
{
|
||||
if (std::strcmp(textures_loaded[j].path.c_str(), str.C_Str()) == 0)
|
||||
{
|
||||
for (UINT j = 0; j < textures_loaded.size(); j++) {
|
||||
if (std::strcmp(textures_loaded[j].path.c_str(), str.C_Str()) == 0) {
|
||||
textures.push_back(textures_loaded[j]);
|
||||
skip = true; // A texture with the same filepath has already been loaded, continue to next one. (optimization)
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!skip)
|
||||
{ // If texture hasn't been loaded already, load it
|
||||
if (!skip) { // If texture hasn't been loaded already, load it
|
||||
HRESULT hr;
|
||||
Texture texture;
|
||||
if (textype == "embedded compressed texture")
|
||||
{
|
||||
if (textype == "embedded compressed texture") {
|
||||
int textureindex = getTextureIndex(&str);
|
||||
texture.texture = getTextureFromModel(scene, textureindex);
|
||||
}
|
||||
else
|
||||
{
|
||||
string filename = string(str.C_Str());
|
||||
} else {
|
||||
std::string filename = std::string(str.C_Str());
|
||||
filename = directory + '/' + filename;
|
||||
wstring filenamews = wstring(filename.begin(), filename.end());
|
||||
std::wstring filenamews = std::wstring(filename.begin(), filename.end());
|
||||
hr = CreateWICTextureFromFile(dev, devcon, filenamews.c_str(), nullptr, &texture.texture);
|
||||
if (FAILED(hr))
|
||||
MessageBox(hwnd, "Texture couldn't be loaded", "Error!", MB_ICONERROR | MB_OK);
|
||||
|
|
@ -136,64 +128,52 @@ vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureTyp
|
|||
return textures;
|
||||
}
|
||||
|
||||
void ModelLoader::Close()
|
||||
{
|
||||
for (int i = 0; i < meshes.size(); i++)
|
||||
{
|
||||
void ModelLoader::Close() {
|
||||
for (auto& t : textures_loaded)
|
||||
t.Release();
|
||||
|
||||
for (int i = 0; i < meshes.size(); i++) {
|
||||
meshes[i].Close();
|
||||
}
|
||||
|
||||
dev->Release();
|
||||
}
|
||||
|
||||
void ModelLoader::processNode(aiNode * node, const aiScene * scene)
|
||||
{
|
||||
for (UINT i = 0; i < node->mNumMeshes; i++)
|
||||
{
|
||||
void ModelLoader::processNode(aiNode * node, const aiScene * scene) {
|
||||
for (UINT i = 0; i < node->mNumMeshes; i++) {
|
||||
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
|
||||
meshes.push_back(this->processMesh(mesh, scene));
|
||||
}
|
||||
|
||||
for (UINT i = 0; i < node->mNumChildren; i++)
|
||||
{
|
||||
for (UINT i = 0; i < node->mNumChildren; i++) {
|
||||
this->processNode(node->mChildren[i], scene);
|
||||
}
|
||||
}
|
||||
|
||||
string ModelLoader::determineTextureType(const aiScene * scene, aiMaterial * mat)
|
||||
{
|
||||
std::string ModelLoader::determineTextureType(const aiScene * scene, aiMaterial * mat) {
|
||||
aiString textypeStr;
|
||||
mat->GetTexture(aiTextureType_DIFFUSE, 0, &textypeStr);
|
||||
string textypeteststr = textypeStr.C_Str();
|
||||
if (textypeteststr == "*0" || textypeteststr == "*1" || textypeteststr == "*2" || textypeteststr == "*3" || textypeteststr == "*4" || textypeteststr == "*5")
|
||||
{
|
||||
if (scene->mTextures[0]->mHeight == 0)
|
||||
{
|
||||
std::string textypeteststr = textypeStr.C_Str();
|
||||
if (textypeteststr == "*0" || textypeteststr == "*1" || textypeteststr == "*2" || textypeteststr == "*3" || textypeteststr == "*4" || textypeteststr == "*5") {
|
||||
if (scene->mTextures[0]->mHeight == 0) {
|
||||
return "embedded compressed texture";
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
return "embedded non-compressed texture";
|
||||
}
|
||||
}
|
||||
if (textypeteststr.find('.') != string::npos)
|
||||
{
|
||||
if (textypeteststr.find('.') != std::string::npos) {
|
||||
return "textures are on disk";
|
||||
}
|
||||
|
||||
return ".";
|
||||
}
|
||||
|
||||
int ModelLoader::getTextureIndex(aiString * str)
|
||||
{
|
||||
string tistr;
|
||||
int ModelLoader::getTextureIndex(aiString * str) {
|
||||
std::string tistr;
|
||||
tistr = str->C_Str();
|
||||
tistr = tistr.substr(1);
|
||||
return stoi(tistr);
|
||||
}
|
||||
|
||||
ID3D11ShaderResourceView * ModelLoader::getTextureFromModel(const aiScene * scene, int textureindex)
|
||||
{
|
||||
ID3D11ShaderResourceView * ModelLoader::getTextureFromModel(const aiScene * scene, int textureindex) {
|
||||
HRESULT hr;
|
||||
ID3D11ShaderResourceView *texture;
|
||||
|
||||
|
|
|
|||
|
|
@ -28,14 +28,14 @@ private:
|
|||
ID3D11Device *dev;
|
||||
ID3D11DeviceContext *devcon;
|
||||
std::vector<Mesh> meshes;
|
||||
string directory;
|
||||
vector<Texture> textures_loaded;
|
||||
std::string directory;
|
||||
std::vector<Texture> textures_loaded;
|
||||
HWND hwnd;
|
||||
|
||||
void processNode(aiNode* node, const aiScene* scene);
|
||||
Mesh processMesh(aiMesh* mesh, const aiScene* scene);
|
||||
vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, string typeName, const aiScene* scene);
|
||||
string determineTextureType(const aiScene* scene, aiMaterial* mat);
|
||||
std::vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, std::string typeName, const aiScene* scene);
|
||||
std::string determineTextureType(const aiScene* scene, aiMaterial* mat);
|
||||
int getTextureIndex(aiString* str);
|
||||
ID3D11ShaderResourceView* getTextureFromModel(const aiScene* scene, int textureindex);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -0,0 +1,57 @@
|
|||
/*
|
||||
---------------------------------------------------------------------------
|
||||
Open Asset Import Library (assimp)
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2020, assimp team
|
||||
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the following
|
||||
conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer in the documentation and/or other
|
||||
materials provided with the distribution.
|
||||
|
||||
* Neither the name of the assimp team, nor the names of its
|
||||
contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior
|
||||
written permission of the assimp team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
/* Used to reduce to reduce the number of lines when calling Release()
|
||||
on a D3D interface. Implemented as a template instead of a 'SAFE_RELEASE'
|
||||
MACRO to ease debugging. */
|
||||
template<typename T>
|
||||
inline void SafeRelease(T*& x) {
|
||||
if (x) {
|
||||
x->Release();
|
||||
x = nullptr;
|
||||
}
|
||||
}
|
||||
|
|
@ -14,12 +14,16 @@
|
|||
// ---------------------------------------------------------------------------
|
||||
|
||||
#include <Windows.h>
|
||||
#include <shellapi.h>
|
||||
#include <stdexcept>
|
||||
#include <windowsx.h>
|
||||
#include <d3d11_1.h>
|
||||
#include <dxgi1_2.h>
|
||||
#include <DirectXMath.h>
|
||||
#include <d3dcompiler.h>
|
||||
#include "ModelLoader.h"
|
||||
#include "UTFConverter.h"
|
||||
#include "SafeRelease.hpp"
|
||||
|
||||
#pragma comment (lib, "d3d11.lib")
|
||||
#pragma comment (lib, "Dxgi.lib")
|
||||
|
|
@ -27,6 +31,10 @@
|
|||
#pragma comment (lib, "dxguid.lib")
|
||||
|
||||
using namespace DirectX;
|
||||
using namespace AssimpSamples::SharedCode;
|
||||
|
||||
#define VERTEX_SHADER_FILE L"VertexShader.hlsl"
|
||||
#define PIXEL_SHADER_FILE L"PixelShader.hlsl"
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Structs
|
||||
|
|
@ -45,29 +53,32 @@ struct ConstantBuffer {
|
|||
|
||||
const char g_szClassName[] = "directxWindowClass";
|
||||
|
||||
static std::string g_ModelPath;
|
||||
|
||||
UINT width, height;
|
||||
HWND hwnd;
|
||||
HWND hwnd = nullptr;
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// DirectX Variables
|
||||
// ------------------------------------------------------------
|
||||
D3D_DRIVER_TYPE g_driverType = D3D_DRIVER_TYPE_NULL;
|
||||
D3D_FEATURE_LEVEL g_featureLevel = D3D_FEATURE_LEVEL_11_0;
|
||||
ID3D11Device *dev;
|
||||
ID3D11Device1 *dev1;
|
||||
ID3D11DeviceContext *devcon;
|
||||
ID3D11DeviceContext1 *devcon1;
|
||||
IDXGISwapChain *swapchain;
|
||||
IDXGISwapChain1 *swapchain1;
|
||||
ID3D11RenderTargetView *backbuffer;
|
||||
ID3D11VertexShader *pVS;
|
||||
ID3D11PixelShader *pPS;
|
||||
ID3D11InputLayout *pLayout;
|
||||
ID3D11Buffer *pConstantBuffer;
|
||||
ID3D11Texture2D *g_pDepthStencil;
|
||||
ID3D11DepthStencilView *g_pDepthStencilView;
|
||||
ID3D11SamplerState *TexSamplerState;
|
||||
ID3D11Device *dev = nullptr;
|
||||
ID3D11Device1 *dev1 = nullptr;
|
||||
ID3D11DeviceContext *devcon = nullptr;
|
||||
ID3D11DeviceContext1 *devcon1 = nullptr;
|
||||
IDXGISwapChain *swapchain = nullptr;
|
||||
IDXGISwapChain1 *swapchain1 = nullptr;
|
||||
ID3D11RenderTargetView *backbuffer = nullptr;
|
||||
ID3D11VertexShader *pVS = nullptr;
|
||||
ID3D11PixelShader *pPS = nullptr;
|
||||
ID3D11InputLayout *pLayout = nullptr;
|
||||
ID3D11Buffer *pConstantBuffer = nullptr;
|
||||
ID3D11Texture2D *g_pDepthStencil = nullptr;
|
||||
ID3D11DepthStencilView *g_pDepthStencilView = nullptr;
|
||||
ID3D11SamplerState *TexSamplerState = nullptr;
|
||||
ID3D11RasterizerState *rasterstate = nullptr;
|
||||
ID3D11Debug* d3d11debug = nullptr;
|
||||
|
||||
XMMATRIX m_World;
|
||||
XMMATRIX m_View;
|
||||
|
|
@ -91,7 +102,7 @@ void Throwanerror(LPCSTR errormessage);
|
|||
// Our Model
|
||||
// ------------------------------------------------------------
|
||||
|
||||
ModelLoader *ourModel;
|
||||
ModelLoader *ourModel = nullptr;
|
||||
|
||||
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
||||
{
|
||||
|
|
@ -109,9 +120,42 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
||||
LPSTR lpCmdLine, int nCmdShow)
|
||||
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
||||
LPWSTR lpCmdLine, int nCmdShow)
|
||||
{
|
||||
int argc;
|
||||
LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
|
||||
if (!argv) {
|
||||
MessageBox(NULL,
|
||||
TEXT("An error occured while reading command line arguments."),
|
||||
TEXT("Error!"),
|
||||
MB_ICONERROR | MB_OK);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
// Free memory allocated from CommandLineToArgvW.
|
||||
auto free_command_line_allocated_memory = [&argv]() {
|
||||
if (argv) {
|
||||
LocalFree(argv);
|
||||
argv = nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
// Ensure that a model file has been specified.
|
||||
if (argc < 2) {
|
||||
MessageBox(NULL,
|
||||
TEXT("No model file specified. The program will now close."),
|
||||
TEXT("Error!"),
|
||||
MB_ICONERROR | MB_OK);
|
||||
free_command_line_allocated_memory();
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
// Retrieve the model file path.
|
||||
g_ModelPath = UTFConverter(argv[1]).str();
|
||||
|
||||
free_command_line_allocated_memory();
|
||||
|
||||
WNDCLASSEX wc;
|
||||
MSG msg;
|
||||
|
||||
|
|
@ -160,6 +204,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
|||
width = wr.right - wr.left;
|
||||
height = wr.bottom - wr.top;
|
||||
|
||||
try {
|
||||
InitD3D(hInstance, hwnd);
|
||||
|
||||
while (true)
|
||||
|
|
@ -178,8 +223,16 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
|||
}
|
||||
|
||||
CleanD3D();
|
||||
|
||||
return msg.wParam;
|
||||
return static_cast<int>(msg.wParam);
|
||||
} catch (const std::exception& e) {
|
||||
MessageBox(hwnd, e.what(), TEXT("Error!"), MB_ICONERROR | MB_OK);
|
||||
CleanD3D();
|
||||
return EXIT_FAILURE;
|
||||
} catch (...) {
|
||||
MessageBox(hwnd, TEXT("Caught an unknown exception."), TEXT("Error!"), MB_ICONERROR | MB_OK);
|
||||
CleanD3D();
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
|
||||
void InitD3D(HINSTANCE hinstance, HWND hWnd)
|
||||
|
|
@ -227,6 +280,12 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
|
|||
if (FAILED(hr))
|
||||
Throwanerror("Directx Device Creation Failed!");
|
||||
|
||||
#if _DEBUG
|
||||
hr = dev->QueryInterface(IID_PPV_ARGS(&d3d11debug));
|
||||
if (FAILED(hr))
|
||||
OutputDebugString(TEXT("Failed to retrieve DirectX 11 debug interface.\n"));
|
||||
#endif
|
||||
|
||||
UINT m4xMsaaQuality;
|
||||
dev->CheckMultisampleQualityLevels(
|
||||
DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m4xMsaaQuality);
|
||||
|
|
@ -348,7 +407,6 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
|
|||
devcon->OMSetRenderTargets(1, &backbuffer, g_pDepthStencilView);
|
||||
|
||||
D3D11_RASTERIZER_DESC rasterDesc;
|
||||
ID3D11RasterizerState *rasterState;
|
||||
rasterDesc.AntialiasedLineEnable = false;
|
||||
rasterDesc.CullMode = D3D11_CULL_BACK;
|
||||
rasterDesc.DepthBias = 0;
|
||||
|
|
@ -360,8 +418,8 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
|
|||
rasterDesc.ScissorEnable = false;
|
||||
rasterDesc.SlopeScaledDepthBias = 0.0f;
|
||||
|
||||
dev->CreateRasterizerState(&rasterDesc, &rasterState);
|
||||
devcon->RSSetState(rasterState);
|
||||
dev->CreateRasterizerState(&rasterDesc, &rasterstate);
|
||||
devcon->RSSetState(rasterstate);
|
||||
|
||||
D3D11_VIEWPORT viewport;
|
||||
ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
|
||||
|
|
@ -381,19 +439,38 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
|
|||
|
||||
void CleanD3D(void)
|
||||
{
|
||||
if (swapchain)
|
||||
swapchain->SetFullscreenState(FALSE, NULL);
|
||||
|
||||
if (ourModel) {
|
||||
ourModel->Close();
|
||||
g_pDepthStencil->Release();
|
||||
g_pDepthStencilView->Release();
|
||||
pLayout->Release();
|
||||
pVS->Release();
|
||||
pPS->Release();
|
||||
pConstantBuffer->Release();
|
||||
swapchain->Release();
|
||||
backbuffer->Release();
|
||||
dev->Release();
|
||||
devcon->Release();
|
||||
delete ourModel;
|
||||
ourModel = nullptr;
|
||||
}
|
||||
SafeRelease(TexSamplerState);
|
||||
SafeRelease(pConstantBuffer);
|
||||
SafeRelease(pLayout);
|
||||
SafeRelease(pVS);
|
||||
SafeRelease(pPS);
|
||||
SafeRelease(rasterstate);
|
||||
SafeRelease(g_pDepthStencilView);
|
||||
SafeRelease(g_pDepthStencil);
|
||||
SafeRelease(backbuffer);
|
||||
SafeRelease(swapchain);
|
||||
SafeRelease(swapchain1);
|
||||
SafeRelease(devcon1);
|
||||
SafeRelease(dev1);
|
||||
SafeRelease(devcon);
|
||||
#if _DEBUG
|
||||
if (d3d11debug) {
|
||||
OutputDebugString(TEXT("Dumping DirectX 11 live objects.\n"));
|
||||
d3d11debug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL);
|
||||
SafeRelease(d3d11debug);
|
||||
} else {
|
||||
OutputDebugString(TEXT("Unable to dump live objects: no DirectX 11 debug interface available.\n"));
|
||||
}
|
||||
#endif
|
||||
SafeRelease(dev);
|
||||
}
|
||||
|
||||
void RenderFrame(void)
|
||||
|
|
@ -431,8 +508,10 @@ void RenderFrame(void)
|
|||
void InitPipeline()
|
||||
{
|
||||
ID3DBlob *VS, *PS;
|
||||
CompileShaderFromFile(L"VertexShader.hlsl", 0, "main", "vs_4_0", &VS);
|
||||
CompileShaderFromFile(L"PixelShader.hlsl", 0, "main", "ps_4_0", &PS);
|
||||
if(FAILED(CompileShaderFromFile(SHADER_PATH VERTEX_SHADER_FILE, 0, "main", "vs_4_0", &VS)))
|
||||
Throwanerror(UTFConverter(L"Failed to compile shader from file " VERTEX_SHADER_FILE).c_str());
|
||||
if(FAILED(CompileShaderFromFile(SHADER_PATH PIXEL_SHADER_FILE, 0, "main", "ps_4_0", &PS)))
|
||||
Throwanerror(UTFConverter(L"Failed to compile shader from file " PIXEL_SHADER_FILE).c_str());
|
||||
|
||||
dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), NULL, &pVS);
|
||||
dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, &pPS);
|
||||
|
|
@ -485,7 +564,7 @@ void InitGraphics()
|
|||
m_View = XMMatrixLookAtLH(Eye, At, Up);
|
||||
|
||||
ourModel = new ModelLoader;
|
||||
if (!ourModel->Load(hwnd, dev, devcon, "Models/myModel.fbx"))
|
||||
if (!ourModel->Load(hwnd, dev, devcon, g_ModelPath))
|
||||
Throwanerror("Model couldn't be loaded");
|
||||
}
|
||||
|
||||
|
|
@ -514,5 +593,5 @@ HRESULT CompileShaderFromFile(LPCWSTR pFileName, const D3D_SHADER_MACRO* pDefine
|
|||
|
||||
void Throwanerror(LPCSTR errormessage)
|
||||
{
|
||||
MessageBox(hwnd, errormessage, "Error!", MB_ICONERROR | MB_OK);
|
||||
throw std::runtime_error(errormessage);
|
||||
}
|
||||
|
|
@ -21,6 +21,7 @@ INCLUDE_DIRECTORIES(
|
|||
${Assimp_SOURCE_DIR}/code
|
||||
${OPENGL_INCLUDE_DIR}
|
||||
${GLUT_INCLUDE_DIR}
|
||||
${SAMPLES_SHARED_CODE_DIR}
|
||||
)
|
||||
|
||||
LINK_DIRECTORIES(
|
||||
|
|
@ -31,6 +32,8 @@ LINK_DIRECTORIES(
|
|||
ADD_EXECUTABLE( assimp_simpletexturedogl WIN32
|
||||
SimpleTexturedOpenGL/include/boost_includes.h
|
||||
SimpleTexturedOpenGL/src/model_loading.cpp
|
||||
${SAMPLES_SHARED_CODE_DIR}/UTFConverter.cpp
|
||||
${SAMPLES_SHARED_CODE_DIR}/UTFConverter.h
|
||||
)
|
||||
|
||||
SET_PROPERTY(TARGET assimp_simpletexturedogl PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
|
||||
|
|
|
|||
|
|
@ -21,8 +21,6 @@
|
|||
#define STB_IMAGE_IMPLEMENTATION
|
||||
#include "contrib/stb_image/stb_image.h"
|
||||
|
||||
#include <locale>
|
||||
#include <codecvt>
|
||||
#include <fstream>
|
||||
|
||||
//to map image filenames to textureIds
|
||||
|
|
@ -35,7 +33,7 @@
|
|||
#include <assimp/scene.h>
|
||||
#include <assimp/DefaultLogger.hpp>
|
||||
#include <assimp/LogStream.hpp>
|
||||
|
||||
#include "UTFConverter.h"
|
||||
|
||||
// The default hard-coded path. Can be overridden by supplying a path through the command line.
|
||||
static std::string modelpath = "../../test/models/OBJ/spider.obj";
|
||||
|
|
@ -77,35 +75,7 @@ GLuint* textureIds; // pointer to texture Array
|
|||
// Create an instance of the Importer class
|
||||
Assimp::Importer importer;
|
||||
|
||||
// Used to convert between multibyte and unicode strings.
|
||||
class UTFConverter {
|
||||
using UTFConverterImpl = std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>;
|
||||
public:
|
||||
UTFConverter(const char* s) :
|
||||
s_(s),
|
||||
ws_(impl_.from_bytes(s)) {
|
||||
}
|
||||
UTFConverter(const std::string& s) :
|
||||
s_(s),
|
||||
ws_(impl_.from_bytes(s)) {
|
||||
}
|
||||
UTFConverter(const std::wstring& s) :
|
||||
s_(impl_.to_bytes(s)),
|
||||
ws_(s) {
|
||||
}
|
||||
inline const std::string& str() const {
|
||||
return s_;
|
||||
}
|
||||
inline const wchar_t* c_wstr() const {
|
||||
return ws_.c_str();
|
||||
}
|
||||
private:
|
||||
static UTFConverterImpl impl_;
|
||||
std::string s_;
|
||||
std::wstring ws_;
|
||||
};
|
||||
|
||||
typename UTFConverter::UTFConverterImpl UTFConverter::impl_;
|
||||
using namespace AssimpSamples::SharedCode;
|
||||
|
||||
void createAILogger()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#----------------------------------------------------------------------
|
||||
cmake_minimum_required( VERSION 2.6 )
|
||||
cmake_minimum_required( VERSION 3.0 )
|
||||
|
||||
INCLUDE_DIRECTORIES(
|
||||
${Assimp_SOURCE_DIR}/include
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#----------------------------------------------------------------------
|
||||
cmake_minimum_required( VERSION 2.6 )
|
||||
cmake_minimum_required( VERSION 3.0 )
|
||||
|
||||
FIND_PACKAGE(DirectX REQUIRED)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue