Updated to CL 22627414:

* docs updates
* authoring fixes
* stress solver crash fixes

12 files changed, 284 insertions, 151 deletions

diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastAssetModel.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastAssetModel.cpp
index 2c39824..857cb9b 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastAssetModel.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastAssetModel.cpp
@@ -36,7 +36,7 @@
 #include "NvBlastExtPxAsset.h"
 #include <sstream>
 #include <fstream>
-#include "NvBlastExtExporterFbxReader.h"
+#include "NvBlastExtExporter.h"
 #include "PxPhysics.h"
 #include <NvBlastGlobals.h>
 #include "NvBlastExtAssetUtils.h"
@@ -46,6 +46,8 @@
 #include "NvBlastExtLlSerialization.h"
 #include "NvBlastExtTkSerialization.h"
 #include "NvBlastExtPxSerialization.h"
+#include "NvBlastExtAuthoring.h"
+#include "NvBlastExtAuthoringCollisionBuilder.h"
 
 BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxCooking& cooking, ExtSerialization& serialization, Renderer& renderer, const char* modelName, const char* modelPath)
 	: BlastAsset(renderer)
@@ -179,27 +181,31 @@ BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxC
 				path = GlobalSettings::MakeFileName(modelPath, objFileName.str().c_str());
 				if (QFile::exists(path.c_str()))
 				{
-					FbxFileReader rdr;
-					rdr.loadFromFile(path);
-					if (rdr.isCollisionLoaded() == 0)
+					std::shared_ptr<IFbxFileReader> rdr(NvBlastExtExporterCreateFbxFileReader(), [](IFbxFileReader* p) {p->release(); });
+					rdr->loadFromFile(path.c_str());
+					if (rdr->isCollisionLoaded() == 0)
 					{
 						ASSERT_PRINT(false, "fbx doesn't contain collision geometry");
 					}
-					std::vector<std::vector<CollisionHull> > hulls;
-					rdr.getCollision(hulls);
+					uint32_t* hullsOffsets = nullptr;
+					CollisionHull** hulls = nullptr;
+					uint32_t meshCount = rdr->getCollision(hullsOffsets, hulls);
 
 					/**
 					Create physics meshes;
 					*/
-					Nv::Blast::ConvexMeshBuilder collisionBuilder(&cooking, &physics.getPhysicsInsertionCallback());
-					physicsChunks.resize(hulls.size());
-					physicsSubchunks.resize(hulls.size());
+					std::shared_ptr<Nv::Blast::ConvexMeshBuilder> collisionBuilder(
+						NvBlastExtAuthoringCreateConvexMeshBuilder(&cooking, &physics.getPhysicsInsertionCallback()),
+						[](Nv::Blast::ConvexMeshBuilder* cmb) {cmb->release(); });
 
-					for (uint32_t i = 0; i < hulls.size(); ++i)
+					physicsChunks.resize(meshCount);
+					physicsSubchunks.resize(meshCount);
+
+					for (uint32_t i = 0; i < meshCount; ++i)
 					{
-						for (uint32_t sbHulls = 0; sbHulls < hulls[i].size(); ++sbHulls)
+						for (uint32_t sbHulls = hullsOffsets[i]; sbHulls < hullsOffsets[i+1]; ++sbHulls)
 						{
-							PxConvexMeshGeometry temp = physx::PxConvexMeshGeometry(collisionBuilder.buildConvexMesh(hulls[i][sbHulls]));
+							PxConvexMeshGeometry temp = physx::PxConvexMeshGeometry(collisionBuilder.get()->buildConvexMesh(*hulls[sbHulls]));
 							if (temp.isValid())
 							{
 								physicsSubchunks[i].push_back(ExtPxAssetDesc::SubchunkDesc());
@@ -208,12 +214,20 @@ BlastAssetModel::BlastAssetModel(TkFramework& framework, PxPhysics& physics, PxC
 							}
 						}
 					}
-					for (uint32_t i = 0; i < hulls.size(); ++i)
+					for (uint32_t i = 0; i < meshCount; ++i)
 					{
 						physicsChunks[i].isStatic = false;
 						physicsChunks[i].subchunkCount = (uint32_t)physicsSubchunks[i].size();
 						physicsChunks[i].subchunks = physicsSubchunks[i].data();
 					}
+					if (hullsOffsets)
+					{
+						NVBLAST_FREE(hullsOffsets);
+					}
+					if (hulls)
+					{
+						NVBLAST_FREE(hulls);
+					}
 				}
 				m_pxAsset = ExtPxAsset::create(tkAsset, physicsChunks.data(), (uint32_t)physicsChunks.size());
 				ASSERT_PRINT(m_pxAsset != nullptr, "can't create asset");
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFamilyModelSimple.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFamilyModelSimple.cpp
index 01559da..7d2cbe4 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFamilyModelSimple.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFamilyModelSimple.cpp
@@ -162,9 +162,10 @@ public:
 		m_device = GetDeviceManager()->GetDevice();
 
 		m_inputDesc.push_back({ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 });
-		m_inputDesc.push_back({ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 });
-		m_inputDesc.push_back({ "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 });
-		m_inputDesc.push_back({ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 36, D3D11_INPUT_PER_VERTEX_DATA, 0 });
+		m_inputDesc.push_back({ "VERTEX_NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 });
+		m_inputDesc.push_back({ "FACE_NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 });
+		m_inputDesc.push_back({ "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 36, D3D11_INPUT_PER_VERTEX_DATA, 0 });
+		m_inputDesc.push_back({ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 48, D3D11_INPUT_PER_VERTEX_DATA, 0 });
 		m_inputDesc.push_back({ "TEXCOORD", 1, DXGI_FORMAT_R32_FLOAT, 1, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 });
 
 		m_numVertices = static_cast<uint32_t>(mesh->vertices.size());
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFractureTool.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFractureTool.cpp
index 5051534..cbd299b 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFractureTool.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFractureTool.cpp
@@ -31,7 +31,8 @@
 #include <BlastAsset.h>
 #include <NvBlastExtPxAsset.h>
 #include <NvBlastTkAsset.h>
-
+#include "NvBlastExtAuthoring.h"
+#include "NvBlastExtAuthoringMeshImpl.h"
 void BlastFractureTool::free()
 {
 	std::vector<Nv::Blast::Mesh*>::iterator it;
@@ -101,7 +102,7 @@ void BlastFractureTool::setSourceAsset(const BlastAsset* pBlastAsset)
 
 		PxVec3* nr = (!normals.empty()) ? normals.data() : 0;
 		PxVec2* uvp = (!uv.empty()) ? uv.data() : 0;
-		Nv::Blast::Mesh* pMesh = new Nv::Blast::Mesh(
+		Nv::Blast::Mesh* pMesh = NvBlastExtAuthoringCreateMesh(
 			positions.data(), nr, uvp, static_cast<uint32_t>(positions.size()),
 			ind.data(), static_cast<uint32_t>(ind.size()));
 
@@ -117,7 +118,8 @@ void BlastFractureTool::setSourceAsset(const BlastAsset* pBlastAsset)
 				curMaterialIndex = materialIndexes[curFaceIndex];
 			}
 
-			pMesh->getFacet(fc)->userData = curMaterialIndex;
+			Facet* pFacet = const_cast<Facet*>(pMesh->getFacet(fc));
+			pFacet->materialId = curMaterialIndex;
 		}
 
 		chunkMeshes[cs] = pMesh;
@@ -162,22 +164,24 @@ void BlastFractureTool::setSourceAsset(const BlastAsset* pBlastAsset)
 	{
 		if (chunkMeshes[cs] == nullptr)
 			continue;
-		mChunkData[cs].meshData = new Nv::Blast::Mesh(*chunkMeshes[cs]);
+		mChunkData[cs].meshData = new MeshImpl(*reinterpret_cast<const MeshImpl*>(chunkMeshes[cs]));
 		mChunkData[cs].parent = parentIds[cs];
 		mChunkData[cs].chunkId = mChunkIdCounter++;
 		mChunkData[cs].isLeaf = isLeafs[cs];
 
 		mesh = mChunkData[cs].meshData;
-		Nv::Blast::Vertex* verticesBuffer = mesh->getVertices();
+		Nv::Blast::Vertex* verticesBuffer = const_cast<Nv::Blast::Vertex*>(mesh->getVertices());
 		for (uint32_t i = 0; i < mesh->getVerticesCount(); ++i)
 		{
 			verticesBuffer[i].p = (verticesBuffer[i].p - mOffset) * (1.0f / mScaleFactor);
 		}
-		mesh->getBoundingBox().minimum = (mesh->getBoundingBox().minimum - mOffset) * (1.0f / mScaleFactor);
-		mesh->getBoundingBox().maximum = (mesh->getBoundingBox().maximum - mOffset) * (1.0f / mScaleFactor);
+		PxBounds3& bb = const_cast<PxBounds3&>(mesh->getBoundingBox());
+		bb.minimum = (bb.minimum - mOffset) * (1.0f / mScaleFactor);
+		bb.maximum = (bb.maximum - mOffset) * (1.0f / mScaleFactor);
 		for (uint32_t i = 0; i < mesh->getFacetCount(); ++i)
 		{
-			mesh->getFacet(i)->userData = chunkMeshes[cs]->getFacet(i)->userData;
+			Facet* pFacet = const_cast<Facet*>(mesh->getFacet(i));
+			pFacet->materialId = chunkMeshes[cs]->getFacet(i)->materialId;
 		}
 	}
 }
@@ -195,7 +199,7 @@ void BlastFractureTool::setSourceMeshes(std::vector<Nv::Blast::Mesh*>& meshes, s
 	chunkMeshes.resize(chunkSize, nullptr);
 	for (int cs = 0; cs < chunkSize; cs++)
 	{
-		Nv::Blast::Mesh* pMesh = new Nv::Blast::Mesh(*meshes[cs]);
+		Nv::Blast::Mesh* pMesh = new MeshImpl(*reinterpret_cast<const MeshImpl*>(meshes[cs]));
 		chunkMeshes[cs] = pMesh;
 	}
 
@@ -223,22 +227,24 @@ void BlastFractureTool::setSourceMeshes(std::vector<Nv::Blast::Mesh*>& meshes, s
 	{
 		if (chunkMeshes[cs] == nullptr)
 			continue;
-		mChunkData[cs].meshData = new Nv::Blast::Mesh(*chunkMeshes[cs]);
+		mChunkData[cs].meshData = new MeshImpl(*reinterpret_cast<const MeshImpl*>(chunkMeshes[cs]));
 		mChunkData[cs].parent = parentIds[cs];
 		mChunkData[cs].chunkId = mChunkIdCounter++;
 		mChunkData[cs].isLeaf = isLeafs[cs];
 
 		mesh = mChunkData[cs].meshData;
-		Nv::Blast::Vertex* verticesBuffer = mesh->getVertices();
+		Nv::Blast::Vertex* verticesBuffer = const_cast<Nv::Blast::Vertex*>(mesh->getVertices());
 		for (uint32_t i = 0; i < mesh->getVerticesCount(); ++i)
 		{
 			verticesBuffer[i].p = (verticesBuffer[i].p - mOffset) * (1.0f / mScaleFactor);
 		}
-		mesh->getBoundingBox().minimum = (mesh->getBoundingBox().minimum - mOffset) * (1.0f / mScaleFactor);
-		mesh->getBoundingBox().maximum = (mesh->getBoundingBox().maximum - mOffset) * (1.0f / mScaleFactor);
+		PxBounds3& bb = const_cast<PxBounds3&>(mesh->getBoundingBox());
+		bb.minimum = (bb.minimum - mOffset) * (1.0f / mScaleFactor);
+		bb.maximum = (bb.maximum - mOffset) * (1.0f / mScaleFactor);
 		for (uint32_t i = 0; i < mesh->getFacetCount(); ++i)
 		{
-			mesh->getFacet(i)->userData = chunkMeshes[cs]->getFacet(i)->userData;
+			Facet* pFacet = const_cast<Facet*>(mesh->getFacet(i));
+			pFacet->materialId = chunkMeshes[cs]->getFacet(i)->materialId;
 		}
 	}
 }
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFractureTool.h b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFractureTool.h
index 42ff78f..3436551 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFractureTool.h
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastFractureTool.h
@@ -29,7 +29,7 @@
 #ifndef BLAST_FRACTURETOOL_H
 #define BLAST_FRACTURETOOL_H
 
-#include "NvBlastExtAuthoringFractureTool.h"
+#include "NvBlastExtAuthoringFractureToolImpl.h"
 
 class BlastAsset;
 namespace Nv
@@ -40,7 +40,7 @@ namespace Nv
 	}
 }
 
-class BlastFractureTool : public Nv::Blast::FractureTool
+class BlastFractureTool : public Nv::Blast::FractureToolImpl
 {
 public:
 	BlastFractureTool() {}
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastModel.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastModel.cpp
index 1e45003..2f00207 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastModel.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/blast/BlastModel.cpp
@@ -33,10 +33,25 @@
 // Add By Lixu End
 #include "tiny_obj_loader.h"
 #include "MathUtil.h"
-#include "NvBlastExtExporterFbxReader.h"
+#include "NvBlastExtExporter.h"
+#include "NvBlastGlobals.h"
 
 using namespace physx;
 
+void computeFacenormalByPosition(
+	physx::PxVec3 p0, physx::PxVec3 p1, physx::PxVec3 p2,
+	physx::PxVec3& facenormal)
+{
+	physx::PxVec3 p01 = p1 - p0;
+	physx::PxVec3 p02 = p2 - p0;
+
+	facenormal.x = p01.y * p02.z - p01.z * p02.y;
+	facenormal.y = p01.z * p02.x - p01.x * p02.z;
+	facenormal.z = p01.x * p02.y - p01.y * p02.x;
+
+	facenormal = -facenormal.getNormalized();
+}
+
 void computeTangentByPositionAndTexcoord(
 	physx::PxVec3 p0, physx::PxVec3 p1, physx::PxVec3 p2,
 	physx::PxVec2 r0, physx::PxVec2 r1, physx::PxVec2 r2,
@@ -67,14 +82,15 @@ BlastModelPtr BlastModel::loadFromFbxFile(const char* path)
 	model->bbMax = PxVec3(FLT_MIN, FLT_MIN, FLT_MIN);
 // Add By Lixu End
 
-	FbxFileReader rdr;
-	rdr.loadFromFile(path);
-	if (rdr.getBoneCount() == 0)
+
+	std::shared_ptr<Nv::Blast::IFbxFileReader> rdr(NvBlastExtExporterCreateFbxFileReader(), [](Nv::Blast::IFbxFileReader* p) {p->release(); });
+	rdr->loadFromFile(path);
+	if (rdr->getBoneCount() == 0)
 	{
 		return nullptr;
 	}
 
-	model->chunks.resize(rdr.getBoneCount());
+	model->chunks.resize(rdr->getBoneCount());
 
 	model->materials.push_back(BlastModel::Material());
 	
@@ -82,33 +98,33 @@ BlastModelPtr BlastModel::loadFromFbxFile(const char* path)
 	/**
 		Produce buffers of appropriate for AssetViewer format
 	*/
-	std::vector<uint32_t> infl;
-	rdr.getBoneInfluences(infl);
-	for (uint32_t i = 0; i < rdr.getBoneCount(); ++i)
+	uint32_t* infl;
+	rdr->getBoneInfluences(infl);
+	for (uint32_t i = 0; i < rdr->getBoneCount(); ++i)
 	{
-		std::vector<int32_t> indRemap(rdr.getPositionArray().size(), -1);
+		std::vector<int32_t> indRemap(rdr->getVerticesCount(), -1);
 		std::vector<uint32_t> indices;
 		SimpleMesh cmesh;
-		for (uint32_t j = 0; j < rdr.getPositionArray().size(); ++j)
+		for (uint32_t j = 0; j < rdr->getVerticesCount(); ++j)
 		{
 			if (i == infl[j])
 			{
 				indRemap[j] = (int32_t)cmesh.vertices.size();
 				cmesh.vertices.push_back(SimpleMesh::Vertex());
-				cmesh.vertices.back().normal = rdr.getNormalsArray()[j];
-				cmesh.vertices.back().position = rdr.getPositionArray()[j];
-				cmesh.vertices.back().uv = rdr.getUvArray()[j];	
+				cmesh.vertices.back().normal = rdr->getNormalsArray()[j];
+				cmesh.vertices.back().position = rdr->getPositionArray()[j];
+				cmesh.vertices.back().uv = rdr->getUvArray()[j];	
 			}
 		}
-		for (uint32_t j = 0; j < rdr.getIndexArray().size(); j += 3)
+		for (uint32_t j = 0; j < rdr->getIdicesCount(); j += 3)
 		{
-			if (i == infl[rdr.getIndexArray()[j]])
+			if (i == infl[rdr->getIndexArray()[j]])
 			{
-				int32_t lind = rdr.getIndexArray()[j + 2];
+				int32_t lind = rdr->getIndexArray()[j + 2];
 				cmesh.indices.push_back(indRemap[lind]);
-				lind = rdr.getIndexArray()[j + 1];
+				lind = rdr->getIndexArray()[j + 1];
 				cmesh.indices.push_back(indRemap[lind]);
-				lind = rdr.getIndexArray()[j];
+				lind = rdr->getIndexArray()[j];
 				cmesh.indices.push_back(indRemap[lind]);
 			}
 		}
@@ -116,6 +132,8 @@ BlastModelPtr BlastModel::loadFromFbxFile(const char* path)
 		model->chunks[i].meshes.push_back(Chunk::Mesh());
 		model->chunks[i].meshes.back().materialIndex = 0;
 		model->chunks[i].meshes.back().mesh = cmesh;
+
+		NVBLAST_FREE(infl);
 	}
 	return model;
 }
@@ -272,7 +290,7 @@ BlastModelPtr BlastModel::loadFromFileTinyLoader(const char* path)
 				}
 			}
 
-			// compute tangent
+			// compute facenormal and tangent
 			if (pMesh.mesh.indices.size() > 0 && allTriangles)
 			{
 				for (uint32_t i = 0; i < pMesh.mesh.indices.size(); i += 3)
@@ -281,6 +299,14 @@ BlastModelPtr BlastModel::loadFromFileTinyLoader(const char* path)
 					SimpleMesh::Vertex& v1 = chunkMesh.vertices[chunkMesh.indices[i + 1]];
 					SimpleMesh::Vertex& v2 = chunkMesh.vertices[chunkMesh.indices[i + 2]];
 
+					physx::PxVec3 facenormal;
+					computeFacenormalByPosition(
+						v0.position, v1.position, v2.position, facenormal);
+
+					v0.facenormal = facenormal;
+					v1.facenormal = facenormal;
+					v2.facenormal = facenormal;
+
 					physx::PxVec3 tangent;
 					computeTangentByPositionAndTexcoord(
 						v0.position, v1.position, v2.position, v0.uv, v1.uv, v2.uv, tangent);
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/core/SampleManager.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/core/SampleManager.cpp
index 61a174a..88af3a1 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/core/SampleManager.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/core/SampleManager.cpp
@@ -71,7 +71,8 @@
 #include "FileReferencesPanel.h"
 #include "BlastPlugin.h"
 #include "BlastToolBar.h"
-
+#include "NvBlastExtAuthoring.h"
+#include "NvBlastExtExporter.h"
 using namespace physx;
 
 const uint32_t DEFAULT_VORONOI_UNIFORM_SITES_NUMBER = 5;
@@ -122,7 +123,9 @@ void loggingCallback(int type, const char* msg, const char* file, int line)
 void buildPxChunks(const std::vector<std::vector<Triangle>>& chunkGeometry, std::vector<ExtPxAssetDesc::ChunkDesc>& pxChunks,
 	std::vector<ExtPxAssetDesc::SubchunkDesc>& pxSubchunks, std::vector<bool>& statics)
 {
-	ConvexMeshBuilder collisionBuilder(cooking, &physics->getPhysicsInsertionCallback());
+	std::shared_ptr<Nv::Blast::ConvexMeshBuilder> collisionBuilder(
+		NvBlastExtAuthoringCreateConvexMeshBuilder(cooking, &physics->getPhysicsInsertionCallback()),
+		[](Nv::Blast::ConvexMeshBuilder* cmb) {cmb->release(); });
 
 	pxChunks.resize(chunkGeometry.size());
 	pxSubchunks.resize(chunkGeometry.size());
@@ -137,7 +140,8 @@ void buildPxChunks(const std::vector<std::vector<Triangle>>& chunkGeometry, std:
 			vertices.push_back(chunkGeometry[i][p].c.p);
 		}
 		pxSubchunks[i].transform = physx::PxTransform(physx::PxIdentity);
-		pxSubchunks[i].geometry = physx::PxConvexMeshGeometry(collisionBuilder.buildConvexMesh(vertices));
+		pxSubchunks[i].geometry = physx::PxConvexMeshGeometry(
+			collisionBuilder.get()->buildConvexMesh(*collisionBuilder.get()->buildCollisionGeometry((uint32_t)vertices.size(), vertices.data())));
 		pxChunks[i].isStatic = statics.size() == 0 ? false : statics[i];
 		pxChunks[i].subchunkCount = 1;
 		pxChunks[i].subchunks = &pxSubchunks[i];
@@ -268,7 +272,7 @@ void saveFractureToObj(std::vector<std::vector<Triangle> > chunksGeometry, std::
 			std::vector<int> internalSurfaces;
 			for (uint32_t i = 0; i < totalSize; ++i)
 			{
-				if (chunksGeometry[vc][i].userInfo != 0)
+				if (chunksGeometry[vc][i].materialId != 0)
 				{
 					internalSurfaces.push_back(indx++);
 					internalSurfaces.push_back(indx++);
@@ -383,10 +387,10 @@ bool VoronoiFractureExecutor::execute()
 		if (mesh == nullptr)
 			continue;
 
-		VoronoiSitesGenerator* siteGenerator = nullptr;
+		VoronoiSitesGenerator* siteGenerator = NvBlastExtAuthoringCreateVoronoiSitesGenerator(mesh, m_randomGenerator == nullptr ? &sRandomGenerator : m_randomGenerator);
 		if (m_voronoi)
 		{
-			siteGenerator = new VoronoiSitesGenerator(mesh, m_randomGenerator == nullptr ? &sRandomGenerator : m_randomGenerator);
+//			siteGenerator = new VoronoiSitesGenerator(mesh, m_randomGenerator == nullptr ? &sRandomGenerator : m_randomGenerator);
 			if (0 == m_voronoi->siteGeneration)
 			{
 				siteGenerator->uniformlyGenerateSitesInMesh(m_voronoi->numSites);
@@ -398,11 +402,13 @@ bool VoronoiFractureExecutor::execute()
 		}
 		else
 		{
-			siteGenerator = new VoronoiSitesGenerator(mesh, m_randomGenerator == nullptr ? &sRandomGenerator : m_randomGenerator);
+//			siteGenerator = new VoronoiSitesGenerator(mesh, m_randomGenerator == nullptr ? &sRandomGenerator : m_randomGenerator);
 			siteGenerator->uniformlyGenerateSitesInMesh(DEFAULT_VORONOI_UNIFORM_SITES_NUMBER);
 		}
 
-		m_fractureTool->voronoiFracturing(*it, siteGenerator->getVoronoiSites(), false);
+		const physx::PxVec3* sites = nullptr;
+		uint32_t sitesCount = siteGenerator->getVoronoiSites(sites);
+		m_fractureTool->voronoiFracturing(*it, sitesCount, sites, false);
 		delete siteGenerator;
 	}
 	m_fractureTool->finalizeFracturing();
@@ -686,23 +692,24 @@ bool SampleManager::saveAsset(BlastAsset* pBlastAsset)
 	m_fTool->finalizeFracturing();
 
 	size_t nChunkListSize = m_fTool->getChunkCount();
-	std::vector<std::shared_ptr<Triangle> > chunkMeshes(nChunkListSize);
+	std::vector<Triangle*> chunkMeshes(nChunkListSize);
 	std::vector<uint32_t> chunkMeshesTriangleCount(nChunkListSize);
-	std::vector<bool> isSupport(nChunkListSize);
+	std::shared_ptr<bool> isSupport(new bool[nChunkListSize] { false }, [](bool* b) {delete[] b; });
 	for (uint32_t i = 0; i < nChunkListSize; ++i)
 	{
 		chunkMeshesTriangleCount[i] = m_fTool->getBaseMesh(i, chunkMeshes[i]);
-		isSupport[i] = m_fTool->getChunkInfo(i).isLeaf;
+		isSupport.get()[i] = m_fTool->getChunkInfo(i).isLeaf;
 	}
 
-	BlastBondGenerator bondGenerator(cooking, &physics->getPhysicsInsertionCallback());
+	std::shared_ptr<Nv::Blast::BlastBondGenerator> bondGenerator(
+		NvBlastExtAuthoringCreateBondGenerator(cooking, &physics->getPhysicsInsertionCallback()),
+		[](Nv::Blast::BlastBondGenerator* bg) {bg->release(); });
 	BondGenerationConfig cnf;
 	cnf.bondMode = BondGenerationConfig::AVERAGE;
-	std::vector<NvBlastChunkDesc> chunkDesc;
-	std::vector<NvBlastBondDesc> bondDescs;
-	bondGenerator.buildDescFromInternalFracture(m_fTool, isSupport, bondDescs, chunkDesc);
-	const uint32_t chunkCount = static_cast<uint32_t>(chunkDesc.size());
-	const uint32_t bondCount = static_cast<uint32_t>(bondDescs.size());
+	NvBlastChunkDesc* chunkDesc;
+	NvBlastBondDesc* bondDescs;
+	const uint32_t bondCount = bondGenerator.get()->buildDescFromInternalFracture(m_fTool, isSupport.get(), bondDescs, chunkDesc);
+	const uint32_t chunkCount = nChunkListSize;
 	if (bondCount == 0)
 	{
 		std::cout << "Can't create bonds descriptors..." << std::endl;
@@ -712,9 +719,9 @@ bool SampleManager::saveAsset(BlastAsset* pBlastAsset)
 	{
 		std::vector<uint32_t> chunkReorderMap(chunkCount);
 		std::vector<char> scratch(chunkCount * sizeof(NvBlastChunkDesc));
-		NvBlastEnsureAssetExactSupportCoverage(chunkDesc.data(), chunkCount, scratch.data(), loggingCallback);
-		NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDesc.data(), chunkCount, scratch.data(), loggingCallback);
-		NvBlastApplyAssetDescChunkReorderMapInPlace(chunkDesc.data(), chunkCount, bondDescs.data(), bondCount, chunkReorderMap.data(), true, scratch.data(), loggingCallback);
+		NvBlastEnsureAssetExactSupportCoverage(chunkDesc, chunkCount, scratch.data(), loggingCallback);
+		NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDesc, chunkCount, scratch.data(), loggingCallback);
+		NvBlastApplyAssetDescChunkReorderMapInPlace(chunkDesc, chunkCount, bondDescs, bondCount, chunkReorderMap.data(), true, scratch.data(), loggingCallback);
 		chunkReorderInvMap.resize(chunkReorderMap.size());
 		Nv::Blast::invertMap(chunkReorderInvMap.data(), chunkReorderMap.data(), static_cast<unsigned int>(chunkReorderMap.size()));
 	}
@@ -724,7 +731,7 @@ bool SampleManager::saveAsset(BlastAsset* pBlastAsset)
 	{
 		uint32_t chunkIndex = chunkReorderInvMap[i];
 		resultGeometry[chunkIndex].resize(chunkMeshesTriangleCount[i]);
-		memcpy(resultGeometry[chunkIndex].data(), chunkMeshes[i].get(), chunkMeshesTriangleCount[i] * sizeof(Triangle));
+		memcpy(resultGeometry[chunkIndex].data(), chunkMeshes[i], chunkMeshesTriangleCount[i] * sizeof(Triangle));
 	}
 
 	saveFractureToObj(resultGeometry, desc.name, outDir);
@@ -855,7 +862,7 @@ uint32_t createChunkRecursive(FbxManager* sdkManager, uint32_t currentCpIdx, uin
 		mesh->AddPolygon(currentCpIdx + cpIdx + 1);
 		mesh->AddPolygon(currentCpIdx + cpIdx + 2);
 		mesh->EndPolygon();
-		if (tri.userInfo == 0)
+		if (tri.materialId == 0)
 		{
 			matElement->GetIndexArray().SetAt(polyCount, 0);
 		}
@@ -1003,23 +1010,24 @@ bool SampleManager::exportAsset()
 	m_fTool->finalizeFracturing();
 
 	size_t nChunkListSize = m_fTool->getChunkCount();
-	std::vector<std::shared_ptr<Triangle> > chunkMeshes(nChunkListSize);
+	std::vector<Triangle*> chunkMeshes(nChunkListSize);
 	std::vector<uint32_t> chunkMeshesTriangleCount(nChunkListSize);
-	std::vector<bool> isSupport(nChunkListSize);
+	std::shared_ptr<bool> isSupport(new bool[nChunkListSize] { false }, [](bool* b) {delete[] b; });
 	for (uint32_t i = 0; i < nChunkListSize; ++i)
 	{
 		chunkMeshesTriangleCount[i] = m_fTool->getBaseMesh(i, chunkMeshes[i]);
-		isSupport[i] = m_fTool->getChunkInfo(i).isLeaf;
+		isSupport.get()[i] = m_fTool->getChunkInfo(i).isLeaf;
 	}
 
-	BlastBondGenerator bondGenerator(cooking, &physics->getPhysicsInsertionCallback());
+	std::shared_ptr<Nv::Blast::BlastBondGenerator> bondGenerator(
+		NvBlastExtAuthoringCreateBondGenerator(cooking, &physics->getPhysicsInsertionCallback()),
+		[](Nv::Blast::BlastBondGenerator* bg) {bg->release(); });
 	BondGenerationConfig cnf;
 	cnf.bondMode = BondGenerationConfig::AVERAGE;
-	std::vector<NvBlastChunkDesc> chunkDesc;
-	std::vector<NvBlastBondDesc> bondDescs;
-	bondGenerator.buildDescFromInternalFracture(m_fTool, isSupport, bondDescs, chunkDesc);
-	const uint32_t chunkCount = static_cast<uint32_t>(chunkDesc.size());
-	const uint32_t bondCount = static_cast<uint32_t>(bondDescs.size());
+	NvBlastChunkDesc* chunkDesc;
+	NvBlastBondDesc* bondDescs;
+	const uint32_t bondCount = bondGenerator.get()->buildDescFromInternalFracture(m_fTool, isSupport.get(), bondDescs, chunkDesc);
+	const uint32_t chunkCount = nChunkListSize;
 	if (bondCount == 0)
 	{
 		std::cout << "Can't create bonds descriptors..." << std::endl;
@@ -1029,9 +1037,9 @@ bool SampleManager::exportAsset()
 	{
 		std::vector<uint32_t> chunkReorderMap(chunkCount);
 		std::vector<char> scratch(chunkCount * sizeof(NvBlastChunkDesc));
-		NvBlastEnsureAssetExactSupportCoverage(chunkDesc.data(), chunkCount, scratch.data(), loggingCallback);
-		NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDesc.data(), chunkCount, scratch.data(), loggingCallback);
-		NvBlastApplyAssetDescChunkReorderMapInPlace(chunkDesc.data(), chunkCount, bondDescs.data(), bondCount, chunkReorderMap.data(), true, scratch.data(), loggingCallback);
+		NvBlastEnsureAssetExactSupportCoverage(chunkDesc, chunkCount, scratch.data(), loggingCallback);
+		NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDesc, chunkCount, scratch.data(), loggingCallback);
+		NvBlastApplyAssetDescChunkReorderMapInPlace(chunkDesc, chunkCount, bondDescs, bondCount, chunkReorderMap.data(), true, scratch.data(), loggingCallback);
 		chunkReorderInvMap.resize(chunkReorderMap.size());
 		Nv::Blast::invertMap(chunkReorderInvMap.data(), chunkReorderMap.data(), static_cast<unsigned int>(chunkReorderMap.size()));
 	}
@@ -1041,11 +1049,30 @@ bool SampleManager::exportAsset()
 	{
 		uint32_t chunkIndex = chunkReorderInvMap[i];
 		resultGeometry[chunkIndex].resize(chunkMeshesTriangleCount[i]);
-		memcpy(resultGeometry[chunkIndex].data(), chunkMeshes[i].get(), chunkMeshesTriangleCount[i] * sizeof(Triangle));
+		memcpy(resultGeometry[chunkIndex].data(), chunkMeshes[i], chunkMeshesTriangleCount[i] * sizeof(Triangle));
 	}
 
 	if (asset.exportFBX)
 	{
+		std::string outputFilePath = GlobalSettings::MakeFileName(outDir.c_str(), asset.fbx.buf);
+
+		Nv::Blast::ConvexMeshBuilder* collisionBuilder = NvBlastExtAuthoringCreateConvexMeshBuilder(cooking, &physics->getPhysicsInsertionCallback());
+		Nv::Blast::AuthoringResult* result = NvBlastExtAuthoringProcessFracture(*m_fTool, *bondGenerator, *collisionBuilder);
+
+		if (!asset.embedFBXCollision)
+		{
+			result->releaseCollisionHulls();
+		}
+
+		std::shared_ptr<IMeshFileWriter> fileWriter(NvBlastExtExporterCreateFbxFileWriter(bOutputFBXAscii), [](IMeshFileWriter* p) {p->release(); });
+		fileWriter->appendMesh(*result, asset.name.buf);
+		if (!fileWriter->saveToFile(asset.fbx.buf, outDir.c_str()))
+		{
+			std::cerr << "Can't write geometry to FBX file." << std::endl;
+			return false;
+		}
+
+#if (0)
 		FbxManager* sdkManager = FbxManager::Create();
 
 		FbxIOSettings* ios = FbxIOSettings::Create(sdkManager, IOSROOT);
@@ -1150,6 +1177,7 @@ bool SampleManager::exportAsset()
 
 		sdkManager->Destroy();
 		sdkManager = nullptr;
+#endif
 
 		std::string info = outputFilePath + " is saved.";
 		viewer_info(info.c_str());
@@ -1180,20 +1208,6 @@ bool SampleManager::exportAsset()
 		viewer_info(info.c_str());
 	}
 
-	if (asset.exportCollision)
-	{
-		SampleManager* pSampleManager = SampleManager::ins();
-		PhysXController& physXController = pSampleManager->getPhysXController();
-		PxPhysics& physics = physXController.getPhysics();
-		PxScene& scene = physXController.getPhysXScene();
-
-		std::string outputFilePath = GlobalSettings::MakeFileName(outDir.c_str(), asset.collision.buf);
-		physXController.ExportCollisionRepX(outputFilePath.c_str(), &physics, &scene, false);
-
-		std::string info = outputFilePath + " is saved.";
-		viewer_info(info.c_str());
-	}
-
 	if (asset.exportTKAsset)
 	{
 		std::string outputFilePath = GlobalSettings::MakeFileName(outDir.c_str(), asset.tkasset.buf);
@@ -1247,26 +1261,29 @@ void SampleManager::_createAsset(BlastAssetModelSimple** ppBlastAsset,
 	physicsManager = &bc.getExtPxManager();
 	TkFramework& tk = bc.getTkFramework();
 
-	std::vector<NvBlastChunkDesc> chunkDesc;
-	std::vector<NvBlastBondDesc> bondDescs;
-	std::vector<std::shared_ptr<Triangle> > chunkMeshes;
+	size_t nChunkListSize = m_fTool->getChunkCount();
+
+	std::vector<Triangle*> chunkMeshes;
 	std::vector<uint32_t> chunkMeshesTriangleCount(nChunkListSize);
-	std::vector<bool> isSupport;
+	std::shared_ptr<bool> isSupport(new bool[nChunkListSize] { false }, [](bool* b) {delete[] b; });
 
-	size_t nChunkListSize = m_fTool->getChunkCount();
 	chunkMeshes.resize(nChunkListSize);
-	isSupport.resize(nChunkListSize);
 	for (uint32_t i = 0; i < nChunkListSize; ++i)
 	{
 		chunkMeshesTriangleCount[i] = m_fTool->getBaseMesh(i, chunkMeshes[i]);
-		isSupport[i] = supports.size() == 0 ? m_fTool->getChunkInfo(i).isLeaf : supports[i];
+		isSupport.get()[i] = supports.size() == 0 ? m_fTool->getChunkInfo(i).isLeaf : supports[i];
 	}
 
-	BlastBondGenerator bondGenerator(cooking, &physics->getPhysicsInsertionCallback());
-	bondGenerator.buildDescFromInternalFracture(m_fTool, isSupport, bondDescs, chunkDesc);
-	bondDescs.clear();
-	bondGenerator.bondsFromPrefractured(chunkMeshes, isSupport, bondDescs);
-	int bondDescsSize = bondDescs.size();
+	std::shared_ptr<Nv::Blast::BlastBondGenerator> bondGenerator(
+		NvBlastExtAuthoringCreateBondGenerator(cooking, &physics->getPhysicsInsertionCallback()),
+		[](Nv::Blast::BlastBondGenerator* bg) {bg->release(); });
+	BondGenerationConfig cnf;
+	cnf.bondMode = BondGenerationConfig::AVERAGE;
+	NvBlastChunkDesc* chunkDesc;
+	NvBlastBondDesc* bondDescs;
+	const uint32_t bondCount = bondGenerator.get()->buildDescFromInternalFracture(m_fTool, isSupport.get(), bondDescs, chunkDesc);
+	const uint32_t chunkCount = nChunkListSize;
+	int bondDescsSize = bondCount;
 	if (bondDescsSize == worlds.size())
 	{		
 		for (int bds = 0; bds < bondDescsSize; bds++)
@@ -1278,8 +1295,6 @@ void SampleManager::_createAsset(BlastAssetModelSimple** ppBlastAsset,
 		}
 	}
 
-	const uint32_t chunkCount = static_cast<uint32_t>(chunkDesc.size());
-	const uint32_t bondCount = static_cast<uint32_t>(bondDescs.size());
 	if (bondCount == 0)
 	{
 		std::cout << "Can't create bonds descriptors..." << std::endl;
@@ -1290,9 +1305,9 @@ void SampleManager::_createAsset(BlastAssetModelSimple** ppBlastAsset,
 	{
 		std::vector<uint32_t> chunkReorderMap(chunkCount);
 		std::vector<char> scratch(chunkCount * sizeof(NvBlastChunkDesc));
-		NvBlastEnsureAssetExactSupportCoverage(chunkDesc.data(), chunkCount, scratch.data(), loggingCallback);
-		NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDesc.data(), chunkCount, scratch.data(), loggingCallback);
-		NvBlastApplyAssetDescChunkReorderMapInPlace(chunkDesc.data(), chunkCount, bondDescs.data(), bondCount, chunkReorderMap.data(), true, scratch.data(), loggingCallback);
+		NvBlastEnsureAssetExactSupportCoverage(chunkDesc, chunkCount, scratch.data(), loggingCallback);
+		NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDesc, chunkCount, scratch.data(), loggingCallback);
+		NvBlastApplyAssetDescChunkReorderMapInPlace(chunkDesc, chunkCount, bondDescs, bondCount, chunkReorderMap.data(), true, scratch.data(), loggingCallback);
 		chunkReorderInvMap.resize(chunkReorderMap.size());
 		Nv::Blast::invertMap(chunkReorderInvMap.data(), chunkReorderMap.data(), static_cast<unsigned int>(chunkReorderMap.size()));
 	}
@@ -1303,7 +1318,7 @@ void SampleManager::_createAsset(BlastAssetModelSimple** ppBlastAsset,
 	{
 		uint32_t chunkIndex = chunkReorderInvMap[i];
 		resultGeometry[chunkIndex].resize(chunkMeshesTriangleCount[i]);
-		memcpy(resultGeometry[chunkIndex].data(), chunkMeshes[i].get(), chunkMeshesTriangleCount[i] * sizeof(Triangle));
+		memcpy(resultGeometry[chunkIndex].data(), chunkMeshes[i], chunkMeshesTriangleCount[i] * sizeof(Triangle));
 	}
 
 	// prepare physics data (convexes)
@@ -1314,9 +1329,9 @@ void SampleManager::_createAsset(BlastAssetModelSimple** ppBlastAsset,
 	// build and serialize ExtPhysicsAsset
 	ExtPxAssetDesc	descriptor;
 	descriptor.bondCount = bondCount;
-	descriptor.bondDescs = bondDescs.data();
+	descriptor.bondDescs = bondDescs;
 	descriptor.chunkCount = chunkCount;
-	descriptor.chunkDescs = chunkDesc.data();
+	descriptor.chunkDescs = chunkDesc;
 	descriptor.bondFlags = joints.data();
 	descriptor.pxChunks = pxChunks.data();
 	ExtPxAsset* asset = ExtPxAsset::create(descriptor, tk);
@@ -2760,26 +2775,28 @@ void SampleManager::_addAssetToProjectParam(BlastAsset* pBlastAsset)
 	{
 		chunkArray.buf = new BPPChunk[chunkCount];
 		chunkArray.arraySizes[0] = chunkCount;
-		char chunkname[10];
+		char chunkname[32];
 		for (int cc = 0; cc < chunkCount; ++cc)
 		{
 			BPPChunk& chunk = chunkArray.buf[cc];
 			::init(chunk);
 
-			std::vector<uint32_t> parentChunkIndexes;
-			parentChunkIndexes.push_back(cc);
-			uint32_t parentChunkIndex = cc;
-			while ((parentChunkIndex = pNvBlastChunk[parentChunkIndex].parentChunkIndex) != -1)
-			{
-				parentChunkIndexes.push_back(parentChunkIndex);
-			}
+			//std::vector<uint32_t> parentChunkIndexes;
+			//parentChunkIndexes.push_back(cc);
+			//uint32_t parentChunkIndex = cc;
+			//while ((parentChunkIndex = pNvBlastChunk[parentChunkIndex].parentChunkIndex) != -1)
+			//{
+			//	parentChunkIndexes.push_back(parentChunkIndex);
+			//}
 
 			std::string strChunkName = "Chunk";
-			for (int pcIndex = parentChunkIndexes.size() - 1; pcIndex >= 0; pcIndex--)
-			{
-				sprintf(chunkname, "_%d", parentChunkIndexes[pcIndex]);
-				strChunkName += chunkname;
-			}
+			sprintf(chunkname, "_%d", cc);
+			strChunkName += chunkname;
+			//for (int pcIndex = parentChunkIndexes.size() - 1; pcIndex >= 0; pcIndex--)
+			//{
+			//	sprintf(chunkname, "_%d", parentChunkIndexes[pcIndex]);
+			//	strChunkName += chunkname;
+			//}
 			copy(chunk.name, strChunkName.c_str());
 
 			chunk.asset = asset.ID;
@@ -2927,7 +2944,7 @@ void SampleManager::_addAssetToProjectParam(BlastAsset* pBlastAsset)
 	{
 		bondArray.buf = new BPPBond[bondCount];
 		bondArray.arraySizes[0] = bondCount;
-		char bondname[20];
+		char bondname[64];
 		bool visible;
 		for (int bc = 0; bc < bondCount; ++bc)
 		{
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Mesh.h b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Mesh.h
index fa214e0..3ef7090 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Mesh.h
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Mesh.h
@@ -56,6 +56,7 @@ public:
 	public:
 		physx::PxVec3 position;
 		physx::PxVec3 normal;
+		physx::PxVec3 facenormal;
 		physx::PxVec3 tangent;
 		physx::PxVec2 uv;
 	};
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/RenderMaterial.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/RenderMaterial.cpp
index a9fedf0..88533cb 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/RenderMaterial.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/RenderMaterial.cpp
@@ -285,7 +285,7 @@ void RenderMaterial::setTextureFileName(std::string textureFileName, TextureType
 
 	std::string searchDir = mTextureFileNames[tt];
 	size_t ind = searchDir.find_last_of('/');
-	if (ind > 0)
+	if (ind > 0 && (ind != std::string::npos))
 		searchDir = searchDir.substr(0, ind);
 
 	ResourceManager* pResourceManager = ResourceManager::ins();
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderable.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderable.cpp
index 5ce713d..d51101f 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderable.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderable.cpp
@@ -29,7 +29,7 @@
 #include "Renderable.h"
 #include "Renderer.h"
 #include "RenderUtils.h"
-
+#include "GlobalSettings.h"
 const DirectX::XMFLOAT4 DEFAULT_COLOR(0.5f, 0.5f, 0.5f, 1.0f);
 
 Renderable::Renderable(IRenderMesh& mesh, RenderMaterial& material) : m_mesh(mesh), m_scale(1, 1, 1), m_color(DEFAULT_COLOR), m_hidden(false), m_transform(PxIdentity)
@@ -64,6 +64,7 @@ void Renderable::render(Renderer& renderer, bool depthStencilOnly) const
 	float useSpecularTexture = -1.0;
 	float useNormalTexture = -1.0;
 	float specularShininess = 1.0;
+	bool useTexture = GlobalSettings::Inst().m_renderStyle == MESH_RENDER_TEXTURED;
 	RenderMaterial& renderMaterial = m_materialInstance->getMaterial();
 	std::string mName = renderMaterial.getMaterialName();
 	if (mName != "")
@@ -77,19 +78,19 @@ void Renderable::render(Renderer& renderer, bool depthStencilOnly) const
 		specularColor = DirectX::XMFLOAT4(r, g, b, a);
 			
 		texName = renderMaterial.getTextureFileName();
-		if (texName != "" && !renderMaterial.isBadTexture())
+		if (useTexture && texName != "" && !renderMaterial.isBadTexture())
 		{
 			useDiffuseTexture = 1.0;
 		}
 
 		texName = renderMaterial.getTextureFileName(RenderMaterial::TT_Specular);
-		if (texName != "" && !renderMaterial.isBadTexture(RenderMaterial::TT_Specular))
+		if (useTexture && texName != "" && !renderMaterial.isBadTexture(RenderMaterial::TT_Specular))
 		{
 			useSpecularTexture = 1.0;
 		}
 
 		texName = renderMaterial.getTextureFileName(RenderMaterial::TT_Normal);
-		if (texName != "" && !renderMaterial.isBadTexture(RenderMaterial::TT_Normal))
+		if (useTexture && texName != "" && !renderMaterial.isBadTexture(RenderMaterial::TT_Normal))
 		{
 			useNormalTexture = 1.0;
 		}
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderer.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderer.cpp
index 9fe5038..00b3256 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderer.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderer.cpp
@@ -55,7 +55,6 @@ Renderer::Renderer()
 : m_cameraCB(nullptr)
 , m_worldCB(nullptr)
 , m_objectCB(nullptr)
-, m_RSState(nullptr)
 , m_opaqueRenderDSState(nullptr)
 , m_transparencyRenderDSState(nullptr)
 , m_opaqueRenderNoDepthDSState(nullptr)
@@ -79,6 +78,9 @@ Renderer::Renderer()
 	m_worldCBData.dirLightDir = DirectX::XMFLOAT3(-0.08f, -0.34f, -0.91f);
 	m_worldCBData.specularPower = 140.0f;
 	m_worldCBData.specularIntensity = 0.4f;
+	
+	m_RSState[0] = nullptr;
+	m_RSState[1] = nullptr;
 
 	toggleCameraSpeed(false);
 }
@@ -89,13 +91,9 @@ Renderer::~Renderer()
 
 void Renderer::initializeDefaultRSState()
 {
-	SAFE_RELEASE(m_RSState);
 	D3D11_RASTERIZER_DESC desc;
 	ZeroMemory(&desc, sizeof(desc));
-// Add By Lixu Begin
 	desc.CullMode = D3D11_CULL_NONE;
-// Add By Lixu End
-	desc.FillMode = m_wireframeMode ? D3D11_FILL_WIREFRAME : D3D11_FILL_SOLID;
 	desc.AntialiasedLineEnable = FALSE;
 	desc.DepthBias = 0;
 	desc.DepthBiasClamp = 0;
@@ -105,7 +103,11 @@ void Renderer::initializeDefaultRSState()
 	desc.ScissorEnable = FALSE;
 	desc.SlopeScaledDepthBias = 0;
 
-	V(m_device->CreateRasterizerState(&desc, &m_RSState));
+	desc.FillMode = D3D11_FILL_SOLID;
+	V(m_device->CreateRasterizerState(&desc, &m_RSState[0]));
+
+	desc.FillMode = D3D11_FILL_WIREFRAME;
+	V(m_device->CreateRasterizerState(&desc, &m_RSState[1]));
 }
 
 HRESULT Renderer::DeviceCreated(ID3D11Device* device)
@@ -242,7 +244,8 @@ void Renderer::DeviceDestroyed()
 	SAFE_RELEASE(m_cameraCB);
 	SAFE_RELEASE(m_worldCB);
 	SAFE_RELEASE(m_objectCB);
-	SAFE_RELEASE(m_RSState);
+	SAFE_RELEASE(m_RSState[0]);
+	SAFE_RELEASE(m_RSState[1]);
 	SAFE_RELEASE(m_opaqueRenderDSState);
 	SAFE_RELEASE(m_transparencyRenderDSState);
 	SAFE_RELEASE(m_opaqueRenderNoDepthDSState);
@@ -360,6 +363,10 @@ void Renderer::setAllConstantBuffers(ID3D11DeviceContext* ctx)
 void Renderer::Render(ID3D11Device* /*device*/, ID3D11DeviceContext* ctx, ID3D11RenderTargetView* pRTV,
 						  ID3D11DepthStencilView*)
 {
+	GlobalSettings& globalSettings = GlobalSettings::Inst();
+	if (!globalSettings.m_showGraphicsMesh)
+		return;
+
 	PROFILER_SCOPED_FUNCTION();
 
 	m_context = ctx;
@@ -389,6 +396,19 @@ void Renderer::Render(ID3D11Device* /*device*/, ID3D11DeviceContext* ctx, ID3D11
 		D3D11_MAPPED_SUBRESOURCE mappedResource;
 		ctx->Map(m_worldCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
 		CBWorld* worldBuffer = (CBWorld*)mappedResource.pData;
+		float flatNormal = -1.0;
+		if (globalSettings.m_renderStyle == MESH_RENDER_FLAT)
+		{
+			flatNormal = 1.0;
+		}
+		float useLighting = 1.0;
+		if (!globalSettings.m_useLighting)
+		{
+			useLighting = -1.0;
+		}
+		m_worldCBData.flatNormal = flatNormal;
+		m_worldCBData.wireFrameOver = -1.0;
+		m_worldCBData.useLighting = useLighting;
 		Light::FillLightShaderParam(m_worldCBData.lightParam);
 		memcpy(worldBuffer, &m_worldCBData, sizeof(m_worldCBData));
 		//worldBuffer->ambientColor = m_CBWorldData.ambientColor;
@@ -401,7 +421,15 @@ void Renderer::Render(ID3D11Device* /*device*/, ID3D11DeviceContext* ctx, ID3D11
 		ctx->Unmap(m_worldCB, 0);
 	}
 
-	ctx->RSSetState(m_RSState);
+	if (globalSettings.m_renderStyle != MESH_RENDER_WIREFRAME)
+	{
+		ctx->RSSetState(m_RSState[0]);
+	}
+	else
+	{
+		ctx->RSSetState(m_RSState[1]);
+	}
+	
 	ctx->PSSetSamplers(0, 1, &m_linearSampler);
 	ctx->PSSetSamplers(1, 1, &m_pointSampler);
 
@@ -450,7 +478,6 @@ void Renderer::Render(ID3D11Device* /*device*/, ID3D11DeviceContext* ctx, ID3D11
 	// Opaque render
 	{
 		ctx->RSSetViewports(1, &m_viewport);
-		ctx->RSSetState(m_RSState);
 		ctx->OMSetRenderTargets(1, &pRTV, m_DSView);
 		ctx->OMSetDepthStencilState(m_opaqueRenderDSState, 0xFF);
 
@@ -498,8 +525,44 @@ void Renderer::Render(ID3D11Device* /*device*/, ID3D11DeviceContext* ctx, ID3D11
 		}
 	}
 
+	// draw overline	
+	if (globalSettings.m_showWireframe)
+	{
+		ctx->RSSetState(m_RSState[1]);
+
+		// update wireFrameOver
+		{
+			D3D11_MAPPED_SUBRESOURCE mappedResource;
+			ctx->Map(m_worldCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+			CBWorld* worldBuffer = (CBWorld*)mappedResource.pData;
+			float wireFrameOver = -1.0;
+			{
+				if (globalSettings.m_showWireframe)
+				{
+					wireFrameOver = 1.0;
+				}
+			}
+			m_worldCBData.wireFrameOver = wireFrameOver;
+			memcpy(worldBuffer, &m_worldCBData, sizeof(m_worldCBData));
+			ctx->Unmap(m_worldCB, 0);
+		}
+
+		for (auto it = m_renderables.begin(); it != m_renderables.end(); it++)
+		{
+			if (!(*it)->isTransparent() && !(*it)->isHidden())
+			{
+				(*it)->render(*this);
+			}
+		}
+
+		if (globalSettings.m_renderStyle != MESH_RENDER_WIREFRAME)
+		{
+			ctx->RSSetState(m_RSState[0]);
+		}
+	}
+
 	// modulate shadows
-	if (m_shadowEnabled)
+	if (m_shadowEnabled && globalSettings.m_useLighting)
 	{
 		m_shadow.modulateShadowBuffer(pRTV);
 	}
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderer.h b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderer.h
index 6981e15..2142921 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderer.h
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/Renderer.h
@@ -198,6 +198,10 @@ class Renderer : public ISampleController
 		float specularPower;
 		DirectX::XMFLOAT3 dirLightColor;
 		float specularIntensity; // TODO: actually it's per object property
+		float flatNormal;
+		float wireFrameOver;
+		float useLighting;
+		float unusedPad4;
 		LightShaderParam lightParam;
 	};
 	struct CBObject
@@ -235,7 +239,7 @@ class Renderer : public ISampleController
 	D3D11_VIEWPORT                     m_viewport;
 
 	// DX11 states
-	ID3D11RasterizerState*             m_RSState;
+	ID3D11RasterizerState*             m_RSState[2];
 	ID3D11DepthStencilState*           m_opaqueRenderDSState;
 	ID3D11DepthStencilState*           m_transparencyRenderDSState;
 	ID3D11DepthStencilState*           m_opaqueRenderNoDepthDSState;
diff --git a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/ResourceManager.cpp b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/ResourceManager.cpp
index 6e4cc50..d1d04e2 100644
--- a/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/ResourceManager.cpp
+++ b/tools/ArtistTools/source/BlastPlugin/SampleBase/renderer/ResourceManager.cpp
@@ -241,7 +241,7 @@ bool ResourceManager::findFile(std::string fileName, const std::vector<const cha
 	}
 
 	size_t ind = fileNameOnly.find_last_of('/');
-	if (ind > 0)
+	if (ind > 0 && (ind != std::string::npos))
 		fileNameOnly = fileNameOnly.substr(ind + 1);
 
 // Add By Lixu Begin