├── SSDR.h ├── README.md ├── SSDR.cpp ├── stdafx.h ├── data └── url.txt ├── stdafx.cpp ├── targetver.h ├── .gitignore ├── util.h ├── main.cpp ├── QuadProg.h ├── ssdr.sln ├── LICENSE ├── ssdr.fx ├── ssdr.vcxproj.filters ├── QuadProg.cpp ├── HorseObject.h ├── Object.h ├── SampleApp.h ├── util.cpp ├── RigidTransform.h ├── ssdr.vcxproj ├── SampleApp.cpp └── HorseObject.cpp /SSDR.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TomohikoMukai/ssdr/HEAD/SSDR.h -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TomohikoMukai/ssdr/HEAD/README.md -------------------------------------------------------------------------------- /SSDR.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TomohikoMukai/ssdr/HEAD/SSDR.cpp -------------------------------------------------------------------------------- /stdafx.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TomohikoMukai/ssdr/HEAD/stdafx.h -------------------------------------------------------------------------------- /data/url.txt: -------------------------------------------------------------------------------- 1 | http://people.csail.mit.edu/sumner/research/deftransfer/data.html -------------------------------------------------------------------------------- /stdafx.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TomohikoMukai/ssdr/HEAD/stdafx.cpp -------------------------------------------------------------------------------- /targetver.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TomohikoMukai/ssdr/HEAD/targetver.h -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files 2 | *.slo 3 | *.lo 4 | *.o 5 | *.obj 6 | 7 | # Precompiled Headers 8 | *.gch 9 | *.pch 10 | 11 | # Compiled Dynamic libraries 12 | *.so 13 | *.dylib 14 | *.dll 15 | 16 | # Fortran module files 17 | *.mod 18 | 19 | # Compiled Static libraries 20 | *.lai 21 | *.la 22 | *.a 23 | *.lib 24 | 25 | # Executables 26 | *.exe 27 | *.out 28 | *.app 29 | -------------------------------------------------------------------------------- /util.h: -------------------------------------------------------------------------------- 1 | #ifndef UTIL_H 2 | #define UTIL_H 3 | #pragma once 4 | 5 | #include 6 | #include 7 | 8 | extern bool LoadObjFile(std::vector& position, std::vector& index, const std::wstring& filePath, float scale = 1.0f); 9 | extern bool ComputeNormal(std::vector& normal, const std::vector& position, const std::vector& index); 10 | 11 | #endif //UTIL_H 12 | -------------------------------------------------------------------------------- /main.cpp: -------------------------------------------------------------------------------- 1 | #include "SampleApp.h" 2 | #include 3 | #include "HorseObject.h" 4 | 5 | int _tmain(int argc, _TCHAR* argv[]) 6 | { 7 | #ifdef _DEBUG 8 | _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); 9 | #endif 10 | 11 | SampleApp::Config config; 12 | config.title = L"DemoSSDR"; 13 | 14 | SampleApp app(config); 15 | 16 | HorseObject::SharedPtr horse = HorseObject::CreateInstance(); 17 | app.AddObject(horse); 18 | 19 | return app.Run(); 20 | } 21 | 22 | -------------------------------------------------------------------------------- /QuadProg.h: -------------------------------------------------------------------------------- 1 | #ifndef QUADPROG_H 2 | #define QUADPROG_H 3 | #pragma once 4 | 5 | #include 6 | #include "QuadProg++.hh" 7 | 8 | // min (0.5 * xv^T * gm * xv + gv^T * x) 9 | // s.t. cem * xv + cev = 0 10 | // cim * xv + civ >= 0 11 | double SolveQP(const Eigen::MatrixXd& gm, const Eigen::VectorXd& gv, 12 | const Eigen::MatrixXd& cem, const Eigen::VectorXd& cev, 13 | const Eigen::MatrixXd& cim, const Eigen::VectorXd& civ, 14 | Eigen::VectorXd& xv); 15 | double TestSolveQP(); 16 | 17 | #endif //QUADPROG_H 18 | -------------------------------------------------------------------------------- /ssdr.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 2013 4 | VisualStudioVersion = 12.0.31101.0 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ssdr", "ssdr.vcxproj", "{4C49F59B-C04D-43A9-B5AD-C796FD3A81DD}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Release|x64 = Release|x64 12 | EndGlobalSection 13 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 14 | {4C49F59B-C04D-43A9-B5AD-C796FD3A81DD}.Debug|x64.ActiveCfg = Debug|x64 15 | {4C49F59B-C04D-43A9-B5AD-C796FD3A81DD}.Debug|x64.Build.0 = Debug|x64 16 | {4C49F59B-C04D-43A9-B5AD-C796FD3A81DD}.Release|x64.ActiveCfg = Release|x64 17 | {4C49F59B-C04D-43A9-B5AD-C796FD3A81DD}.Release|x64.Build.0 = Release|x64 18 | EndGlobalSection 19 | GlobalSection(SolutionProperties) = preSolution 20 | HideSolutionNode = FALSE 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Mukai Laboratory 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /ssdr.fx: -------------------------------------------------------------------------------- 1 | cbuffer CBPerFrame : register(b0) 2 | { 3 | matrix viewMatrix; 4 | matrix projectionMatrix; 5 | float4 lightColor; 6 | }; 7 | 8 | cbuffer CBPerObj : register(b1) 9 | { 10 | matrix worldMatrix; 11 | float3 localEyePos; 12 | float3 localLightPos; 13 | float4 ambientColor; 14 | float specExpon; 15 | }; 16 | 17 | cbuffer CBSkinningMatrix : register(b2) 18 | { 19 | matrix pallet[100]; 20 | } 21 | 22 | struct VertexData 23 | { 24 | float3 position : POSITION; 25 | float3 normal : NORMAL; 26 | float4 weight : BLENDWEIGHT; 27 | uint4 index : BLENDINDICES; 28 | float4 color : COLOR; 29 | }; 30 | 31 | struct LambertData 32 | { 33 | float4 position : SV_POSITION; 34 | float3 normal : NORMAL; 35 | float3 viewVec : TEXCOORD1; 36 | float3 lightVec : TEXCOORD2; 37 | float4 color : COLOR; 38 | }; 39 | 40 | float4 BlendPosition(float4 weight, uint4 index, float3 p) 41 | { 42 | float4 v = float4(p.xyz, 1.0f); 43 | float4 output = weight.x * mul(v, pallet[index.x]); 44 | output += weight.y * mul(v, pallet[index.y]); 45 | output += weight.z * mul(v, pallet[index.z]); 46 | output += weight.w * mul(v, pallet[index.w]); 47 | return float4(output.xyz, 1.0f); 48 | } 49 | 50 | float3 BlendNormal(float4 weight, uint4 index, float3 n) 51 | { 52 | float4 v = float4(n.xyz, 0); 53 | float4 output = weight.x * mul(v, pallet[index.x]); 54 | output += weight.y * mul(v, pallet[index.y]); 55 | output += weight.z * mul(v, pallet[index.z]); 56 | output += weight.w * mul(v, pallet[index.w]); 57 | return output.xyz; 58 | } 59 | 60 | LambertData LambertSkinVS(VertexData input) 61 | { 62 | LambertData output = (LambertData)0; 63 | output.position = BlendPosition(input.weight, input.index, input.position); 64 | output.position = mul(output.position, worldMatrix); 65 | output.position = mul(output.position, viewMatrix); 66 | output.position = mul(output.position, projectionMatrix); 67 | output.normal = BlendNormal(input.weight, input.index, input.normal.xyz); 68 | output.viewVec = normalize(localEyePos - input.position); 69 | output.lightVec = normalize(localLightPos - input.position); 70 | output.color = input.color; 71 | return output; 72 | } 73 | 74 | float4 LambertPS(LambertData input) : SV_TARGET0 75 | { 76 | float3 hn = normalize(input.viewVec + input.lightVec); 77 | float3 diffContrib = (lightColor.xyz * input.color.xyz) * max(dot(input.lightVec, input.normal), 0); 78 | return float4(ambientColor + diffContrib, input.color.w); 79 | } 80 | -------------------------------------------------------------------------------- /ssdr.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | ヘッダーファイル 20 | 21 | 22 | ヘッダーファイル 23 | 24 | 25 | ヘッダーファイル 26 | 27 | 28 | ヘッダーファイル 29 | 30 | 31 | ヘッダーファイル 32 | 33 | 34 | ヘッダーファイル 35 | 36 | 37 | ヘッダーファイル 38 | 39 | 40 | ヘッダーファイル 41 | 42 | 43 | ヘッダーファイル 44 | 45 | 46 | ヘッダーファイル 47 | 48 | 49 | ヘッダーファイル 50 | 51 | 52 | 53 | 54 | ソースファイル 55 | 56 | 57 | ソースファイル 58 | 59 | 60 | ソースファイル 61 | 62 | 63 | ソースファイル 64 | 65 | 66 | ソースファイル 67 | 68 | 69 | ソースファイル 70 | 71 | 72 | ソースファイル 73 | 74 | 75 | ソースファイル 76 | 77 | 78 | ソースファイル 79 | 80 | 81 | 82 | 83 | 84 | -------------------------------------------------------------------------------- /QuadProg.cpp: -------------------------------------------------------------------------------- 1 | #include "QuadProg.h" 2 | 3 | using namespace Eigen; 4 | 5 | double SolveQP(const MatrixXd& gm, const VectorXd& gv, 6 | const MatrixXd& cem, const VectorXd& cev, 7 | const MatrixXd& cim, const VectorXd& civ, 8 | VectorXd& xv) 9 | { 10 | QuadProgPP::Matrix G(gm.rows(), gm.cols()); 11 | for (int i = 0; i < gm.rows(); ++i) 12 | { 13 | for (int j = 0; j < gm.cols(); ++j) 14 | { 15 | G[i][j] = gm(i, j); 16 | } 17 | } 18 | QuadProgPP::Vector g0(gv.size()); 19 | for (int i = 0; i < gv.size(); ++i) 20 | { 21 | g0[i] = gv[i]; 22 | } 23 | QuadProgPP::Matrix CE; 24 | if (cem.rows() > 0 && cem.cols() > 0) 25 | { 26 | CE.resize(cem.cols(), cem.rows()); 27 | for (int i = 0; i < cem.rows(); ++i) 28 | { 29 | for (int j = 0; j < cem.cols(); ++j) 30 | { 31 | CE[j][i] = cem(i, j); 32 | } 33 | } 34 | } 35 | QuadProgPP::Vector ce0; 36 | if (cev.size() > 0) 37 | { 38 | ce0.resize(cev.size()); 39 | for (int i = 0; i < cev.size(); ++i) 40 | { 41 | ce0[i] = cev[i]; 42 | } 43 | } 44 | QuadProgPP::Matrix CI; 45 | if (cim.rows() > 0 && cim.cols() > 0) 46 | { 47 | CI.resize(cim.cols(), cim.rows()); 48 | for (int i = 0; i < cim.rows(); ++i) 49 | { 50 | for (int j = 0; j < cim.cols(); ++j) 51 | { 52 | CI[j][i] = cim(i, j); 53 | } 54 | } 55 | } 56 | QuadProgPP::Vector ci0; 57 | if (civ.size() > 0) 58 | { 59 | ci0.resize(civ.size()); 60 | for (int i = 0; i < civ.size(); ++i) 61 | { 62 | ci0[i] = civ[i]; 63 | } 64 | } 65 | QuadProgPP::Vector x(0.0, xv.size()); 66 | double retval = QuadProgPP::solve_quadprog(G, g0, CE, ce0, CI, ci0, x); 67 | for (int i = 0; i < xv.size(); ++i) 68 | { 69 | xv[i] = x[i]; 70 | } 71 | return retval; 72 | } 73 | 74 | double TestSolveQP() 75 | { 76 | MatrixXd H(2, 2); 77 | H(0, 0) = 1.0; 78 | H(0, 1) = -1.0; 79 | H(1, 0) = -1.0; 80 | H(1, 1) = 2.0; 81 | 82 | VectorXd f(2); 83 | f(0) = -2.0; 84 | f(1) = -6.0; 85 | 86 | MatrixXd A(2, 5); 87 | A(0, 0) = -1.0; 88 | A(1, 0) = -1.0; 89 | A(0, 1) = 1.0; 90 | A(1, 1) = -2.0; 91 | A(0, 2) = -2.0; 92 | A(1, 2) = -1.0; 93 | A(0, 3) = 1.0; 94 | A(1, 3) = 0.0; 95 | A(0, 4) = 0.0; 96 | A(1, 4) = 1.0; 97 | 98 | VectorXd b(5); 99 | b(0) = 2.0; 100 | b(1) = 2.0; 101 | b(2) = 3.0; 102 | b(3) = 0; 103 | b(4) = 0; 104 | 105 | MatrixXd C; 106 | VectorXd d; 107 | 108 | VectorXd xv(2); 109 | SolveQP(H, f, C, d, A, b, xv); 110 | printf("%f - %f\n", xv[0], xv[1]); 111 | return (xv[0] - 2.0 / 3.0) * (xv[0] - 2.0 / 3.0) + (xv[1] - 4.0 / 3.0) * (xv[1] - 4.0 / 3.0); 112 | } 113 | -------------------------------------------------------------------------------- /HorseObject.h: -------------------------------------------------------------------------------- 1 | #ifndef HORSE_OBJECT_H 2 | #define HORSE_OBJECT_H 3 | #pragma once 4 | 5 | #include "Object.h" 6 | #include "RigidTransform.h" 7 | 8 | class HorseObject : public Object 9 | { 10 | public: 11 | using SharedPtr = std::shared_ptr; 12 | using UniquePtr = std::unique_ptr; 13 | 14 | protected: 15 | struct ConstantBufferPerFrame 16 | { 17 | DirectX::XMFLOAT4X4A view; 18 | DirectX::XMFLOAT4X4A proj; 19 | DirectX::XMFLOAT4A lightColor; 20 | }; 21 | static const int NumMaxSkinningMatrix = 100; 22 | struct ConstantBufferSkinningMatrix 23 | { 24 | DirectX::XMFLOAT4X4A pallet[NumMaxSkinningMatrix]; 25 | }; 26 | struct ConstantBufferPerObj 27 | { 28 | DirectX::XMFLOAT4X4A world; 29 | DirectX::XMFLOAT3A localEyePos; 30 | DirectX::XMFLOAT3A localLightPos; 31 | DirectX::XMFLOAT4A ambientColor; 32 | float specExpon; 33 | }; 34 | struct CustomVertex 35 | { 36 | static const int NumInfluences = 4; 37 | DirectX::XMFLOAT3A position; 38 | DirectX::XMFLOAT3A normal; 39 | float weight[NumInfluences]; 40 | unsigned int indices[NumInfluences]; 41 | DirectX::XMFLOAT4A color; 42 | }; 43 | static D3D11_INPUT_ELEMENT_DESC customVertexLayout[5]; 44 | 45 | 46 | public: 47 | static SharedPtr CreateInstance() 48 | { 49 | SharedPtr r(new HorseObject()); 50 | r->self = r; 51 | return r; 52 | } 53 | virtual ~HorseObject(); 54 | 55 | public: 56 | bool OnInit(ID3D11Device* device, ID3D11DeviceContext* deviceContext, const UINT width, const UINT height) override; 57 | void OnResize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, const UINT width, const UINT height) override; 58 | void OnUpdate(ID3D11Device* device, ID3D11DeviceContext* deviceContext, float elapsed); 59 | void OnRender(ID3D11Device* device, ID3D11DeviceContext* deviceContext) override; 60 | void OnDestroy() override; 61 | 62 | protected: 63 | HRESULT InitShader(ID3D11Device* device); 64 | HRESULT LoadModel(ID3D11Device* device, const wchar_t* filePath, const DirectX::XMFLOAT4A& color); 65 | bool LoadAnim(const wchar_t* filePath); 66 | void ColorVerticesByError(int frame, float upperBound); 67 | 68 | private: 69 | ID3D11Buffer* constantBufferPerFrame; 70 | ID3D11Buffer* constantBufferPerObj; 71 | ID3D11Buffer* constantBufferSkinningBone; 72 | ConstantBufferPerFrame perFrameData; 73 | DirectX::XMFLOAT3A lightPosition; 74 | ID3D11InputLayout* inputLayout; 75 | ID3D11VertexShader* vertexShader; 76 | ID3D11PixelShader* pixelShader; 77 | ID3D11BlendState* alphaBlendState; 78 | 79 | ID3D11Buffer* vertexBuffer; 80 | ID3D11Buffer* indexBuffer; 81 | unsigned long numVertices; 82 | unsigned long numFaces; 83 | 84 | CustomVertex* vertexBufferCPU; 85 | CustomVertex* srcVertexBufferCPU; 86 | std::vector vertexAnim; 87 | std::vector boneAnim; 88 | unsigned long numFrames; 89 | unsigned long frame; 90 | int numBones; 91 | 92 | protected: 93 | HorseObject(); 94 | }; 95 | 96 | #endif //HORSE_OBJECT_H 97 | -------------------------------------------------------------------------------- /Object.h: -------------------------------------------------------------------------------- 1 | #ifndef OBJECT_H 2 | #define OBJECT_H 3 | #pragma once 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | struct Object 11 | { 12 | public: 13 | using SharedPtr = std::shared_ptr