</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<IncludePath>../../win32/;$(IncludePath)</IncludePath>
+ <LibraryPath>H:\libs\DirectXTK\Bin\Desktop\x64\Debug;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
</ClCompile>
<Link>
<AdditionalDependencies>winmm.lib;DWMApi.lib;d2d1.lib;Avrt.lib;Dwrite.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <OutputFile>$(OutDir)STed2.exe</OutputFile>
+ <OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<IgnoreSpecificDefaultLibraries>;libcmt;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(OutDir)STed2.pdb</ProgramDatabaseFile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="acconfig.h" />
+ <ClInclude Include="base_window.h" />
+ <ClInclude Include="code_converter.h" />
<ClInclude Include="config.h" />
<ClInclude Include="doslib.h" />
+ <ClInclude Include="dout.h" />
+ <ClInclude Include="dpi.h" />
<ClInclude Include="exception.h" />
<ClInclude Include="gettext_wrapper.h" />
<ClInclude Include="graph.h" />
+ <ClInclude Include="icon.h" />
<ClInclude Include="iocslib.h" />
+ <ClInclude Include="jumplist.h" />
+ <ClInclude Include="logger.h" />
<ClInclude Include="machin.h" />
+ <ClInclude Include="message_loop.h" />
<ClInclude Include="mididev.h" />
<ClInclude Include="midi_in.h" />
<ClInclude Include="netbsdgetopt.h" />
<ClCompile Include="assign.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
+ <ClCompile Include="base_window.cpp" />
<ClCompile Include="basic.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="cm6con.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
+ <ClCompile Include="code_converter.cpp" />
<ClCompile Include="defload.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="dos.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
+ <ClCompile Include="dpi.cpp" />
<ClCompile Include="edit.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="itor.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
+ <ClCompile Include="jumplist.cpp" />
<ClCompile Include="key_sub.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
+ <ClCompile Include="logger.cpp" />
<ClCompile Include="mcpy.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="sted_vals.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
+ <ClCompile Include="taskbar.cpp" />
+ <ClCompile Include="timer.cpp" />
<ClCompile Include="track.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_color.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_file.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_graphics.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_key.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_midi.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_misc.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_pointer.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_text.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="win32_win.cpp">
- <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+ <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
</ClCompile>
<ClCompile Include="x68funcs.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
--- /dev/null
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-10 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+#include "StdAfx.h"
+#include "base_window.h"
+
+namespace sf {
+}
\ No newline at end of file
--- /dev/null
+#pragma once
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-10 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+namespace sf {
+/** window \83x\81[\83X\83N\83\89\83X */
+
+struct rect {
+ uint32_t width;
+ uint32_t height;
+};
+
+struct base_window : boost::noncopyable
+{
+ typedef boost::signals2::signal<void ()> on_render_type;
+
+ on_render_type on_render;
+
+ // \90¶\82ÌWindow\83n\83\93\83h\83\8b\82ð\95Ô\82·\81B
+ virtual void * raw_handle() const = 0;
+ // \83E\83B\83\93\83h\83E\82ð\90¶\90¬\82·\82é
+ virtual void create() = 0;
+// virtual void show(uint32_t show_flag) = 0;
+ // \83E\83B\83\93\83h\83E\82ð\95\\8e¦\82·\82é
+ virtual void show() = 0;
+ // \83E\83B\83\93\83h\83E\82ª\8d¡\95\\8e¦\82³\82ê\82Ä\82¢\82é\82©\82ð\95Ô\82·
+ virtual bool is_show() = 0;
+ // \83E\83B\83\93\83h\83E\82ð\89B\82·
+ virtual void hide() = 0;
+ //virtual void activate() = 0;
+ //virtual bool is_activate() = 0;
+ //virtual void deactivate() = 0;
+ //virtual void
+ //virtual void size(uint32_t width,uint32_t height);
+ //virtual rect size();
+
+ virtual void text(std::wstring& text) = 0;
+ //virtual std::wstring text() = 0;
+
+ virtual void update() = 0;
+
+protected:
+ virtual ~base_window() {};
+
+};
+
+}
+
--- /dev/null
+#include "stdafx.h"
+
+namespace sf
+{
+
+ code_converter<char,wchar_t>::code_converter(const char*p)
+ {
+ int len = ::MultiByteToWideChar(CP_ACP,0,p,-1,NULL,0);
+ m_dest.reset(new wchar_t[len]);
+ ::MultiByteToWideChar(CP_ACP,0,p,-1,&m_dest[0],len);
+ };
+
+ code_converter<char,wchar_t>::code_converter(const std::string& p)
+ {
+ int len = ::MultiByteToWideChar(CP_ACP,0,p.c_str(),-1,NULL,0);
+ m_dest.reset(new wchar_t[len]);
+ ::MultiByteToWideChar(CP_ACP,0,p.c_str(),-1,&m_dest[0],len);
+ };
+
+ code_converter<wchar_t,char>::code_converter(const wchar_t*p)
+ {
+ int len = ::WideCharToMultiByte(CP_ACP,0,p,-1,NULL,0,NULL,NULL);
+ m_dest.reset(new char[len]);
+ ::WideCharToMultiByte(CP_ACP,0,p,-1,&m_dest[0],len,NULL,NULL);
+ };
+
+ code_converter<wchar_t,char>::code_converter(const std::wstring & p)
+ {
+ int len = ::WideCharToMultiByte(CP_ACP,0,p.c_str(),-1,NULL,0,NULL,NULL);
+ m_dest.reset(new char[len]);
+ ::WideCharToMultiByte(CP_ACP,0,p.c_str(),-1,&m_dest[0],len,NULL,NULL);
+ };
+
+};
\ No newline at end of file
--- /dev/null
+#pragma once
+
+
+/** @file
+ * @author S.F. (Satoshi Fujiwara)
+ * @brief wchar_t <--> char の変換ユーティリティ
+ * 引数として文字列を引き渡す際、変換が必要な場合、下記のようにアダプタ的に使用することを想定している。
+ * std::wstring a(L"abcd");
+ * std::wstring b((sf::code_converter<wcha_t,char>(a)));
+ *
+ * 後、ATLコード差し替え用のtypedefも用意している。
+ * これは、アダプタとしての利用のみに限定される。
+ * sf::ct2a hoge_(L"abcef"); // 想定していない（動作する場合もあるし、ダメな場合もある）
+ */
+
+namespace sf
+{
+ /** 雛形 */
+ template <typename SrcChar,typename DestChar>
+ struct code_converter
+ {
+ public:
+ explicit code_converter(SrcChar* p);
+ explicit code_converter(std::basic_string<SrcChar> & p);
+ operator DestChar*();
+ };
+
+ /** char -> wchar_tへの変換 */
+ template <>
+ struct code_converter<char,wchar_t>
+ {
+ explicit code_converter(const char* p);
+ explicit code_converter(const std::string& p);
+
+ operator wchar_t*() const {return m_dest.get();}
+ private:
+ boost::scoped_array<wchar_t> m_dest;
+ };
+
+ /** wchar_t -> char */
+ template <>
+ struct code_converter<wchar_t,char>
+ {
+ explicit code_converter(const wchar_t* p);
+ explicit code_converter(const std::wstring& p);
+ operator char* () const {return m_dest.get();}
+ private:
+ boost::scoped_array<char> m_dest;
+ };
+
+ /** ATLコード差し替えのためのエイリアス */
+ typedef sf::code_converter<char,wchar_t> ca2w;
+
+ /** ATLコード差し替えのためのエイリアス */
+ typedef sf::code_converter<wchar_t,char> cw2a;
+
+ #ifdef _UNICODE
+
+ /** ATLコード差し替えのためのエイリアス */
+ typedef sf::code_converter<char,wchar_t> ca2t;
+ /** ATLコード差し替えのためのエイリアス */
+ typedef sf::code_converter<wchar_t,char> ct2a;
+
+ /** ATLコード差し替えのためのエイリアス */
+ inline const wchar_t* ct2w(const wchar_t* p) { return p;};
+ /** ATLコード差し替えのためのエイリアス */
+ inline const wchar_t* cw2t(const wchar_t* p) { return p;};
+
+ #else
+
+ /** ATLコード差し替えのためのエイリアス */
+ inline const char* ct2a(const char* p) { return p;};
+ /** ATLコード差し替えのためのエイリアス */
+ inline const char* ca2t(const char* p) { return p;};
+
+ #endif
+}
+
+
--- /dev/null
+#pragma once
+
+/* http://vision.kuee.kyoto-u.ac.jp/~nob/doc/win32/win32.html#doc1_42
+ \82æ\82è\94q\8eØ
+*/
+
+
+#ifndef STDX_DSTREAM_H
+
+#define STDX_DSTREAM_H
+
+namespace sf
+{
+
+#ifdef _DEBUG
+
+// VC++ \82Å STLport \82¾\82Æ using std::char_traits; \82Ý\82½\82¢\82È\82Ì\82ª\95K\97v\82©\82à
+template <typename Ch_T, typename Tr_T = std::char_traits<Ch_T> >
+class basic_dbg_streambuf: public std::basic_stringbuf<Ch_T, Tr_T>
+{
+public:
+ basic_dbg_streambuf()
+ {
+#ifndef STDX_DSTREAM_BUFFERING
+ setbuf(0,0);
+#endif
+ }
+
+ virtual ~basic_dbg_streambuf()
+ {
+ sync();
+ }
+
+protected:
+ int sync(void)
+ {
+ dbg_out(str().c_str());
+ pbump(static_cast<int>(pbase() - pptr()));
+ return 0;
+ }
+
+ void dbg_out(const Ch_T*);
+};
+
+template <>
+inline void basic_dbg_streambuf<char>::dbg_out(const char *str)
+{
+ ::OutputDebugStringA(str);
+}
+
+template <>
+inline void basic_dbg_streambuf<wchar_t>::dbg_out(const wchar_t *str)
+{
+ ::OutputDebugStringW(str);
+}
+
+template <typename Ch_T, typename Tr_T = std::char_traits<Ch_T> >
+class basic_dbg_ostream: public std::basic_ostream<Ch_T, Tr_T>
+{
+public:
+ basic_dbg_ostream() : std::basic_ostream<Ch_T, Tr_T>(new basic_dbg_streambuf<Ch_T, Tr_T>())
+ {
+ }
+
+ virtual ~basic_dbg_ostream()
+ {
+ // flush(); // \95s\97v\82ç\82µ\82¢\81Dhttp://www.tietew.jp/cppll/archive/607
+ delete rdbuf();
+ }
+};
+
+typedef basic_dbg_streambuf<wchar_t> wdbg_streambuf;
+typedef basic_dbg_ostream<wchar_t> wdstream;
+
+// \82±\82ê\82ð\92è\8b`\82µ\82Ä\82¨\82\82Æ\81C dout \82Ì\90é\8c¾\82ª\82¢\82ç\82È\82\82È\82é\81D
+
+static wdstream wdout;
+#define DOUT(x) wdout << x
+}
+#else
+#define DOUT(x)
+#define wdout //
+// struct dummy_wdout {
+// //template <typename R>
+// //inline dummy_wdout& operator<<(const R v) {return *this;};
+//
+// //template <typename R>
+// //inline dummy_wdout& operator<<(const R* v) {return *this;};
+//
+// //template <typename R>
+// //inline dummy_wdout& operator<<(const R& v) {return *this;};
+//
+// //template <typename R>
+// //inline dummy_wdout& operator<<(const R&& v) {return *this;};
+//
+// ////template <typename R,int N>
+// ////inline dummy_wdout& operator<<(const R(&a)[N]) {return *this;};
+//
+// };
+//
+// static dummy_wdout wdout;
+//}
+//
+//template <typename L>
+//inline sf::dummy_wdout& operator<<(sf::dummy_wdout& p,const L v) {return p;};
+//
+//template <typename L>
+//inline sf::dummy_wdout& operator<<(sf::dummy_wdout& p,const L& v) {return p;};
+//
+//template <typename L>
+//inline sf::dummy_wdout& operator<<(sf::dummy_wdout& p,const L&& v) {return p;};
+//
+////template <typename L>
+////inline sf::dummy_wdout& operator<<(sf::dummy_wdout& p,const L* v) {return p;};
+//
+//template <typename L,int N>
+//inline sf::dummy_wdout& operator<<(sf::dummy_wdout& p,const L(&a)[N]) {return p;};
+//
+//template <typename L>
+//inline L& operator<<(const L v,sf::dummy_wdout& p) {return v;};
+//
+//template <typename L>
+//inline L& operator<<(sf::dummy_wdout& p,L v) {return v;};
+//
+//
+//template <typename L>
+//inline sf::dummy_wdout& operator<<(const L v,sf::dummy_wdout& p) {return p;};
+//
+//template <typename L>
+//inline sf::dummy_wdout& operator<<(const L& v,sf::dummy_wdout& p) {return p;};
+//
+////template <typename L>
+////inline sf::dummy_wdout& operator<<(const L* v,sf::dummy_wdout& p) {return p;};
+//
+//template <typename L>
+//inline sf::dummy_wdout& operator<<(const L&& v,sf::dummy_wdout& p) {return p;};
+//
+//
+//template <typename L,int N>
+//inline sf::dummy_wdout& operator<<(const L(&a)[N],sf::dummy_wdout& p) {return p;};
+////
+//template <typename L>
+//inline sf::dummy_wdout& operator<<(sf::dummy_wdout& p , const L *v) {return p;};
+
+//
+}
+#endif
+#endif // STDX_DSTREAM_
\ No newline at end of file
--- /dev/null
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-10 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+
+#include "StdAfx.h"
+#if _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
+#endif
+#include "sf_windows.h"
+#include "dpi.h"
+
+namespace sf {
+ void dpi::init()
+ {
+ if (!init_)
+ {
+ sf::get_dc hdc(0);
+ if (hdc.get())
+ {
+ dpi_x_ = GetDeviceCaps(hdc.get(), LOGPIXELSX);
+ dpi_y_ = GetDeviceCaps(hdc.get(), LOGPIXELSY);
+ ReleaseDC(NULL, hdc.get());
+ }
+ init_ = true;
+ }
+ }
+
+}
\ No newline at end of file
--- /dev/null
+#pragma once
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-10 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+
+namespace sf{
+ template <typename T>
+ class dpi_t
+ {
+ public:
+ dpi_t() : init_(false), dpi_x_(96), dpi_y_(96) { }
+ // \89æ\96Ê\82Ì DPI \82ð\8eæ\93¾\82µ\82Ü\82·\81B
+ T dpix() { init(); return dpi_x_; }
+ T dpiy() { init(); return dpi_y_; }
+
+ // \90â\91Î\83s\83N\83Z\83\8b\82Æ\91\8a\91Î\83s\83N\83Z\83\8b\8aÔ\82Ì\95Ï\8a·\82ð\8ds\82¢\82Ü\82·\81B
+ T scale_x(T x) { init(); return MulDiv(x, dpi_x_, 96); }
+ T scale_y(T y) { init(); return MulDiv(y, dpi_y_, 96); }
+ T unscale_x(T x) { init(); return MulDiv(x, 96, dpi_x_); }
+ T unscale_y(T y) { init(); return MulDiv(y, 96, dpi_y_); }
+
+ // \89æ\96Ê\83T\83C\83Y (\91\8a\91Î\83s\83N\83Z\83\8b\92P\88Ê) \82ð\8b\81\82ß\82Ü\82·\81B
+ T scaled_screen_width() { return scaled_system_metrix_x(SM_CXSCREEN); }
+ T scaled_screen_height() { return scaled_system_metrix_y(SM_CYSCREEN); }
+
+ // \8el\8ap\8c`\82Ì\83T\83C\83Y\82ð\90â\91Î\83s\83N\83Z\83\8b\82©\82ç\91\8a\91Î\83s\83N\83Z\83\8b\82É\95Ï\8dX\82µ\82Ü\82·\81B
+ void scale_rect(RECT *rect_ptr)
+ {
+ rect_ptr->left = scale_x(rect_ptr->left);
+ rect_ptr->right = scale_x(rect_ptr->right);
+ rect_ptr->top = scale_y(rect_ptr->top);
+ rect_ptr->bottom = scale_y(rect_ptr->bottom);
+ }
+
+ // \89æ\96Ê\89ð\91\9c\93x\82ª\8dÅ\92á\92l (\91\8a\91Î\83s\83N\83Z\83\8b\92P\88Ê) \82ð\96\9e\82½\82µ\82Ä\82¢\82é\82©\82Ç\82¤\82©\82ð
+ // \8am\94F\82µ\82Ü\82·\81B
+ bool is_resolution_at_least(T xmin, T ymin)
+ {
+ return (scaled_screen_width() >= xmin) && (scaled_screen_height() >= ymin);
+ }
+ // \83|\83C\83\93\83g \83T\83C\83Y (1/72 \83C\83\93\83`) \82ð\90â\91Î\83s\83N\83Z\83\8b\82É\95Ï\8a·\82µ\82Ü\82·\81B
+ T point_to_pixels(int pt) { return MulDiv(pt, dpi_y_, 72); }
+ // \83L\83\83\83b\83V\83\85\82³\82ê\82½\83\81\83g\83\8a\83b\83N\82ð\82·\82×\82Ä\96³\8cø\82É\82µ\82Ü\82·\81B
+ void invalidate() { init_ = false; }
+ private:
+ void init();
+
+ T scaled_system_metrix_x(int nIndex)
+ {
+ init();
+ return MulDiv(GetSystemMetrics(nIndex), 96, dpi_x_);
+ }
+
+ T scaled_system_metrix_y(int nIndex)
+ {
+ init();
+ return MulDiv(GetSystemMetrics(nIndex), 96, dpi_y_);
+ }
+
+ private:
+ bool init_;
+ T dpi_x_;
+ T dpi_y_;
+ };
+
+ typedef dpi_t<int> dpi;
+}
#include <boost/assign/ptr_list_of.hpp>
#include <boost/assign/ptr_list_inserter.hpp>
#include <boost/foreach.hpp>
+
+#if _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
+#endif
+
#include "sf_memory.h"
using namespace boost;
std::map<HRESULT,std::wstring> com_error_ = boost::assign::list_of<std::pair<HRESULT,std::wstring> >
(E_POINTER,L"E_POINTER")
(E_INVALIDARG,L"E_INVALIDARG")
+ (DWRITE_E_FILEFORMAT,L"DWRITE_E_FILEFORMAT")
+ (DWRITE_E_UNEXPECTED,L"DWRITE_E_UNEXPECTED")
+ (DWRITE_E_NOFONT,L"DWRITE_E_NOFONT")
+ (DWRITE_E_FILENOTFOUND,L"DWRITE_E_FILENOTFOUND")
+ (DWRITE_E_FILEACCESS,L"DWRITE_E_FILEACCESS")
+ (DWRITE_E_FONTCOLLECTIONOBSOLETE,L"DWRITE_E_FONTCOLLECTIONOBSOLETE")
+ (DWRITE_E_ALREADYREGISTERED,L"DWRITE_E_ALREADYREGISTERED")
(AUDCLNT_E_NOT_INITIALIZED,L"AUDCLNT_E_NOT_INITIALIZED")
(AUDCLNT_E_ALREADY_INITIALIZED,L"AUDCLNT_E_ALREADY_INITIALIZED")
(AUDCLNT_E_WRONG_ENDPOINT_TYPE,L"AUDCLNT_E_WRONG_ENDPOINT_TYPE")
(AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL,L"AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL")
(AUDCLNT_E_EVENTHANDLE_NOT_SET,L"AUDCLNT_E_EVENTHANDLE_NOT_SET")
(AUDCLNT_E_INCORRECT_BUFFER_SIZE,L"AUDCLNT_E_INCORRECT_BUFFER_SIZE")
- (AUDCLNT_E_BUFFER_SIZE_ERROR,L"AUDCLNT_E_BUFFER_SIZE_ERROR")
+ (AUDCLNT_E_CPUUSAGE_EXCEEDED,L"AUDCLNT_E_CPUUSAGE_EXCEEDED")
+ (AUDCLNT_E_BUFFER_ERROR,L"AUDCLNT_E_BUFFER_ERROR")
+ (AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED,L"AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED")
+ (AUDCLNT_E_BUFFER_SIZE_ERROR,L"AUDCLNT_E_BUFFER_SIZE_ERROR")
+ (AUDCLNT_E_INVALID_DEVICE_PERIOD,L"AUDCLNT_E_INVALID_DEVICE_PERIOD")
(AUDCLNT_S_BUFFER_EMPTY,L"AUDCLNT_S_BUFFER_EMPTY")
- (AUDCLNT_S_THREAD_ALREADY_REGISTERED,L"AUDCLNT_S_THREAD_ALREADY_REGISTERED");
+ (AUDCLNT_S_THREAD_ALREADY_REGISTERED,L"AUDCLNT_S_THREAD_ALREADY_REGISTERED")
+ (AUDCLNT_S_POSITION_STALLED,L"AUDCLNT_S_POSITION_STALLED")
+ (DXGI_ERROR_UNSUPPORTED,L"DXGI_ERROR_UNSUPPORTED ")
+ (DXGI_STATUS_OCCLUDED,L"DXGI_STATUS_OCCLUDED")
+ (DXGI_STATUS_CLIPPED,L"DXGI_STATUS_CLIPPED")
+ ;
-win32_error_exception::win32_error_exception(boost::uint32_t hr)
+win32_error_exception::win32_error_exception(uint32_t hr)
: std::exception("HRESULT ERROR"),hresult_(hr)
{
local_memory<wchar_t> mem;
- DWORD result = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,0,hr,0,(LPWSTR)&mem,0,0);
- if(result != 0){
+ DWORD 結果 = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,0,hr,0,(LPWSTR)&mem,0,0);
+ if(結果 != 0){
error_ = mem.get();
} else {
std::map<HRESULT,std::wstring>::iterator it = com_error_.find(hr);
} else {
error_ = (boost::wformat(L"0x%x 不明なCOMエラー") % hr).str();
}
-
+#ifdef _DEBUG
+ wdout << L"#### Exception Occured ####" << error_ << std::endl;
+#endif
}
+
};
win32_error_exception::win32_error_exception()
local_memory<wchar_t> mem;
DWORD rv = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,0,hresult_,0,(LPWSTR)&mem,0,0);
error_ = mem.get();
- //Logger::outputDebugPrintf(L"Win32 Error %x %s",hresult_,mem.Get() );
+#ifdef _DEBUG
+ wdout << L"#### Exception Occured ####" << error_ << std::endl;
+#endif
+
+ //Logger::outputDebugPrintf(L"Win32 Error %x %s",hresult_,mem.Get() );
};
+std::wstring win32_error_exception::get_last_error_str(uint32_t err)
+{
+// DWORD err = ::GetLastError();
+ std::wstring err_str;
+ local_memory<wchar_t> mem;
+ DWORD rv = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,0,err,0,(LPWSTR)&mem,0,0);
+ err_str = mem.get();
+#ifdef _DEBUG
+ wdout << L"#### Exception Occured ####" << err_str << std::endl;
+#endif
+ return err_str;
+}
+
}
\ No newline at end of file
class win32_error_exception : std::exception
{
public:
- win32_error_exception(boost::uint32_t hr);
+ win32_error_exception(uint32_t hr);
win32_error_exception();
virtual ~win32_error_exception() {};
- boost::uint32_t hresult() {return hresult_;}
+ uint32_t hresult() {return hresult_;}
std::wstring& error() {return error_;}
- private:
- boost::uint32_t hresult_;
+ static std::wstring get_last_error_str(uint32_t err = ::GetLastError());
+ private:
+ uint32_t hresult_;
std::wstring error_;
};
+ template <class Exc = win32_error_exception> struct throw_if_err
+ {
+ inline void operator()(HRESULT hr) {
+ if(hr != S_OK)
+ {throw Exc(hr);}
+ }
+ inline void operator()(bool v) {if(!v){throw Exc();}}
+ };
-}
\ No newline at end of file
+}
+
+#define THROW_IF_ERR(x) sf::throw_if_err<>()(x)
--- /dev/null
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-11 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+
+#include "StdAfx.h"
+
+#if _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
+#endif
+
+#include "sf_windows.h"
+#include "icon.h"
+#include "application.h"
+
+namespace sf {
+ bitmap_holder icon::default_mono_bitmap(CreateBitmap(32,32,1,1,NULL));
+
+ icon::icon(uint32_t id)
+ : icon_((HICON)::LoadImageW(application::instance()->instance_handle(),MAKEINTRESOURCE(id),IMAGE_ICON,0,0,LR_DEFAULTCOLOR))
+ {
+
+ };
+
+ icon::icon(icon_holder& ic)
+ {
+ icon_.reset(::CopyIcon(ic.get()));
+ analyze();
+ }
+
+ icon::icon(icon_holder&& ic)
+ {
+ std::swap(ic,icon_);
+ analyze();
+ }
+
+ icon::icon(bitmap_holder& bmp_color,int width,int height)
+ : width_(width),height_(height)
+ {
+ BITMAP bmp;
+ ICONINFO ii;
+ ::GetObjectW(bmp_color.get(),sizeof(BITMAP),&bmp);
+ bits_per_pixel_ = bmp.bmBitsPixel;
+
+ ii.fIcon = TRUE;
+ ii.xHotspot = 0;
+ ii.yHotspot = 0;
+ ii.hbmColor = bmp_color.get();
+
+ if(width == 32 && height == 32){
+ ii.hbmMask = default_mono_bitmap.get();
+ icon_.reset(::CreateIconIndirect(&ii));
+ } else {
+ bitmap_holder hmb(::CreateBitmap(width,height,1,1,NULL));
+ ii.hbmMask = hmb.get();
+ icon_.reset(::CreateIconIndirect(&ii));
+ }
+
+ }
+
+ icon::icon(ID2D1BitmapPtr& ptr)
+ {
+ ID2D1FactoryPtr factory;
+ ptr->GetFactory(&factory);
+
+ D2D1_SIZE_U size(ptr->GetPixelSize());
+ // ビットマップヘッダのセットアップ
+ BITMAPV5HEADER bi = {0};
+ bi.bV5Size = sizeof(BITMAPV5HEADER);
+ bi.bV5Width = size.width;
+ bi.bV5Height = size.height;
+ bi.bV5Planes = 1;
+ bi.bV5BitCount = 32;
+ bi.bV5Compression = BI_BITFIELDS;
+ bi.bV5RedMask = 0x00FF0000;
+ bi.bV5GreenMask = 0x0000FF00;
+ bi.bV5BlueMask = 0x000000FF;
+ bi.bV5AlphaMask = 0xFF000000;
+
+ // デスクトップHDCの取得
+ get_dc dc(NULL);
+
+ // DIBセクションの作成
+ void *bits;// 得られるビットマップ
+ bitmap_holder bmp(
+ ::CreateDIBSection(
+ dc.get(),reinterpret_cast<BITMAPINFO *>(&bi),DIB_RGB_COLORS,&bits,NULL,0));
+ {
+ // 互換DCの作成
+ compatible_dc cdc(dc.get());
+ {
+ // 描画先への切り替え
+ select_object s(cdc.get(),bmp.get());
+
+ // DC互換レンダーターゲットのセットアップ
+ D2D1_RENDER_TARGET_PROPERTIES
+ props = D2D1::RenderTargetProperties(
+ D2D1_RENDER_TARGET_TYPE_DEFAULT,
+ D2D1::PixelFormat(
+ DXGI_FORMAT_B8G8R8A8_UNORM,
+ D2D1_ALPHA_MODE_PREMULTIPLIED),
+ 0,
+ 0,
+ D2D1_RENDER_TARGET_USAGE_NONE,
+ D2D1_FEATURE_LEVEL_DEFAULT
+ );
+
+ ID2D1DCRenderTargetPtr dcr;
+ throw_if_err<>()(factory->CreateDCRenderTarget(&props,dcr.GetAddressOf()));
+ RECT rect = {0,0,size.width,size.height};
+ // 互換DCへのバインド
+ throw_if_err<>()(dcr->BindDC(cdc.get(),&rect));
+ dcr->DrawBitmap(ptr.Get());
+ }
+ }
+ icon(bmp,size.width,size.height);
+ };
+
+
+ icon::icon(boost::filesystem::wpath& path)
+ {
+ icon_.reset(
+ reinterpret_cast<HICON>(
+ LoadImageW(NULL,path.native().c_str(),IMAGE_ICON,0,0,LR_DEFAULTSIZE | LR_LOADFROMFILE)));
+ }
+
+ icon::~icon()
+ {
+
+ }
+
+ void icon::analyze()
+ {
+ ::ICONINFOEXW info;
+ ::GetIconInfoExW(icon_.get(),&info);
+ BITMAP bmp;
+ ::GetObjectW(info.hbmColor,sizeof(BITMAP),&bmp);
+ width_ = bmp.bmWidth;
+ height_ = bmp.bmHeight;
+ bits_per_pixel_ = bmp.bmBitsPixel;
+ }
+
+ icon& icon::operator= (icon& i)
+ {
+ BOOST_ASSERT(icon_ != i.icon_);
+ if(icon_ == i.icon_) return *this;
+ icon_.reset(::CopyIcon(i.icon_.get()));
+ width_ = i.width_;
+ height_ = i.height_;
+ bits_per_pixel_ = i.bits_per_pixel_;
+ return *this;
+ }
+
+ //icon_ptr icon::create_icon()
+ //{
+
+ // // ビットマップヘッダのセットアップ
+ // BITMAPV5HEADER bi = {0};
+ // bi.bV5Size = sizeof(BITMAPV5HEADER);
+ // bi.bV5Width = width_;
+ // bi.bV5Height = height_;
+ // bi.bV5Planes = 1;
+ // bi.bV5BitCount = 32;
+ // bi.bV5Compression = BI_BITFIELDS;
+ // bi.bV5RedMask = 0x00FF0000;
+ // bi.bV5GreenMask = 0x0000FF00;
+ // bi.bV5BlueMask = 0x000000FF;
+ // bi.bV5AlphaMask = 0xFF000000;
+
+ // // デスクトップHDCの取得
+ // get_dc dc(NULL);
+
+ // // DIBセクションの作成
+ // void *bits;// 得られるビットマップ
+ // gdi_object<HBITMAP> bmp(
+ // ::CreateDIBSection(
+ // dc.get(),reinterpret_cast<BITMAPINFO *>(&bi),DIB_RGB_COLORS,&bits,NULL,0));
+ // {
+ // // 互換DCの作成
+ // compatible_dc cdc(dc.get());
+ // {
+ // // 描画先への切り替え
+ // select_object s(cdc.get(),bmp);
+
+ // // DC互換レンダーターゲットのセットアップ
+ // D2D1_RENDER_TARGET_PROPERTIES
+ // props = D2D1::RenderTargetProperties(
+ // D2D1_RENDER_TARGET_TYPE_DEFAULT,
+ // D2D1::PixelFormat(
+ // DXGI_FORMAT_B8G8R8A8_UNORM,
+ // D2D1_ALPHA_MODE_PREMULTIPLIED),
+ // 0,
+ // 0,
+ // D2D1_RENDER_TARGET_USAGE_NONE,
+ // D2D1_FEATURE_LEVEL_DEFAULT
+ // );
+
+ // ID2D1DCRenderTargetPtr dcr;
+ // throw_if_err<>()(factory_->CreateDCRenderTarget(&props,&dcr));
+ // RECT rect = {0,0,w,h};
+ // // 互換DCへのバインド
+ // throw_if_err<>()(dcr->BindDC(cdc.get(),&rect));
+
+ // // ブラシのセットアップ(背景の赤丸）
+ // ID2D1SolidColorBrushPtr brush_e;
+ // throw_if_err<>()(
+ // dcr->CreateSolidColorBrush(
+ // D2D1::ColorF(D2D1::ColorF::Red,0.8f), &brush_e));
+
+ // // アイコンに描画する文字の生成
+ // std::wstring t(L"S.F.\nTimer");
+ // D2D1_RECT_F l = D2D1::RectF(0.0f,0.0f,width_,height_);
+ // // Text Formatの作成
+ // IDWriteTextFormatPtr f;
+ // write_factory_->CreateTextFormat(
+ // L"メイリオ", // Font family name.
+ // NULL, // Font collection (NULL sets it to use the system font collection).
+ // DWRITE_FONT_WEIGHT_REGULAR,
+ // DWRITE_FONT_STYLE_NORMAL,
+ // DWRITE_FONT_STRETCH_NORMAL,
+ // 10.0f,
+ // L"ja-jp",
+ // &f
+ // );
+ // f->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
+ // f->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);
+
+ // // 文字描画用ブラシのセットアップ
+ // ID2D1SolidColorBrushPtr brush;
+ // dcr->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black), &brush);
+ // // 描画開始
+ // dcr->BeginDraw();
+ // // ビットマップクリア
+ // dcr->Clear(D2D1::ColorF(D2D1::ColorF::Black,0.0f));
+ // // 赤丸を描く
+ // dcr->FillEllipse(D2D1::Ellipse(D2D1::Point2F(16.0f,16.0f),14,14),brush_e);
+ // // テキストを表示する
+ // dcr->DrawTextW(t.c_str(),t.size(),f,&l,brush);
+ // // 描画終了
+ // dcr->EndDraw();
+ // }
+ // }
+ //}
+}
--- /dev/null
+#pragma once
+/*
+==============================================================================
+
+This file is part of the async
+Copyright 2005-11 by Satoshi Fujiwara.
+
+async can be redistributed and/or modified under the terms of the
+GNU General Public License, as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+async is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with async; if not, visit www.gnu.org/licenses or write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+Boston, MA 02111-1307 USA
+
+==============================================================================
+*/
+
+namespace sf {
+
+ struct icon_deleter {
+ typedef HICON pointer;
+ void operator ()(HICON handle) {
+ if (handle) {
+ ::DestroyIcon(handle);
+ }
+ }
+ };
+
+ /** icon\83n\83\93\83h\83\8b\82Ì\89ð\95ú\82µ\96Y\82ê\82ð\97\\96h\82·\82é */
+ typedef std::unique_ptr<HICON,icon_deleter> icon_holder;
+
+ /**
+ \81@icon\8aÇ\97\9d\83N\83\89\83X
+ */
+ struct icon
+ {
+ public:
+ icon(){};
+ explicit icon(uint32_t id);/// \83\8a\83\\81[\83XID\82©\82ç\83A\83C\83R\83\93\82ð\8dì\90¬\82·\82é
+ explicit icon(icon_holder& ic);/// \83A\83C\83R\83\93\83t\83H\83\8b\83_\82©\82ç\83A\83C\83R\83\93\82ð\8dì\90¬\82·\82é
+ explicit icon(icon_holder&& ic);/// \89E\95Ó\92l\8eQ\8fÆ\82©\82ç\83A\83C\83R\83\93\82ð\8dì\90¬\82·\82é
+ icon(bitmap_holder& bmp_color,int width = ::GetSystemMetrics(SM_CXICON),int height = ::GetSystemMetrics(SM_CYICON));
+ icon(ID2D1BitmapPtr& ptr);
+ icon(boost::filesystem::wpath& path);
+
+ virtual ~icon();
+
+ HICON get() const {return icon_.get();};
+
+ icon(icon& i) : width_(i.width_),height_(i.height_),bits_per_pixel_(i.bits_per_pixel_)
+ {
+ icon_.reset(::CopyIcon(i.icon_.get()));
+ }
+
+ icon(icon&& i) : width_(i.width_),height_(i.height_),bits_per_pixel_(i.bits_per_pixel_)
+ {
+ std::swap(icon_,i.icon_);
+ }
+
+ icon& operator= (icon&& i)
+ {
+ BOOST_ASSERT(icon_ != i.icon_);
+ if(icon_ == i.icon_) return *this;
+ std::swap(icon_,i.icon_);
+ width_ = i.width_;
+ height_ = i.height_;
+ bits_per_pixel_ = i.bits_per_pixel_;
+ return *this;
+ }
+
+ icon& operator= (icon& i);
+
+ void swap(icon& i)
+ {
+ std::swap(icon_,i.icon_);
+ std::swap(width_,i.width_);
+ std::swap(height_,i.height_);
+ std::swap(bits_per_pixel_,i.bits_per_pixel_);
+ }
+
+ private:
+
+ void analyze();
+ //ID2D1DCRenderTargetPtr dcr_;
+ //ID2D1BitmapPtr bitmap_;
+ int width_;
+ int height_;
+ int bits_per_pixel_;
+ icon_holder icon_;
+ static bitmap_holder default_mono_bitmap;
+ };
+}
+
--- /dev/null
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-10 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+#include "StdAfx.h"
+#include "jumplist.h"
+
+
--- /dev/null
+#pragma once
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-10 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+namespace sf{
+struct jumplist
+{
+public:
+ jumplist(){};
+ virtual ~jumplist(){};
+};
+}
+
--- /dev/null
+/*
+==============================================================================
+
+This file is part of the S.F.Tracker
+Copyright 2005-7 by Satoshi Fujiwara.
+
+S.F.Tracker can be redistributed and/or modified under the terms of the
+GNU General Public License, as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+S.F.Tracker is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with S.F.Tracker; if not, visit www.gnu.org/licenses or write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+Boston, MA 02111-1307 USA
+
+==============================================================================
+*/
+/** @file
+* @author S.F. (Satoshi Fujiwara)
+*/
+
+#include "stdafx.h"
+#if _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
+#endif
+namespace sf {
+
+ struct logger::impl
+ {
+ impl() : m_log_file("sftracker.log",std::ios_base::out | std::ios_base::trunc ){};
+ ~impl() {m_log_file.close();}
+
+ void write(const boost::wformat & fmt)
+ {
+ write(fmt.str());
+ };
+
+ void write(const std::wistream & st)
+ {
+ {
+ //mutex_type::scoped_lock lock_(m_mutex);
+ m_log_file << st << std::endl;
+ }
+ boost::gregorian::date dt = boost::gregorian::day_clock::local_day();
+
+ };
+
+ void write(const std::wstring & mes)
+ {
+ write(mes.c_str());
+ }
+
+ void write(const TCHAR * mes)
+ {
+ //mutex_type::scoped_lock lock_(m_mutex);
+ m_log_file << mes << std::endl;
+ m_log_file.flush();
+ }
+ private:
+ std::wofstream m_log_file;
+ //mutex_type m_mutex;
+ };
+
+ logger::logger() : m_impl(new logger::impl())
+ {
+ }
+ void logger::write(const boost::wformat & fmt)
+ {
+ m_impl->write(fmt);
+ };
+
+ void logger::write(const std::wstring & mes)
+ {
+ m_impl->write(mes);
+ }
+
+ void logger::write(const TCHAR * mes)
+ {
+ m_impl->write(mes);
+ }
+
+ void logger::write(const std::wistream & st)
+ {
+ m_impl->write(st);
+ }
+
+ logger::~logger()
+ {
+
+ }
+
+ void debug_out(const char * file_name,const int line,boost::wformat& fmt)
+ {
+ OutputDebugString((boost::wformat(_T("%s(%d) %s \n")) % std::wstring(sf::code_converter<char,wchar_t>(file_name)) % line % fmt).str().c_str());
+ };
+
+ void debug_out(const char * file_name,const int line,const std::wstring& str)
+ {
+ OutputDebugString((boost::wformat(_T("%s(%d) %s \n")) % std::wstring(sf::code_converter<char,wchar_t>(file_name)) % line % str).str().c_str());
+ };
+
+ void debug_out(const char * file_name,const int line,const char* str)
+ {
+ OutputDebugString((boost::wformat(_T("%s(%d) %s \n")) % std::wstring(sf::code_converter<char,wchar_t>(file_name)) % line % sf::code_converter<char,wchar_t>(str)).str().c_str());
+ }
+
+ void debug_outW(const char * file_name,const int line,const wchar_t* str)
+ {
+ OutputDebugString((boost::wformat(_T("%s(%d) %s \n")) % std::wstring(sf::code_converter<char,wchar_t>(file_name)) % line % str).str().c_str());
+ };
+
+}
--- /dev/null
+#pragma once
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "singleton.h"
+
+namespace sf {
+
+ struct logger : public singleton<logger>
+ {
+ public:
+ logger();
+ ~logger();
+ void write(const boost::wformat & fmt);
+ void write(const std::wstring & mes);
+ void write(const TCHAR * mes);
+ void write(const std::wistream & st);
+ private:
+ struct impl;
+ std::shared_ptr<impl> m_impl;
+ };
+
+ void debug_out(const char * file_name,const int line,boost::wformat& fmt);
+ void debug_out(const char * file_name,const int line,const std::wstring& str);
+ void debug_out(const char * file_name,const int line,const char* str);
+ void debug_out(const char * file_name,const int line,const wchar_t* str);
+}
+
+#define WRITE_LOG(s) \
+ sf::logger::instance()->write(boost::wformat(_T("%s %s %6d %s")) % boost::posix_time::second_clock::local_time() % (TCHAR*)sf::ca2t(__FILE__) % __LINE__ % (s))
+
+#ifdef _DEBUG
+#define SFTRACE(x) sf::debug_out(__FILE__,__LINE__,(x))
+#else
+#define SFTRACE(x)
+#endif
+
--- /dev/null
+#pragma once
+/*
+ ==============================================================================
+
+ This file is part of the S.F.Tracker
+ Copyright 2005-7 by Satoshi Fujiwara.
+
+ S.F.Tracker can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ S.F.Tracker is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with S.F.Tracker; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+/** @file
+ * @brief
+ * @author S.F. (Satoshi Fujiwara)
+ */
+namespace sf {
+ struct run_message_loop
+ {
+ run_message_loop(){};
+ inline WPARAM operator()()
+ {
+ MSG msg;
+ while (GetMessage(&msg, NULL, 0, 0))
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ return msg.wParam;
+ }
+
+ ~run_message_loop(void){};
+ };
+
+ struct peek_message_loop
+ {
+ typedef boost::function<void ()> func_type;
+ explicit peek_message_loop(func_type func) {func_ = func;};
+ inline WPARAM operator()()
+ {
+ MSG msg = {0};
+ while( WM_QUIT != msg.message )
+ {
+ if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
+ {
+ TranslateMessage( &msg );
+ DispatchMessage( &msg );
+ }
+ else
+ {
+ func_(); // Do some rendering
+ }
+ }
+ return msg.wParam;
+ };
+ private:
+ func_type func_;
+ };
+
+ struct dialog_message_loop
+ {
+ dialog_message_loop(HWND dialog) : dialog_(dialog) {};
+ inline WPARAM operator()()
+ {
+ MSG msg;
+ while (GetMessage(&msg, NULL, 0, 0))
+ {
+ if(IsDialogMessage(dialog_,&msg) == FALSE)
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ }
+ return msg.wParam;
+ }
+ ~dialog_message_loop(){};
+ private:
+ HWND dialog_;
+
+ };
+}
/*
==============================================================================
- This file is part of the Shooting3
- Copyright 2005-7 by Satoshi Fujiwara.
+ This file is part of the mfsample
+ Copyright 2005-11 by Satoshi Fujiwara.
- S.F.Tracker can be redistributed and/or modified under the terms of the
+ mfsample can be redistributed and/or modified under the terms of the
GNU General Public License, as published by the Free Software Foundation;
either version 2 of the License, or (at your option) any later version.
- S.F.Tracker is distributed in the hope that it will be useful,
+ async is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with S.F.Tracker; if not, visit www.gnu.org/licenses or write to the
+ along with async; if not, visit www.gnu.org/licenses or write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307 USA
* @author S.F. (Satoshi Fujiwara)
*/
#include "objbase.h"
+
+
+
namespace sf
{
+ template <class COM_SMART_PTR > inline void safe_release(COM_SMART_PTR& ptr)
+ {
+ if(ptr)
+ {
+ ptr.Reset();
+ }
+ };
enum com_init
{
multi_threaded = 0x0,
struct com_initialize
{
struct impl;
- com_initialize(void * reserved = NULL,unsigned int init = multi_threaded);
+ com_initialize(void * reserved ,unsigned int init);
+ com_initialize(){com_initialize(0,multi_threaded);};
~com_initialize() {};
private:
- boost::shared_ptr<impl> m_impl;
+ std::shared_ptr<impl> m_impl;
};
template <typename ComClass,typename ComInterface>
T* get( void )
{ return FMemory; }
+T* operator ->(void)
+{
+ return FMemory;
+}
+
T** operator&( void )
{ return &FMemory; }
{ }
};
template< typename T >
-class co_task_memory : public base_memory< T,
-co_task_memory_free_policy >
+class co_task_memory : public base_memory< T, co_task_memory_free_policy >
{
public:
co_task_memory( T* AMemory = NULL )
{ }
};
+struct handle_deleter {
+ typedef HANDLE pointer;
+ void operator ()(HANDLE handle) {
+ if (handle != INVALID_HANDLE_VALUE) {
+ CloseHandle(handle);
+ }
+ }
+};
+
+typedef std::unique_ptr<HANDLE,handle_deleter> handle_holder;
+
};
-// Direct2DBurn.cpp : アプリケーションのエントリ ポイントを定義します。\r
-\r
-#include "stdafx.h"\r
+#include "stdafx.h"\r
#define BOOST_ASSIGN_MAX_PARAMS 7\r
#include <boost/assign.hpp>\r
#include <boost/assign/ptr_list_of.hpp>\r
#include <boost/assign/ptr_list_inserter.hpp>\r
#include <boost/foreach.hpp>\r
+\r
+#if _DEBUG\r
+#define _CRTDBG_MAP_ALLOC\r
+#include <crtdbg.h>\r
+#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)\r
+#endif\r
+\r
#include "sf_windows.h"\r
#include "exception.h"\r
\r
-#define EXCEPTION_ON_ERROR(hres) \\r
- if (FAILED(hres)) { throw sf::win32_error_exception(hres); }\r
+//#pragma comment(lib,"dxerr.lib")\r
+#pragma comment( lib, "dxguid.lib" )\r
+#pragma comment( lib, "d3d11.lib" )\r
+#pragma comment( lib, "D3DCompiler.lib" )\r
+#pragma comment( lib, "DirectXTK.lib" )\r
+#pragma comment( lib, "dxgi.lib" )\r
+//#pragma comment( lib, "d3dx9.lib" ) \r
+#pragma comment( lib, "Shlwapi.lib" ) \r
+#pragma comment( lib, "DWMApi.lib" )\r
+#pragma comment( lib,"msimg32.lib")\r
+\r
+#define THROW_IFERR(hres) \\r
+ if (FAILED(hres)) { throw sf::win32_error_exception(hres); }\r
\r
#ifndef HINST_THISCOMPONENT\r
EXTERN_C IMAGE_DOS_HEADER __ImageBase;\r
#define HINST_THISCOMPONENT ((HINSTANCE)&__ImageBase)\r
#endif\r
-\r
-#define SAFE_RELEASE(x) if(x) x.Release(); \r
+using namespace std;\r
+using namespace DirectX;\r
\r
namespace sf \r
{\r
- LRESULT base_window::window_proc(HWND hwnd,boost::uint32_t message, WPARAM wParam, LPARAM lParam)\r
- {\r
- \r
- LRESULT result = 0;\r
- switch (message)\r
- {\r
- case WM_CREATE:\r
- {\r
- // TODO:\r
- create_device();\r
- break;\r
- }\r
- case WM_SIZE:\r
- {\r
- //if (render_target_)\r
- //{\r
- // D2D1_SIZE_U size;\r
- // size.width = lParam & 0xFFFF;\r
- // size.height = (lParam >> 16) & 0xFFFF; ;\r
-\r
- // // Note: This method can fail, but it's okay to ignore the\r
- // // error here -- it will be repeated on the next call to\r
- // // EndDraw.\r
- // //render_target_->Resize(size);\r
- //}\r
- }\r
- case WM_PAINT:\r
- {\r
- //create_device();\r
- \r
- paint_struct begin_paint(hwnd);\r
-\r
- //if (!(render_target_->CheckWindowState() & D2D1_WINDOW_STATE_OCCLUDED))\r
- //{\r
- // // Retrieve the size of the render target.\r
- // D2D1_SIZE_F renderTargetSize = render_target_->GetSize();\r
- // try {\r
- // //render_target_->BeginDraw();\r
- // base_->on_render();\r
- // //EXCEPTION_ON_ERROR(render_target_->EndDraw());\r
- // } catch (sf::win32_error_exception& e )\r
- // {\r
- // if(e.hresult() == D2DERR_RECREATE_TARGET)\r
- // {\r
- // discard_device();\r
- // } else {\r
- // throw;\r
- // }\r
- // }\r
- //}\r
- return FALSE;\r
- }\r
- case WM_DISPLAYCHANGE:\r
- {\r
- ::InvalidateRect(hwnd, NULL, FALSE);\r
- }\r
- case WM_ERASEBKGND:\r
- {\r
- return FALSE;\r
- }\r
- case WM_MOUSEMOVE:\r
- {\r
-// on_mouse_move(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam),wParam); \r
- }\r
- case WM_LBUTTONDOWN:\r
- {\r
- }\r
- }\r
- return ::DefWindowProcW(hwnd,message,wParam,lParam);\r
- };\r
+ HRESULT EnableBlurBehind(HWND hwnd)\r
+ {\r
+ HRESULT hr = S_OK;\r
+\r
+ //Create and populate the BlurBehind structre\r
+ DWM_BLURBEHIND bb = {0};\r
+ //Enable Blur Behind and Blur Region;\r
+ bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;\r
+ bb.fEnable = true;\r
+ bb.hRgnBlur = ::CreateRectRgn(-1,-1,0,0);\r
+\r
+ //Enable Blur Behind\r
+ hr = DwmEnableBlurBehindWindow(hwnd, &bb);\r
+ //BOOL allow_ncpaint = TRUE;\r
+ //DwmSetWindowAttribute(hwnd,DWMWA_ALLOW_NCPAINT,&allow_ncpaint,sizeof(BOOL));\r
+ //DWMNCRENDERINGPOLICY policy = DWMNCRP_ENABLED;\r
+ //DwmSetWindowAttribute(hwnd,DWMWA_NCRENDERING_POLICY,&policy,sizeof(policy));\r
+\r
+ \r
+ //if (SUCCEEDED(hr))\r
+ //{\r
+ // //do more things\r
+ //MARGINS mgn = {-1};\r
+ //hr = DwmExtendFrameIntoClientArea( hwnd, &mgn );\r
+ /* }*/\r
+ return hr;\r
+ }\r
+\r
+ // 汎用情報格納用\r
+ struct mode_info \r
+ {\r
+ mode_info(const std::wstring& n,const std::wstring& d) : name(n),description(d) {}\r
+ std::wstring name;\r
+ std::wstring description;\r
+ };\r
\r
+ // ディスプレイモード\r
+ struct display_mode \r
+ {\r
+ display_mode(const std::wstring& n,const std::wstring& d) : name(n),description(d) {}\r
+ std::wstring name;\r
+ std::wstring description;\r
+ };\r
+\r
+ std::vector<mode_info> display_modes = \r
+ boost::assign::list_of<mode_info>\r
+ (L"DXGI_FORMAT_UNKNOWN",L"フォーマットが不明")\r
+ (L"DXGI_FORMAT_R32G32B32A32_TYPELESS",L"4 成分、128 ビット型なしフォーマット 1")\r
+ (L"DXGI_FORMAT_R32G32B32A32_FLOAT",L"4 成分、128 ビット浮動小数点フォーマット 1")\r
+ (L"DXGI_FORMAT_R32G32B32A32_UINT",L"4 成分、128 ビット符号なし整数フォーマット 1")\r
+ (L"DXGI_FORMAT_R32G32B32A32_SINT",L"4 成分、128 ビット符号付き整数フォーマット 1")\r
+ (L"DXGI_FORMAT_R32G32B32_TYPELESS",L"3 成分、96 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R32G32B32_FLOAT",L"3 成分、96 ビット浮動小数点フォーマット")\r
+ (L"DXGI_FORMAT_R32G32B32_UINT",L"3 成分、96 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R32G32B32_SINT",L"3 成分、96 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R16G16B16A16_TYPELESS",L"4 成分、64 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R16G16B16A16_FLOAT",L"4 成分、64 ビット浮動小数点フォーマット")\r
+ (L"DXGI_FORMAT_R16G16B16A16_UNORM",L"4 成分、64 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R16G16B16A16_UINT",L"4 成分、64 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R16G16B16A16_SNORM",L"4 成分、64 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R16G16B16A16_SINT",L"4 成分、64 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R32G32_TYPELESS",L"2 成分、64 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R32G32_FLOAT",L"2 成分、64 ビット浮動小数点フォーマット")\r
+ (L"DXGI_FORMAT_R32G32_UINT",L"2 成分、64 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R32G32_SINT",L"2 成分、64 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R32G8X24_TYPELESS",L"2 成分、64 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_D32_FLOAT_S8X24_UINT",L"32 ビット浮動小数点成分、および 2 つの符号なし整数成分です (追加の 32 ビットを含む)。")\r
+ (L"DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS",L"32 ビット浮動小数点成分、および 2 つの型なし成分です (追加の 32 ビットを含む)。")\r
+ (L"DXGI_FORMAT_X32_TYPELESS_G8X24_UINT",L"32 ビット型なし成分、および 2 つの符号なし整数成分です (追加の 32 ビットを含む)。")\r
+ (L"DXGI_FORMAT_R10G10B10A2_TYPELESS",L"4 成分、32 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R10G10B10A2_UNORM",L"4 成分、32 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R10G10B10A2_UINT",L"4 成分、32 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R11G11B10_FLOAT",L"3 成分、32 ビット浮動小数点フォーマット")\r
+ (L"DXGI_FORMAT_R8G8B8A8_TYPELESS",L"3 成分、32 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R8G8B8A8_UNORM",L"4 成分、32 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",L"4 成分、32 ビット符号なし正規化整数 sRGB フォーマット")\r
+ (L"DXGI_FORMAT_R8G8B8A8_UINT",L"4 成分、32 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R8G8B8A8_SNORM",L"3 成分、32 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R8G8B8A8_SINT",L"3 成分、32 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R16G16_TYPELESS",L"2 成分、32 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R16G16_FLOAT",L"2 成分、32 ビット浮動小数点フォーマット")\r
+ (L"DXGI_FORMAT_R16G16_UNORM",L"2 成分、32 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R16G16_UINT",L"2 成分、32 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R16G16_SNORM",L"2 成分、32 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R16G16_SINT",L"2 成分、32 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R32_TYPELESS",L"1 成分、32 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_D32_FLOAT",L"1 成分、32 ビット浮動小数点フォーマット")\r
+ (L"DXGI_FORMAT_R32_FLOAT",L"1 成分、32 ビット浮動小数点フォーマット")\r
+ (L"DXGI_FORMAT_R32_UINT",L"1 成分、32 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R32_SINT",L"1 成分、32 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R24G8_TYPELESS",L"2 成分、32 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_D24_UNORM_S8_UINT",L"深度チャンネルに 24 ビット、ステンシル チャンネルに 8 ビットを使用する 32 ビット Z バッファー フォーマット")\r
+ (L"DXGI_FORMAT_R24_UNORM_X8_TYPELESS",L"1 成分、24 ビット符号なし正規化整数と追加の型なし 8 ビットを含む、32 ビット フォーマット")\r
+ (L"DXGI_FORMAT_X24_TYPELESS_G8_UINT",L"1 成分、24 ビット型なしフォーマットと追加の 8 ビット符号なし整数成分を含む、32 ビット フォーマット")\r
+ (L"DXGI_FORMAT_R8G8_TYPELESS",L"2 成分、16 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R8G8_UNORM",L"2 成分、16 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R8G8_UINT",L"2 成分、16 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R8G8_SNORM",L"2 成分、16 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R8G8_SINT",L"2 成分、16 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R16_TYPELESS",L"1 成分、16 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R16_FLOAT",L"1 成分、16 ビット浮動小数点フォーマット")\r
+ (L"DXGI_FORMAT_D16_UNORM",L"1 成分、16 ビット符号なし正規化整数フォーマット")\r
+ (L"DXGI_FORMAT_R16_UNORM",L"1 成分、16 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R16_UINT",L"1 成分、16 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R16_SNORM",L"1 成分、16 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R16_SINT",L"1 成分、16 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R8_TYPELESS",L"1 成分、8 ビット型なしフォーマット")\r
+ (L"DXGI_FORMAT_R8_UNORM",L"1 成分、8 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R8_UINT",L"1 成分、8 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R8_SNORM",L"1 成分、8 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_R8_SINT",L"1 成分、8 ビット符号付き整数フォーマット")\r
+ (L"DXGI_FORMAT_A8_UNORM",L"1 成分、8 ビット符号なし整数フォーマット")\r
+ (L"DXGI_FORMAT_R1_UNORM",L"1 成分、1 ビット符号なし正規化整数フォーマット 2.")\r
+ (L"DXGI_FORMAT_R9G9B9E5_SHAREDEXP",L"4 成分、32 ビット浮動小数点フォーマット 2.")\r
+ (L"DXGI_FORMAT_R8G8_B8G8_UNORM",L"4 成分、32 ビット符号なし正規化整数フォーマット 3")\r
+ (L"DXGI_FORMAT_G8R8_G8B8_UNORM",L"4 成分、32 ビット符号なし正規化整数フォーマット 3")\r
+ (L"DXGI_FORMAT_BC1_TYPELESS",L"4 成分、型なしブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC1_UNORM",L"4 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC1_UNORM_SRGB",L"sRGB データ用の 4 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC2_TYPELESS",L"4 成分、型なしブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC2_UNORM",L"4 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC2_UNORM_SRGB",L"sRGB データ用の 4 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC3_TYPELESS",L"4 成分、型なしブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC3_UNORM",L"4 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC3_UNORM_SRGB",L"sRGB データ用の 4 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC4_TYPELESS",L"1 成分、型なしブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC4_UNORM",L"1 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC4_SNORM",L"1 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC5_TYPELESS",L"2 成分、型なしブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC5_UNORM",L"2 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_BC5_SNORM",L"2 成分、ブロック圧縮フォーマット")\r
+ (L"DXGI_FORMAT_B5G6R5_UNORM",L"3 成分、16 ビット符号なし正規化整数フォーマット")\r
+ (L"DXGI_FORMAT_B5G5R5A1_UNORM",L"1 ビット アルファをサポートする 4 成分、16 ビット符号なし正規化整数フォーマット")\r
+ (L"DXGI_FORMAT_B8G8R8A8_UNORM",L"8 ビット アルファをサポートする 4 成分、16 ビット符号なし正規化整数フォーマット")\r
+ (L"DXGI_FORMAT_B8G8R8X8_UNORM",L"4 成分、16 ビット符号なし正規化整数フォーマット")\r
+ (L"DXGI_FORMAT_FORCE_UINT",L"コンパイル時に、この列挙型のサイズを 32 ビットにするために定義されています。この値を指定しない場合、一部のコンパイラでは列挙型を 32 ビット以外のサイズでコンパイル可能この定数が使用されることはありません。");\r
+\r
+ // スキャンライン情報\r
+\r
+ std::vector<mode_info> scanline_orders = \r
+ boost::assign::list_of<mode_info>\r
+ (L"DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED",L"走査線の順序が指定されていません。")\r
+ (L"DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE",L"イメージは先頭の走査線～最後の走査線から作成され、スキップされる走査線はありません。")\r
+ (L"DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST",L"イメージが上部のフィールドから作成されます。")\r
+ (L"DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST",L"イメージが下部のフィールドから作成されます。");\r
+\r
+ // スケーリングパラメータ\r
+ std::vector<mode_info> scalings = boost::assign::list_of<mode_info>\r
+ (L"DXGI_MODE_SCALING_UNSPECIFIED",L"スケーリングが指定されていません。")\r
+ (L"DXGI_MODE_SCALING_CENTERED",L"スケーリングなしを指定します。イメージはディスプレイの中央に配置されます。通常、このフラグは固定ドットピッチ ディスプレイ (LED ディスプレイなど) に使用します。")\r
+ (L"DXGI_MODE_SCALING_STRETCHED",L"拡大スケーリングを指定します。");\r
+\r
+ struct simple_vertex\r
+ {\r
+ XMFLOAT3 pos;\r
+ XMFLOAT3 norm;\r
+ XMFLOAT2 tex;\r
+ };\r
+\r
+ struct cb_never_changes\r
+ {\r
+ XMMATRIX mView;\r
+ XMFLOAT4 vLightDir;\r
+ };\r
+\r
+ struct cb_change_on_resize\r
+ {\r
+ XMMATRIX mProjection;\r
+ };\r
+\r
+ struct cb_changes_every_frame\r
+ {\r
+ XMMATRIX mWorld;\r
+ XMFLOAT4 vLightColor;\r
+\r
+ // XMFLOAT4 vMeshColor;\r
+ };\r
+ template <typename ProcType> \r
+ typename base_win32_window<ProcType>::result_t base_win32_window<ProcType>::window_proc(HWND hwnd,uint32_t message, WPARAM wParam, LPARAM lParam)\r
+ {\r
+\r
+ switch (message)\r
+ {\r
+ case WM_NCCREATE:\r
+ return on_nccreate(reinterpret_cast<CREATESTRUCT*>(lParam));\r
+ case WM_CREATE:\r
+ return on_create(reinterpret_cast<CREATESTRUCT*>(lParam));\r
+ case WM_INITDIALOG:\r
+ return on_init_dialog(reinterpret_cast<HWND>(wParam),lParam);\r
+ case WM_SIZE:\r
+ return on_size(wParam,LOWORD(lParam),HIWORD(lParam)) ;\r
+ case WM_PAINT:\r
+ return on_paint();\r
+ case WM_DISPLAYCHANGE:\r
+ return on_display_change(wParam,LOWORD(lParam),HIWORD(lParam));\r
+ case WM_ERASEBKGND:\r
+ return on_erase_backgroud(reinterpret_cast<HDC>(wParam));\r
+ case WM_HSCROLL:\r
+ return on_hscroll(LOWORD(wParam),HIWORD(wParam),reinterpret_cast<HWND>(lParam));\r
+ case WM_VSCROLL:\r
+ return on_vscroll(LOWORD(wParam),HIWORD(wParam),reinterpret_cast<HWND>(lParam));\r
+ case WM_LBUTTONDOWN:\r
+ return on_left_mouse_button_down(\r
+ wParam,dpi_.scale_x(\r
+ GET_X_LPARAM(lParam)),dpi_.scale_y(GET_Y_LPARAM(lParam)))\r
+ ;\r
+ ;\r
+ case WM_LBUTTONUP:\r
+ return on_left_mouse_button_up(\r
+ wParam,dpi_.scale_x(\r
+ GET_X_LPARAM(lParam)),dpi_.scale_y(GET_Y_LPARAM(lParam)))\r
+ ;\r
+ case WM_LBUTTONDBLCLK:\r
+ return on_left_mouse_button_double_click(wParam,\r
+ dpi_.scale_x(\r
+ GET_X_LPARAM(lParam)),dpi_.scale_y(GET_Y_LPARAM(lParam)))\r
+ ;\r
+ case WM_MOUSEMOVE:\r
+ {\r
+ return on_mouse_move(wParam,\r
+ dpi_.scale_x(\r
+ GET_X_LPARAM(lParam)),dpi_.scale_y(GET_Y_LPARAM(lParam)))\r
+ ;\r
+ // on_mouse_move(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam),wParam); \r
+ }\r
+ case WM_MOUSEWHEEL:\r
+ return on_mouse_wheel(GET_KEYSTATE_WPARAM(wParam),GET_WHEEL_DELTA_WPARAM(wParam),\r
+ dpi_.scale_x(\r
+ GET_X_LPARAM(lParam)),dpi_.scale_y(GET_Y_LPARAM(lParam)))\r
+ ;\r
+ case WM_MOUSELEAVE:\r
+ return on_mouse_leave() ;\r
+ case WM_KEYDOWN:\r
+ return on_key_down(wParam,lParam & 0xffff0000,LOWORD(lParam)) ;\r
+ case WM_KEYUP:\r
+ return on_key_up(wParam,lParam & 0xffff0000,LOWORD(lParam)) ;\r
+ case WM_APPCOMMAND:\r
+ return on_app_command(GET_APPCOMMAND_LPARAM(lParam),GET_DEVICE_LPARAM(lParam),GET_KEYSTATE_LPARAM(lParam));\r
+ case WM_COMMAND:\r
+ return on_command(wParam,lParam);\r
+ case WM_DESTROY:\r
+ return on_destroy();\r
+ case WM_CLOSE:\r
+ return on_close();\r
+ case WM_TIMER:\r
+ return on_timer(wParam);\r
+ case WM_NOTIFY:\r
+ return on_notify(reinterpret_cast<NMHDR*>(lParam));\r
+ case WM_DWMCOMPOSITIONCHANGED:\r
+ return on_dwm_composition_changed();\r
+ //case WM_DWMCOLORIZATIONCOLORCHANGED:\r
+ // return on_dwm_colorlizationcolor_changed\r
+ }\r
\r
- void base_window::create_device_independent_resources()\r
- {\r
+ // 他のWindowメッセージを派生クラス側でフックできるようにする\r
+ return other_window_proc(hwnd,message,wParam,lParam);\r
\r
- // Direct2DFactory の生成\r
+ };\r
\r
- if(!factory_){\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::register_class (\r
+ const wchar_t * menu_name,\r
+ uint32_t style ,\r
+ int32_t cbClsExtra,\r
+ int32_t cbWndExtra,\r
+ HICON hIcon ,\r
+ HCURSOR hCursor,\r
+ HBRUSH hbrBackground ,\r
+ HICON hIconSm\r
+ ) \r
+ {\r
+ wnd_class_.reset(new sf::window_class_ex(menu_name,name_,HINST_THISCOMPONENT,&start_wnd_proc,style,cbClsExtra,cbWndExtra,hIcon,hCursor,hbrBackground,hIconSm));\r
+ }\r
+\r
+ /** デフォルト設定 */\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::register_class()\r
+ {\r
+ //register_class(0,0);\r
+ wnd_class_.reset(new sf::window_class_ex(0,name_,HINST_THISCOMPONENT,&start_wnd_proc));\r
+ }\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::create_window(HWND parent)\r
+ {\r
+ // Create the application window.\r
+ //\r
+ // Because the CreateWindow function takes its size in pixels, we\r
+ // obtain the system DPI and use it to scale the window size.\r
+ //FLOAT dpiX, dpiY;\r
+ //factory_->GetDesktopDpi(&dpiX, &dpiY);\r
+\r
+\r
+ // Windowを作成する\r
+ // Windowを作成する\r
+ CreateWindowEx(\r
+ WS_EX_APPWINDOW/* | WS_EX_LAYERED */,\r
+ name_.c_str(),\r
+ title_.c_str(),\r
+ WS_OVERLAPPEDWINDOW /*| WS_POPUP*/,\r
+ CW_USEDEFAULT,\r
+ CW_USEDEFAULT,\r
+ static_cast<uint32_t>(width_),\r
+ static_cast<uint32_t>(height_),\r
+ parent,\r
+ NULL,\r
+ HINST_THISCOMPONENT,\r
+ this\r
+ );\r
+ ::GetWindowPlacement(hwnd_,&wp_);\r
+ }\r
+\r
+\r
+ //void base_win32_window::show() \r
+ //{\r
+ // //HRESULT hr = S_OK;\r
+ // //BOOL enable;\r
+ // //DwmIsCompositionEnabled (&enable);\r
+ // //if(enable){\r
+ // // //Create and populate the BlurBehind structre\r
+ // // DWM_BLURBEHIND bb = {0};\r
+ // // //Enable Blur Behind and Blur Region;\r
+ // // bb.dwFlags = DWM_BB_ENABLE;\r
+ // // bb.fEnable = true;\r
+ // // bb.hRgnBlur = NULL;\r
+\r
+ // // //Enable Blur Behind\r
+ // // hr = DwmEnableBlurBehindWindow(hwnd_, &bb);\r
+ // //}\r
+ // ::ShowWindow(hwnd_,SW_SHOW);\r
+ // ::GetWindowPlacement(&wp_);\r
+ //}\r
+\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::update() {::UpdateWindow(hwnd_);}\r
+\r
+ template <typename ProcType> \r
+ base_win32_window<ProcType>::~base_win32_window()\r
+ {\r
+ }\r
+\r
+ template <typename ProcType> \r
+ base_win32_window<ProcType>::base_win32_window(const std::wstring& title,const std::wstring& name,bool fit_to_display,float width,float height)\r
+ : title_(title),name_(name),fit_to_display_(fit_to_display),width_(width),height_(height),thunk_(this,reinterpret_cast<ProcType::proc_type>(base_win32_window::WndProc)),hwnd_(0),timer_(*this,10)\r
+ {\r
+ ZeroMemory(&actual_desc_,sizeof(DXGI_MODE_DESC));\r
+ width_ = dpi_.scale_x(width_);\r
+ height_ = dpi_.scale_y(height_);\r
+ memset(&wp_,0,sizeof(wp_));\r
+ wp_.length = sizeof(WINDOWPLACEMENT);\r
+ thunk_proc_ = (WNDPROC)thunk_.getCode();\r
+ create_device_independent_resources();\r
+ }\r
+\r
+ template <typename ProcType> \r
+ typename base_win32_window<ProcType>::result_t base_win32_window<ProcType>::on_nccreate(CREATESTRUCT *p)\r
+ {\r
+\r
+ return std::is_same<proc_t,wndproc>::value?1:FALSE;\r
+ }\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::create_device_independent_resources()\r
+ {\r
+\r
+ // DXGI Factory の 生成\r
+\r
+ if(!dxgi_factory_)\r
+ {\r
+ THROW_IFERR(CreateDXGIFactory1(__uuidof(IDXGIFactory1),reinterpret_cast<void**>(dxgi_factory_.GetAddressOf())));\r
+ get_dxgi_information();\r
+ }\r
+\r
+ if(!factory_){\r
#if defined(DEBUG) || defined(_DEBUG)\r
D2D1_FACTORY_OPTIONS options;\r
options.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION ;\r
- EXCEPTION_ON_ERROR(D2D1CreateFactory(\r
+ THROW_IFERR(D2D1CreateFactory(\r
D2D1_FACTORY_TYPE_SINGLE_THREADED,\r
options,\r
- &factory_\r
+ factory_.GetAddressOf()\r
));\r
#else\r
EXCEPTION_ON_ERROR(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &factory_));\r
}\r
\r
if(!write_factory_){\r
- EXCEPTION_ON_ERROR(::DWriteCreateFactory(\r
+ THROW_IFERR(::DWriteCreateFactory(\r
DWRITE_FACTORY_TYPE_SHARED,\r
__uuidof(IDWriteFactory),\r
- reinterpret_cast<IUnknown**>(&write_factory_)\r
+ reinterpret_cast<IUnknown**>(write_factory_.GetAddressOf())\r
));\r
}\r
\r
\r
- //wic_imaging_factory_.CreateInstance(CLSID_WICImagingFactory);\r
+ }\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::create_device(){\r
+ calc_client_size();\r
+ HRESULT hr = S_OK;\r
+ init_ = false;\r
+ RECT rc;\r
+ GetWindowRect(hwnd_,&rc);\r
\r
- //thunk_proc_ = (WNDPROC)thunk_.getCode();\r
+ // アダプタデバイス情報の取得\r
+ //LARGE_INTEGER version;\r
+ THROW_IFERR(dxgi_factory_->EnumAdapters1(0,&adapter_));\r
+ //THROW_IFERR(adapter_->CheckInterfaceSupport( __uuidof(ID3D10Device),&version));\r
\r
- };\r
\r
- void base_window::register_class (\r
- wchar_t * menu_name,\r
- boost::uint32_t style ,\r
- boost::int32_t cbClsExtra,\r
- HICON hIcon ,\r
- HCURSOR hCursor,\r
- HBRUSH hbrBackground ,\r
- HICON hIconSm\r
- ) \r
- {\r
- wnd_class_.reset(new sf::window_class_ex(menu_name,name_,HINST_THISCOMPONENT,thunk_proc_,style,cbClsExtra,hIcon,hCursor,hbrBackground,hIconSm));\r
- }\r
-\r
- /** デフォルト設定 */\r
- void base_window::register_class()\r
- {\r
- wnd_class_.reset(new sf::window_class_ex(0,name_,HINST_THISCOMPONENT,thunk_proc_));\r
- }\r
-\r
- void base_window::create_window()\r
- {\r
- // Create the application window.\r
- //\r
- // Because the CreateWindow function takes its size in pixels, we\r
- // obtain the system DPI and use it to scale the window size.\r
- FLOAT dpiX, dpiY;\r
- //factory_->GetDesktopDpi(&dpiX, &dpiY);\r
-\r
-\r
- // Windowを作成する\r
- CreateWindow(\r
- name_.c_str(),\r
- title_.c_str(),\r
- WS_OVERLAPPEDWINDOW,\r
- CW_USEDEFAULT,\r
- CW_USEDEFAULT,\r
- static_cast<boost::uint32_t>(ceil(width_ /** dpiX / 96.f*/)),\r
- static_cast<boost::uint32_t>(ceil(height_ /** dpiY / 96.f*/)),\r
- NULL,\r
- NULL,\r
- HINST_THISCOMPONENT,\r
- this\r
- );\r
- }\r
-\r
- void base_window::create_device()\r
- {\r
-\r
-// input_.reset(new input(HINST_THISCOMPONENT,hwnd_));\r
- HRESULT hr = S_OK;\r
-\r
-\r
- //ウィンドウの現在の幅、高さを求める\r
- RECT rc;\r
- GetClientRect( hwnd_, &rc );\r
- boost::uint32_t width = rc.right - rc.left;\r
- boost::uint32_t height = rc.bottom - rc.top;\r
-\r
- {\r
- //wic_imaging_factory_.CreateInstance(CLSID_WICImagingFactory);\r
-// bitmap_ = load_bitmap_from_file(render_target_,wic_imaging_factory_,L"myship.png");\r
- }\r
-\r
- if(!render_target_)\r
- {\r
- RECT rc;\r
- GetClientRect(hwnd_, &rc);\r
-\r
- D2D1_SIZE_U size = D2D1::SizeU(\r
- rc.right - rc.left,\r
- rc.bottom - rc.top\r
- );\r
-\r
- EXCEPTION_ON_ERROR(factory_->CreateHwndRenderTarget(\r
- D2D1::RenderTargetProperties(),\r
- D2D1::HwndRenderTargetProperties(hwnd_, size,D2D1_PRESENT_OPTIONS_IMMEDIATELY),\r
- &render_target_\r
- ));\r
- // Create a DC render target \r
- //D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(\r
- // D2D1_RENDER_TARGET_TYPE_DEFAULT,\r
- // D2D1::PixelFormat(\r
- // DXGI_FORMAT_B8G8R8A8_UNORM,\r
- // D2D1_ALPHA_MODE_IGNORE\r
- // ) , 0.0, 0.0,\r
- // D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE\r
- // );\r
-\r
- //EXCEPTION_ON_ERROR(factory_->CreateDCRenderTarget(\r
- // &props,\r
- // &render_target_\r
- // ));\r
- }\r
- }\r
-\r
-\r
- void base_window::discard_device()\r
- {\r
-/* if(render_target_)\r
- {\r
- render_target_.Release();\r
- }*/\r
- }\r
-\r
- void base_window::show(boost::uint32_t show_flag) \r
- {\r
- //HRESULT hr = S_OK;\r
- //BOOL enable;\r
- //DwmIsCompositionEnabled (&enable);\r
- //if(enable){\r
- // //Create and populate the BlurBehind structre\r
- // DWM_BLURBEHIND bb = {0};\r
- // //Enable Blur Behind and Blur Region;\r
- // bb.dwFlags = DWM_BB_ENABLE;\r
- // bb.fEnable = true;\r
- // bb.hRgnBlur = NULL;\r
-\r
- // //Enable Blur Behind\r
- // hr = DwmEnableBlurBehindWindow(hwnd_, &bb);\r
- //}\r
- ::ShowWindow(hwnd_,show_flag);\r
- }\r
- void base_window::update() {::UpdateWindow(hwnd_);}\r
-\r
- base_window::~base_window()\r
- {\r
- safe_release(factory_);\r
- safe_release(write_factory_);\r
+ // D3DDeviceの作成\r
\r
- }\r
+ std::vector<D3D_FEATURE_LEVEL> feature_levels = \r
+ boost::assign::list_of<D3D_FEATURE_LEVEL>\r
+ (D3D_FEATURE_LEVEL_11_0 ) // DirectX11対応GPU\r
+ (D3D_FEATURE_LEVEL_10_1) // DirectX10.1対応GPU\r
+ (D3D_FEATURE_LEVEL_10_0 ); // DirectX10対応GPU\r
\r
+ D3D_FEATURE_LEVEL level;\r
+ THROW_IFERR(::D3D11CreateDevice(\r
+ adapter_.Get(),\r
+ D3D_DRIVER_TYPE_UNKNOWN ,\r
+ NULL,\r
+ D3D11_CREATE_DEVICE_DEBUG,\r
+ &feature_levels[0],\r
+ feature_levels.size(),\r
+ D3D11_SDK_VERSION,\r
+ &d3d_device_,\r
+ &level,\r
+ &d3d_context_));\r
\r
- base_window::base_window(const std::wstring& title,const std::wstring& name,bool fit_to_display,float width,float height)\r
- : title_(title),name_(name),fit_to_display_(fit_to_display),\r
- width_(width),height_(height),thunk_(this,base_window::WndProc),hwnd_(0)\r
- {\r
- thunk_proc_ = (WNDPROC)thunk_.getCode();\r
- //create_device_independent_resources();\r
- }\r
+ THROW_IFERR(adapter_->EnumOutputs(0,&output_));\r
\r
+ // MSAA\r
+ DXGI_SAMPLE_DESC msaa;\r
+ for(int i = 0; i <= D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT; i++){\r
+ UINT q;\r
+ if SUCCEEDED(d3d_device_->CheckMultisampleQualityLevels(DXGI_FORMAT_D24_UNORM_S8_UINT, i, &q)){\r
+ if(1 < q){\r
+ msaa.Count = i;\r
+ msaa.Quality = q - 1;\r
+ break;\r
+ }\r
+ }\r
+ }\r
\r
+ // 表示モード\r
+ DXGI_MODE_DESC desired_desc = {};// , actual_desc_ = {};\r
+ // 各色8ビットで符号化なし正規化数\r
+ desired_desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;\r
+ desired_desc.Height = height_;// 高さ\r
+ desired_desc.Width = width_;// 幅\r
+ desired_desc.Scaling = DXGI_MODE_SCALING_CENTERED;// スケーリングなし\r
+ // リフレッシュレートを60Hzを要求する\r
\r
- base_window::operator HWND()\r
- {\r
- return hwnd_;\r
- };\r
+ desired_desc.RefreshRate.Numerator = 60000;\r
+ desired_desc.RefreshRate.Denominator = 1000;\r
+ // 近いモードを検索\r
+ THROW_IF_ERR(output_->FindClosestMatchingMode(&desired_desc,&actual_desc_,d3d_device_.Get()));\r
\r
- //ID2D1FactoryPtr base_window::factory() { return impl_->factory();};\r
- //ID2D1HwndRenderTargetPtr base_window::render_target() { return impl_->render_target();};\r
- //IDWriteFactoryPtr base_window::write_factory() {return impl_->write_factory();};\r
-\r
-// toplevel_window_ptr create_toplevel_window\r
-// (\r
-// const std::wstring& menu_name,\r
-// const std::wstring& name,\r
-// const boost::uint32_t show_flag,\r
-// bool fit_to_display,\r
-// float width,\r
-// float height\r
-// )\r
-// {\r
-// toplevel_window* p = new toplevel_window(menu_name,name,fit_to_display,width,height);\r
-// p->register_class();\r
-// p->create_window();\r
-// p->show(show_flag);\r
-// p->update();\r
-// return toplevel_window_ptr(p);\r
-// }\r
-//\r
-// LRESULT toplevel_window::window_proc(HWND hwnd,boost::uint32_t message, WPARAM wParam, LPARAM lParam) \r
-// {\r
-// \r
-//\r
-// switch (message)\r
-// {\r
-// case WM_CREATE:\r
-// {\r
-// // TODO:\r
-// create_device();\r
-// break;\r
-// }\r
-// case WM_SIZE:\r
-// {\r
-// //if (render_target_)\r
-// //{\r
-// // D2D1_SIZE_U size;\r
-// // size.width = lParam & 0xFFFF;\r
-// // size.height = (lParam >> 16) & 0xFFFF; ;\r
-//\r
-// // // Note: This method can fail, but it's okay to ignore the\r
-// // // error here -- it will be repeated on the next call to\r
-// // // EndDraw.\r
-// // render_target_->Resize(size);\r
-// //}\r
-// }\r
-// case WM_PAINT:\r
-// {\r
-// //create_device();\r
-// \r
-// paint_struct begin_paint(hwnd);\r
-// render();\r
-//\r
-//\r
-// return FALSE;\r
-// }\r
-// case WM_DISPLAYCHANGE:\r
-// {\r
-// ::InvalidateRect(hwnd, NULL, FALSE);\r
-// }\r
-// case WM_ERASEBKGND:\r
-// {\r
-// return FALSE;\r
-// }\r
-// case WM_MOUSEMOVE:\r
-// {\r
-//// on_mouse_move(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam),wParam); \r
-// }\r
-// case WM_LBUTTONDOWN:\r
-// {\r
-// }\r
-// }\r
-//\r
-// if(message == WM_CLOSE)\r
-// {\r
-// BOOL ret(::DestroyWindow(hwnd));\r
-// BOOST_ASSERT(ret != 0);\r
-// }\r
-//\r
-// if(message == WM_DESTROY)\r
-// {\r
-// ::PostQuitMessage(0);\r
-// return 0;\r
-// }\r
-//\r
-// return ::DefWindowProcW(hwnd,message,wParam,lParam);\r
-// }\r
-//\r
-// void toplevel_window::main_loop()\r
-// {\r
-// render();\r
-// }\r
-//\r
-// void toplevel_window::render()\r
-// {\r
-//\r
-// static float t = 0.0f;\r
-//\r
-// if (render_target_)\r
-// {\r
-// // Retrieve the size of the render target.\r
-// D2D1_SIZE_F renderTargetSize = render_target_->GetSize();\r
-// try {\r
-// render_target_->BeginDraw();\r
-// render_target_->Clear(D2D1::ColorF(D2D1::ColorF::White));\r
-// render_target_->SetTransform(D2D1::Matrix3x2F::Identity());\r
-// //render_target_->Clear(D2D1::ColorF(D2D1::ColorF::White));\r
-// ID2D1SolidColorBrushPtr brush;\r
-// render_target_->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black), &brush);\r
-// ID2D1SolidColorBrushPtr brushr;\r
-// render_target_->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Red), &brushr);\r
-//\r
-// D2D1_RECT_F layoutRect = D2D1::RectF(50.f, 50.f, 600.f, 200.f);\r
-// IDWriteTextFormatPtr write_text_format;\r
-// // Text Formatの作成\r
-// EXCEPTION_ON_ERROR(write_factory_->CreateTextFormat(\r
-// L"メイリオ", // Font family name.\r
-// NULL, // Font collection (NULL sets it to use the system font collection).\r
-// DWRITE_FONT_WEIGHT_REGULAR,\r
-// DWRITE_FONT_STYLE_NORMAL,\r
-// DWRITE_FONT_STRETCH_NORMAL,\r
-// 48.0f,\r
-// L"ja-jp",\r
-// &write_text_format\r
-// ));\r
-// // Actually draw the text at the origin.\r
-// render_target_->DrawTextW(\r
-// L"こんにちは、世界！By S.F.",\r
-// wcslen(L"こんにちは、世界！By S.F."),\r
-// write_text_format,\r
-// layoutRect, \r
-// brush);\r
-//// render_target_->DrawBitmap(bitmap_,D2D1::Rect<float>(40.0f,200.0f,64.0f + 40.0f,64.0f + 200.0f),1.0f,D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,D2D1::Rect<float>(0.0f,0.0f,64.0f,64.0f));\r
-//\r
-// IDWriteTextFormatPtr write_text_format2;\r
-// // Text Formatの作成\r
-// EXCEPTION_ON_ERROR(write_factory_->CreateTextFormat(\r
-// L"メイリオ", // Font family name.\r
-// NULL, // Font collection (NULL sets it to use the system font collection).\r
-// DWRITE_FONT_WEIGHT_REGULAR,\r
-// DWRITE_FONT_STYLE_NORMAL,\r
-// DWRITE_FONT_STRETCH_NORMAL,\r
-// 12.0f,\r
-// L"ja-jp",\r
-// &write_text_format2\r
-// ));\r
-// std::wstring lbl1(L"Direct2D");\r
-// render_target_->DrawTextW(lbl1.c_str(),lbl1.size(),write_text_format2,D2D1::RectF(40.0f,270.0f,64.0f+40.0f,64.0f + 270.0f),brushr);\r
-// std::wstring lbl2(L"D3DX10Sprite");\r
-// render_target_->DrawTextW(lbl2.c_str(),lbl2.size(),write_text_format2,D2D1::RectF(140.0f,270.0f,96.0f+140.0f,128.0f + 270.0f),brushr);\r
-//\r
-//// std::wstring lbl3(L"DirectWrite+Direct2D");\r
-// render_target_->DrawTextW(lbl3.c_str(),lbl3.size(),write_text_format2,D2D1::RectF(60.0f,40.0f,280.0f,128.0f),brushr);\r
-//\r
-// std::wstring lbl4(L"Direct3D");\r
-// render_target_->DrawTextW(lbl4.c_str(),lbl4.size(),write_text_format2,D2D1::RectF(280.0f,160.0f,380.0f,190.0f),brushr);\r
-//\r
-// EXCEPTION_ON_ERROR(render_target_->EndDraw());\r
-//\r
-// } catch(...) {\r
-// throw;\r
-// }\r
-// }\r
-// };\r
-\r
-//\r
-// Creates a Direct2D bitmap from the specified\r
-// file name.\r
-//\r
-ID2D1BitmapPtr load_bitmap_from_file(\r
- ID2D1HwndRenderTargetPtr render_target,\r
- IWICImagingFactoryPtr wic_factory,\r
- std::wstring uri,\r
- boost::uint32_t destination_width,\r
- boost::uint32_t destination_height\r
-)\r
-{\r
- HRESULT hr = S_OK;\r
+ //// スワップチェーンの作成\r
+ //{\r
+ // DXGI_SWAP_CHAIN_DESC desc = {};\r
+\r
+ // desc.BufferDesc = actual_desc_;\r
+ // desc.SampleDesc.Count = 1;\r
+ // desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;\r
+ // desc.BufferCount = 1;\r
+ // // desc.SampleDesc = msaa;\r
+ // desc.OutputWindow = hwnd_;\r
+ // //desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;\r
+ // desc.Windowed = TRUE;\r
+ // desc.Flags = DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE;\r
\r
- IWICBitmapDecoderPtr decoder;\r
- IWICBitmapFrameDecodePtr decoder_source;\r
- IWICStreamPtr stream;\r
- IWICFormatConverterPtr converter;\r
- IWICBitmapScalerPtr scaler;\r
- ID2D1BitmapPtr bitmap;\r
-\r
- EXCEPTION_ON_ERROR(wic_factory->CreateDecoderFromFilename(\r
- uri.c_str(),\r
- NULL,\r
- GENERIC_READ,\r
- WICDecodeMetadataCacheOnLoad,\r
- &decoder\r
- ));\r
-\r
- // Create the initial frame.\r
- EXCEPTION_ON_ERROR(decoder->GetFrame(0, &decoder_source));\r
+ // THROW_IFERR(dxgi_factory_->CreateSwapChain(d3d_device_,&desc,&swap_chain_));\r
+\r
+ //}\r
+\r
+ // バックバッファの作成\r
\r
- // Convert the image format to 32bppPBGRA\r
- // (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).\r
- EXCEPTION_ON_ERROR(hr = wic_factory->CreateFormatConverter(&converter));\r
+ D3D11_TEXTURE2D_DESC desc = {0};\r
+ desc.Width = actual_desc_.Width;\r
+ desc.Height = actual_desc_.Height;\r
+ desc.Format = actual_desc_.Format;\r
+ desc.MipLevels = 1;\r
+ desc.SampleDesc.Count = 1;\r
+ desc.SampleDesc.Quality = 0;\r
+ desc.ArraySize = 1;\r
+ desc.Usage = D3D11_USAGE_DEFAULT;\r
+ desc.BindFlags = D3D11_BIND_RENDER_TARGET;\r
+ desc.MiscFlags = D3D11_RESOURCE_MISC_GDI_COMPATIBLE;\r
+ THROW_IF_ERR(d3d_device_->CreateTexture2D(&desc,NULL,&back_buffer_));\r
+\r
+ // スワップチェーン依存リソースの作成\r
+ \r
+ create_swapchain_dependent_resources();\r
\r
- // If a new width or height was specified, create an\r
- // IWICBitmapScaler and use it to resize the image.\r
- if (destination_width != 0 || destination_height != 0)\r
{\r
- boost::uint32_t originalWidth, originalHeight;\r
- EXCEPTION_ON_ERROR(decoder_source->GetSize((UINT*)&originalWidth, (UINT*)&originalHeight));\r
- if (destination_width == 0)\r
- {\r
- FLOAT scalar = static_cast<FLOAT>(destination_height) / static_cast<FLOAT>(originalHeight);\r
- destination_width = static_cast<boost::uint32_t>(scalar * static_cast<FLOAT>(originalWidth));\r
+ // バーテックスシェーダのコンパイル\r
+ ID3DBlobPtr vsblob,vserrblob;\r
+ DWORD compile_flag = D3DCOMPILE_ENABLE_STRICTNESS;\r
+#if defined( DEBUG ) || defined( _DEBUG )\r
+ compile_flag |= D3DCOMPILE_DEBUG;\r
+#endif\r
+\r
+ HRESULT hr = D3DCompileFromFile\r
+ (\r
+ L"dxgi_test.fx", NULL,D3D_COMPILE_STANDARD_FILE_INCLUDE , "VS", "vs_5_0", \r
+ compile_flag, 0, &vsblob, &vserrblob );\r
+ if( FAILED( hr ) )\r
+ {\r
+ if( vserrblob != NULL )\r
+ OutputDebugStringA( (char*)vserrblob->GetBufferPointer() );\r
+ if( vserrblob ) vserrblob.Reset();\r
+ throw sf::win32_error_exception(hr);\r
+ }\r
+\r
+ // バーテックスシェーダの生成\r
+ THROW_IFERR(d3d_device_->CreateVertexShader( vsblob->GetBufferPointer(), vsblob->GetBufferSize(), NULL, &v_shader_ ));\r
+\r
+ // 入力頂点レイアウトの定義\r
+ D3D11_INPUT_ELEMENT_DESC\r
+ layout[] = {\r
+ { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },\r
+ { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },\r
+ { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }};\r
+ ;\r
+\r
+ // 入力頂点レイアウトの生成\r
+ THROW_IFERR(d3d_device_->CreateInputLayout( layout, ARRAYSIZE(layout), vsblob->GetBufferPointer(),\r
+ vsblob->GetBufferSize(), &input_layout_ ));\r
+ vsblob.Reset();\r
+ }\r
+\r
+ // 入力レイアウトの設定\r
+ d3d_context_->IASetInputLayout( input_layout_.Get() );\r
+\r
+ // ピクセル・シェーダーのコンパイル\r
+ {\r
+ ID3DBlobPtr psblob,pserror;\r
+ DWORD compile_flag = D3DCOMPILE_ENABLE_STRICTNESS;\r
+#if defined( DEBUG ) || defined( _DEBUG )\r
+ compile_flag |= D3DCOMPILE_DEBUG;\r
+#endif\r
+ HRESULT hr = D3DCompileFromFile( L"dxgi_test.fx", NULL, D3D_COMPILE_STANDARD_FILE_INCLUDE, "PS", "ps_5_0", \r
+ compile_flag, 0, &psblob, &pserror);\r
+ if( FAILED( hr ) )\r
+ {\r
+ if( pserror != NULL )\r
+ OutputDebugStringA( (char*)pserror->GetBufferPointer() );\r
+ safe_release(pserror);\r
+ throw sf::win32_error_exception(hr);\r
+ }\r
+\r
+ // ピクセルシェーダの作成\r
+ THROW_IFERR(d3d_device_->CreatePixelShader( psblob->GetBufferPointer(), psblob->GetBufferSize(), NULL, &p_shader_ ));\r
+\r
+ psblob.Reset();\r
+ }\r
+\r
+ // バーテックスバッファの作成\r
+ // Create vertex buffer\r
+ simple_vertex vertices[] =\r
+ {\r
+ { XMFLOAT3( 0.0f, 0.0f,0.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ) , XMFLOAT2( 0.0f, 0.0f ) },\r
+ { XMFLOAT3( 640.0f, 0.0f, 0.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) },\r
+ { XMFLOAT3( 0.0f, 480.0f, 0.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ) , XMFLOAT2( 0.0f, 1.0f ) },\r
+ { XMFLOAT3( 640.0f, 480.0f, 0.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ), XMFLOAT2( 1.0f, 1.0f ) }\r
+\r
+ //{ XMFLOAT3( -1.0f, -1.0f, 2.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ) , XMFLOAT2( 1.0f, 1.0f ) },\r
+ //{ XMFLOAT3( 1.0f, -1.0f, 2.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ), XMFLOAT2( 0.0f, 1.0f ) },\r
+ //{ XMFLOAT3( -1.0f, 1.0f, 2.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ) , XMFLOAT2( 1.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, 1.0f, 2.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ), XMFLOAT2( 0.0f, 0.0f ) }\r
+ // ---------------------\r
+ //{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT3( 0.0f, 1.0f, 0.0f ),XMFLOAT2( 0.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, 1.0f, -1.0f ),XMFLOAT3( 0.0f, 1.0f, 0.0f ), XMFLOAT2( 1.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, 1.0f, 1.0f ),XMFLOAT3( 0.0f, 1.0f, 0.0f ), XMFLOAT2( 1.0f, 1.0f ) },\r
+ //{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT3( 0.0f, 1.0f, 0.0f ) ,XMFLOAT2( 0.0f, 1.0f ) },\r
+\r
+ //{ XMFLOAT3( -1.0f, -1.0f, -1.0f ),XMFLOAT3( 0.0f, -1.0f, 0.0f ), XMFLOAT2( 0.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT3( 0.0f, -1.0f, 0.0f ) ,XMFLOAT2( 1.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT3( 0.0f, -1.0f, 0.0f ) , XMFLOAT2( 1.0f, 1.0f ) },\r
+ //{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT3( 0.0f, -1.0f, 0.0f ),XMFLOAT2( 0.0f, 1.0f ) },\r
+\r
+ //{ XMFLOAT3( -1.0f, -1.0f, 1.0f ),XMFLOAT3( -1.0f, 0.0f, 0.0f ) , XMFLOAT2( 0.0f, 0.0f ) },\r
+ //{ XMFLOAT3( -1.0f, -1.0f, -1.0f ),XMFLOAT3( -1.0f, 0.0f, 0.0f ), XMFLOAT2( 1.0f, 0.0f ) },\r
+ //{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT3( -1.0f, 0.0f, 0.0f ),XMFLOAT2( 1.0f, 1.0f ) },\r
+ //{ XMFLOAT3( -1.0f, 1.0f, 1.0f ),XMFLOAT3( -1.0f, 0.0f, 0.0f ), XMFLOAT2( 0.0f, 1.0f ) },\r
+\r
+ //{ XMFLOAT3( 1.0f, -1.0f, 1.0f ),XMFLOAT3( 1.0f, 0.0f, 0.0f ), XMFLOAT2( 0.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, -1.0f, -1.0f ),XMFLOAT3( 1.0f, 0.0f, 0.0f ), XMFLOAT2( 1.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, 1.0f, -1.0f ),XMFLOAT3( 1.0f, 0.0f, 0.0f ), XMFLOAT2( 1.0f, 1.0f ) },\r
+ //{ XMFLOAT3( 1.0f, 1.0f, 1.0f ),XMFLOAT3( 1.0f, 0.0f, 0.0f ), XMFLOAT2( 0.0f, 1.0f ) },\r
+\r
+ //{ XMFLOAT3( -1.0f, -1.0f, -1.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ) , XMFLOAT2( 0.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, -1.0f, -1.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, 1.0f, -1.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ), XMFLOAT2( 1.0f, 1.0f ) },\r
+ //{ XMFLOAT3( -1.0f, 1.0f, -1.0f ),XMFLOAT3( 0.0f, 0.0f, -1.0f ) , XMFLOAT2( 0.0f, 1.0f ) },\r
+\r
+ //{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT3( 0.0f, 0.0f, 1.0f ) , XMFLOAT2( 0.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT3( 0.0f, 0.0f, 1.0f ) , XMFLOAT2( 1.0f, 0.0f ) },\r
+ //{ XMFLOAT3( 1.0f, 1.0f, 1.0f ),XMFLOAT3( 0.0f, 0.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },\r
+ //{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT3( 0.0f, 0.0f, 1.0f ),XMFLOAT2( 0.0f, 1.0f ) }\r
+ };\r
+ //std::vector<simple_vertex> vertices = boost::assign::list_of<simple_vertex>\r
+ //\r
+ // ( XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT2( 0.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) )\r
+ // ( XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) )\r
+\r
+ // ( XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT2( 0.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) )\r
+ // ( XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) )\r
+\r
+ // ( XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) )\r
+ // ( XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) )\r
+ // ( XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT2( 1.0f, 1.0f ) )\r
+ // ( XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) )\r
+\r
+ // ( XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT2( 1.0f, 1.0f ) )\r
+ // ( XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) )\r
+\r
+ // ( XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT2( 0.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT2( 1.0f, 1.0f ) )\r
+ // ( XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT2( 0.0f, 1.0f ) )\r
+\r
+ // ( XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) )\r
+ // ( XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) )\r
+ // ( XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) );\r
+\r
+ D3D11_BUFFER_DESC bd = {};\r
+ bd.Usage = D3D11_USAGE_DEFAULT;\r
+ bd.ByteWidth = sizeof( simple_vertex ) * 4;\r
+ bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;\r
+ bd.CPUAccessFlags = 0;\r
+\r
+ D3D11_SUBRESOURCE_DATA init_data = {};\r
+ init_data.pSysMem = vertices;\r
+ THROW_IFERR(d3d_device_->CreateBuffer( &bd, &init_data, &v_buffer_ ));\r
+\r
+ // 頂点バッファのセット\r
+ uint32_t stride = sizeof( simple_vertex );\r
+ uint32_t offset = 0;\r
+ d3d_context_->IASetVertexBuffers( 0, 1, v_buffer_.GetAddressOf(), &stride, &offset );\r
+\r
+ // インデックスバッファの生成\r
+ WORD indices[] =\r
+ {\r
+ 0,1,2,\r
+ 2,3,1\r
+ //3,1,0,\r
+ //2,1,3,\r
+ //6,4,5,\r
+ //7,4,6,\r
+ //11,9,8,\r
+ //10,9,11,\r
+ //14,12,13,\r
+ //15,12,14,\r
+ //19,17,16,\r
+ //18,17,19,\r
+ //22,20,21,\r
+ //23,20,22\r
+ };\r
+\r
+ bd.Usage = D3D11_USAGE_DEFAULT;\r
+ bd.ByteWidth = sizeof( WORD ) * 6;\r
+ bd.BindFlags = D3D11_BIND_INDEX_BUFFER;\r
+ bd.CPUAccessFlags = 0;\r
+ init_data.pSysMem = indices;\r
+ THROW_IFERR(d3d_device_->CreateBuffer( &bd, &init_data, &i_buffer_ ));\r
+\r
+ // インデックスバッファのセット\r
+ d3d_context_->IASetIndexBuffer( i_buffer_.Get(), DXGI_FORMAT_R16_UINT, 0 );\r
+\r
+ // プリミティブの形態を指定する\r
+ d3d_context_->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP );\r
+\r
+ // 定数バッファを生成する。\r
+ bd.Usage = D3D11_USAGE_DEFAULT;\r
+ bd.ByteWidth = sizeof(cb_never_changes);\r
+ bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;\r
+ bd.CPUAccessFlags = 0;\r
+ THROW_IFERR(d3d_device_->CreateBuffer( &bd, NULL, &cb_never_changes_ ));\r
+\r
+ bd.ByteWidth = sizeof(cb_change_on_resize);\r
+ THROW_IFERR(d3d_device_->CreateBuffer( &bd, NULL, &cb_change_on_resize_ ));\r
+\r
+ bd.ByteWidth = sizeof(cb_changes_every_frame);\r
+ THROW_IFERR(d3d_device_->CreateBuffer( &bd, NULL, &cb_changes_every_frame_ ));\r
+\r
+ // テクスチャのロード\r
+ ID3D11ResourcePtr ptr;\r
+ THROW_IFERR(CreateDDSTextureFromFile( d3d_device_.Get(), L"SF.dds", &ptr, &shader_res_view_, NULL ));\r
+// THROW_IFERR(CreateDDSTextureFromFile( d3d_device_, L"SF.dds", NULL, NULL, &shader_res_view_, NULL ));\r
+\r
+ // サンプルステートの生成\r
+ D3D11_SAMPLER_DESC sdesc = {};\r
+ sdesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;\r
+ sdesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;\r
+ sdesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;\r
+ sdesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;\r
+ sdesc.ComparisonFunc = D3D11_COMPARISON_NEVER;\r
+ sdesc.MinLOD = 0;\r
+ sdesc.MaxLOD = D3D11_FLOAT32_MAX;\r
+ THROW_IFERR(d3d_device_->CreateSamplerState( &sdesc, &sampler_state_ ));\r
+\r
+ // ワールド座標変換行列のセットアップ\r
+ mat_world_ = XMMatrixIdentity();\r
+\r
+ //g_vMeshColor( 0.7f, 0.7f, 0.7f, 1.0f );\r
+ // \r
+ init_view_matrix();\r
+\r
+\r
+\r
+ // 動的テクスチャの生成\r
+ {\r
+ //D3D11_TEXTURE2D_DESC desc = {0};\r
+ //desc.Width = 256;\r
+ //desc.Height = 256;\r
+ //desc.Format = actual_desc_.Format;\r
+ //desc.MipLevels = 1;\r
+ //desc.SampleDesc.Count = 1;\r
+ //desc.SampleDesc.Quality = 0;\r
+ //desc.ArraySize = 1;\r
+ //desc.Usage = D3D11_USAGE_DEFAULT;\r
+ //desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;\r
+ //// desc.MiscFlags = D3D11_RESOURCE_MISC_GDI_COMPATIBLE;\r
+ //THROW_IF_ERR(d3d_device_->CreateTexture2D(&desc,NULL,&cube_texture_));\r
+ //THROW_IF_ERR(d3d_device_->CreateRenderTargetView(cube_texture_,0,&cube_view_));\r
+\r
+ //// 深度バッファの作成\r
+ //D3D11_TEXTURE2D_DESC depth = {} ;\r
+ //depth.Width = desc.Width;//rc.right - rc.left;client_width_;\r
+ //depth.Height = desc.Height;//rc.bottom - rc.top;client_height_;\r
+ //depth.MipLevels = 1;\r
+ //depth.ArraySize = 1;\r
+ //depth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;\r
+ //depth.SampleDesc.Count = 1;\r
+ //depth.SampleDesc.Quality = 0;\r
+ //depth.Usage = D3D11_USAGE_DEFAULT;\r
+ //depth.BindFlags = D3D11_BIND_DEPTH_STENCIL;\r
+ //depth.CPUAccessFlags = 0;\r
+ //depth.MiscFlags = 0;\r
+ //THROW_IF_ERR(d3d_device_->CreateTexture2D( &depth, NULL, &cube_depth_texture_ ));\r
+\r
+ //D3D11_DEPTH_STENCIL_VIEW_DESC dsv = {};\r
+ //dsv.Format = depth.Format;\r
+ //dsv.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;\r
+ //dsv.Texture2D.MipSlice = 0;\r
+ //THROW_IF_ERR(d3d_device_->CreateDepthStencilView( cube_depth_texture_, &dsv, &cube_depth_view_ ));\r
+ //THROW_IF_ERR(d3d_device_->CreateShaderResourceView(cube_texture_,0,&cube_shader_res_view_));\r
+\r
+ //D3D11_SAMPLER_DESC sdesc = {};\r
+ //sdesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;\r
+ //sdesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;\r
+ //sdesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;\r
+ //sdesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;\r
+ //sdesc.ComparisonFunc = D3D11_COMPARISON_NEVER;\r
+ //sdesc.MinLOD = 0;\r
+ //sdesc.MaxLOD = D3D11_FLOAT32_MAX;\r
+ //THROW_IFERR(d3d_device_->CreateSamplerState( &sdesc, &cube_sampler_state_ ));\r
+ //cube_mat_projection_ = XMMatrixPerspectiveFovLH( XM_PIDIV4, /*(rc.right - rc.left)/(rc.bottom - rc.top)*/256 / 256, 0.01f, 100.0f );\r
+\r
+ }\r
+ // \r
+\r
+ init_ = true;// 初期化完了\r
+ }\r
+\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::init_view_matrix()\r
+ {\r
+ // ビュー行列のセットアップ\r
+ //基本値設定\r
+ float aspect = (float) width_ / height_; //アスペクト比(高さを1としたときの幅)\r
+ float depth = 1.0f; //奥行きZ\r
+ float fovy = (float)atan(1.0f / depth) * 2.0f; //視野をZ=0でデバイスの幅と高さに合わせる\r
+ \r
+ XMVECTOR eye = { 0.0f, 0.0f, -depth, 0.0f };\r
+ XMVECTOR at = { 0.0f, 0.0f, 0.0f, 0.0f};\r
+ XMVECTOR up = { 0.0f, 1.0f, 0.0f, 0.0f };\r
+ mat_view_ = XMMatrixLookAtLH( eye, at, up );\r
+ cb_never_changes cnc;\r
+ cnc.mView = XMMatrixTranspose( mat_view_ );\r
+ //cnc.vLightColor = XMFLOAT4( 1.0f, 0.5f, 0.5f, 1.0f );\r
+ cnc.vLightDir = XMFLOAT4(0.577f, 0.577f, -0.977f, 1.0f);\r
+ // 定数バッファに格納\r
+ d3d_context_->UpdateSubresource( cb_never_changes_.Get(), 0, NULL, &cnc, 0, 0 );\r
+\r
+ // 投影行列のセットアップ\r
+\r
+ //mat_projection_ = XMMatrixPerspectiveFovLH( XM_PIDIV4, /*(rc.right - rc.left)/(rc.bottom - rc.top)*/width_ / height_, 0.01f, 100.0f );\r
+ //mat_projection_ = XMMatrixPerspectiveFovLH( fovy, aspect, 0.01f, 100.0f );\r
+ mat_projection_ = XMMatrixPerspectiveFovLH( fovy, 1.0, 0.0001f, 100.0f );\r
+ cb_change_on_resize ccor;\r
+ ccor.mProjection = XMMatrixTranspose( mat_projection_ );\r
+ // 定数バッファに格納\r
+ d3d_context_->UpdateSubresource( cb_change_on_resize_.Get(), 0, NULL, &ccor, 0, 0 );\r
+\r
+ }\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::create_swapchain_dependent_resources()\r
+ {\r
+\r
+ // ビューの作成\r
+ //THROW_IF_ERR(swap_chain_->GetBuffer(0,texture_.GetIID(),(void**)&texture_));\r
+ //D3D11_TEXTURE2D_DESC desc;\r
+ //texture_->GetDesc(&desc);\r
+\r
+ //THROW_IF_ERR(d3d_device_->CreateRenderTargetView(texture_,0,&view_));\r
+ //texture_.Release();\r
+ THROW_IF_ERR(d3d_device_->CreateRenderTargetView(back_buffer_.Get(),0,view_.GetAddressOf()));\r
+ D3D11_TEXTURE2D_DESC desc;\r
+ back_buffer_->GetDesc(&desc);\r
+\r
+ // 深度バッファの作成\r
+ D3D11_TEXTURE2D_DESC depth = {} ;\r
+ depth.Width = desc.Width;//rc.right - rc.left;client_width_;\r
+ depth.Height = desc.Height;//rc.bottom - rc.top;client_height_;\r
+ depth.MipLevels = 1;\r
+ depth.ArraySize = 1;\r
+ depth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;\r
+ depth.SampleDesc.Count = 1;\r
+ depth.SampleDesc.Quality = 0;\r
+ depth.Usage = D3D11_USAGE_DEFAULT;\r
+ depth.BindFlags = D3D11_BIND_DEPTH_STENCIL;\r
+ depth.CPUAccessFlags = 0;\r
+ depth.MiscFlags = 0;\r
+ THROW_IF_ERR(d3d_device_->CreateTexture2D( &depth, NULL, &depth_texture_ ));\r
+\r
+ D3D11_DEPTH_STENCIL_VIEW_DESC dsv = {};\r
+ dsv.Format = depth.Format;\r
+ dsv.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;\r
+ dsv.Texture2D.MipSlice = 0;\r
+ THROW_IF_ERR(d3d_device_->CreateDepthStencilView( depth_texture_.Get(), &dsv, depth_view_.GetAddressOf() ));\r
+\r
+ // OMステージに登録する\r
+ // d3d_context_->OMSetRenderTargets( 1, &view_.Get(), depth_view_ );\r
+ d3d_context_->OMSetRenderTargets( 1, view_.GetAddressOf(), depth_view_.Get() );\r
+\r
+ // ビューポートの設定\r
+ D3D11_VIEWPORT vp;\r
+ vp.Width = depth.Width;//client_width_;\r
+ vp.Height = depth.Height;//client_height_;\r
+ vp.MinDepth = 0.0f;\r
+ vp.MaxDepth = 1.0f;\r
+ vp.TopLeftX = 0;\r
+ vp.TopLeftY = 0;\r
+ d3d_context_->RSSetViewports( 1, &vp );\r
+\r
+ ID3D11RasterizerState* hpRasterizerState = NULL;\r
+ D3D11_RASTERIZER_DESC hRasterizerDesc = {\r
+ D3D11_FILL_SOLID,\r
+ D3D11_CULL_NONE, //ポリゴンの裏表を無くす\r
+ FALSE,\r
+ 0,\r
+ 0.0f,\r
+ FALSE,\r
+ FALSE,\r
+ FALSE,\r
+ FALSE,\r
+ FALSE\r
+ };\r
+ d3d_device_->CreateRasterizerState(&hRasterizerDesc,&hpRasterizerState);\r
+ d3d_context_->RSSetState(hpRasterizerState);\r
+ }\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::discard_swapchain_dependent_resources()\r
+ {\r
+ safe_release(depth_view_);\r
+ safe_release(depth_texture_);\r
+ safe_release(view_);\r
+ safe_release(texture_);\r
+ }\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::discard_device()\r
+ {\r
+ safe_release(sampler_state_);\r
+ safe_release(shader_res_view_);\r
+ safe_release(cb_changes_every_frame_);\r
+ safe_release(cb_change_on_resize_);\r
+ safe_release(cb_never_changes_);\r
+ safe_release(i_buffer_);\r
+ safe_release(v_buffer_);\r
+ safe_release(p_shader_);\r
+ safe_release(input_layout_);\r
+ safe_release(v_shader_);\r
+ discard_swapchain_dependent_resources();\r
+ safe_release(back_buffer_);\r
+ //safe_release(cube_sampler_state_);\r
+ //safe_release(cube_shader_res_view_);\r
+ //safe_release(cube_view_);\r
+ //safe_release(cube_depth_view_);\r
+ //safe_release(cube_texture_);\r
+ //safe_release(cube_depth_texture_);\r
+ //safe_release(render_target_);\r
+// safe_release(swap_chain_);\r
+ safe_release(d3d_context_);\r
+ safe_release(d3d_device_);\r
+ safe_release(adapter_);\r
+\r
+ }\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::discard_device_independant_resources(){\r
+ safe_release(dxgi_factory_);\r
+ }\r
+\r
+ template <typename ProcType> \r
+ void base_win32_window<ProcType>::get_dxgi_information()\r
+ {\r
+ int i = 0;\r
+\r
+ while(1){\r
+ IDXGIAdapter1Ptr adapter;\r
+ HRESULT hr = dxgi_factory_->EnumAdapters1(i,&adapter);\r
+ if(hr == DXGI_ERROR_NOT_FOUND)\r
+ {\r
+ break;\r
+ }\r
+ DXGI_ADAPTER_DESC1 desc;\r
+ adapter->GetDesc1(&desc);\r
+ //adapter->CheckInterfaceSupport();\r
+\r
+ wdout << desc.Description << std::endl;\r
+ wdout << desc.DedicatedVideoMemory << std::endl;\r
+ IDXGIDevice1Ptr device;\r
+\r
+ uint32_t oi = 0;\r
+\r
+\r
+ while(1)\r
+ {\r
+ IDXGIOutputPtr output; \r
+ if(adapter->EnumOutputs(oi,&output) == DXGI_ERROR_NOT_FOUND){\r
+ break;\r
}\r
- else if (destination_height == 0)\r
+ DXGI_OUTPUT_DESC output_desc;\r
+ output->GetDesc(&output_desc); \r
+ UINT num = 0;\r
+ DXGI_FORMAT format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;\r
+ UINT flags = DXGI_ENUM_MODES_INTERLACED | DXGI_ENUM_MODES_SCALING;\r
+\r
+ output->GetDisplayModeList(format,flags,&num,0);\r
+ boost::shared_array<DXGI_MODE_DESC> disp_modes(new DXGI_MODE_DESC[num]);\r
+ output->GetDisplayModeList(format,flags,&num,&disp_modes[0]);\r
+ //output->GetFrameStatistics\r
+ for(uint32_t mode_index = 0;mode_index < num;++mode_index)\r
{\r
- FLOAT scalar = static_cast<FLOAT>(destination_width) / static_cast<FLOAT>(originalWidth);\r
- destination_height = static_cast<boost::uint32_t>(scalar * static_cast<FLOAT>(originalHeight));\r
+ DXGI_MODE_DESC& mode(disp_modes[mode_index]);\r
+ wdout << boost::wformat(L"Format: %s %s \n Width: %d Height: %d RefleshRate: %d/%d Scaling:%s %s \n Scanline: %s %s ")\r
+ % display_modes[mode.Format].name % display_modes[mode.Format].description\r
+ % mode.Width % mode.Height \r
+ % mode.RefreshRate.Numerator % mode.RefreshRate.Denominator\r
+ % scalings[mode.Scaling].name % scalings[mode.Scaling].description\r
+ % scanline_orders[mode.ScanlineOrdering].name\r
+ % scanline_orders[mode.ScanlineOrdering].description\r
+ << std::endl;\r
}\r
+ // output->\r
+ wdout << output_desc.DeviceName << std::endl; \r
+ oi++;\r
+ }\r
\r
- EXCEPTION_ON_ERROR(wic_factory->CreateBitmapScaler(&scaler));\r
- EXCEPTION_ON_ERROR(scaler->Initialize(\r
- decoder_source,\r
- destination_width,\r
- destination_height,\r
- WICBitmapInterpolationModeCubic\r
- ));\r
- EXCEPTION_ON_ERROR(converter->Initialize(\r
- scaler.GetInterfacePtr(),\r
- GUID_WICPixelFormat32bppPBGRA,\r
- WICBitmapDitherTypeNone,\r
- NULL,\r
- 0.f,\r
- WICBitmapPaletteTypeMedianCut\r
- ));\r
+ adapter.Reset();\r
+ ++i;\r
}\r
- else // Don't scale the image.\r
+ }\r
+\r
+ template <typename ProcType>\r
+ typename base_win32_window<ProcType>::result_t base_win32_window<ProcType>::on_size(uint32_t flag,uint32_t width,uint32_t height)\r
+ {\r
+ if(init_ && !(width == 0 || height == 0))\r
{\r
- EXCEPTION_ON_ERROR(converter->Initialize(\r
- decoder_source.GetInterfacePtr(),\r
- GUID_WICPixelFormat32bppPBGRA,\r
- WICBitmapDitherTypeNone,\r
- NULL,\r
- 0.f,\r
- WICBitmapPaletteTypeMedianCut\r
- ));\r
+ update_window_size();\r
+ calc_client_size();\r
+ discard_swapchain_dependent_resources();\r
+ back_buffer_.Reset();\r
+ D3D11_TEXTURE2D_DESC desc = {0};\r
+ desc.Width = width_;\r
+ desc.Height = height_;\r
+ desc.Format = actual_desc_.Format;\r
+ desc.MipLevels = 1;\r
+ desc.SampleDesc.Count = 1;\r
+ desc.SampleDesc.Quality = 0;\r
+ desc.ArraySize = 1;\r
+ desc.Usage = D3D11_USAGE_DEFAULT;\r
+ desc.BindFlags = D3D11_BIND_RENDER_TARGET;\r
+ desc.MiscFlags = D3D11_RESOURCE_MISC_GDI_COMPATIBLE;\r
+ THROW_IF_ERR(d3d_device_->CreateTexture2D(&desc,NULL,&back_buffer_));\r
+ //swap_chain_->ResizeBuffers(0,0,0,DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE);\r
+ create_swapchain_dependent_resources();\r
+ init_view_matrix(); \r
+\r
+ // リージョンの設定\r
+ //HRGN rgn = CreateRectRgn(0, 0, width_, height_);\r
+ //SetWindowRgn(hwnd_, rgn, FALSE);\r
+\r
}\r
+ return std::is_same<proc_t,wndproc>::value?0:FALSE; \r
+ }\r
\r
- // Create a Direct2D bitmap from the WIC bitmap.\r
- EXCEPTION_ON_ERROR(render_target->CreateBitmapFromWicBitmap(\r
- converter.GetInterfacePtr(),\r
- NULL,\r
- &bitmap\r
- ));\r
+ template <typename ProcType>\r
+ typename base_win32_window<ProcType>::result_t base_win32_window<ProcType>::on_create(CREATESTRUCT *p)\r
+ {\r
+ // DWM API\r
+ BOOL dwmEnable;\r
+ DwmIsCompositionEnabled (&dwmEnable); \r
+ if (dwmEnable) EnableBlurBehind(hwnd_);\r
+ //DwmEnableComposition(DWM_EC_DISABLECOMPOSITION );\r
\r
- return bitmap;\r
-}\r
+ // ウィンドウ全体を半透明にする\r
+ //SetLayeredWindowAttributes(\r
+ // hwnd_,\r
+ // RGB(0,0,0), // color key\r
+ // 100, // alpha value\r
+ // LWA_ALPHA | LWA_COLORKEY);\r
+\r
+ // ウィンドウの指定領域を半透明にする\r
+ // リージョンの設定\r
+ //HRGN rgn = CreateRectRgn(0, 0, width_, height_);\r
+ //SetWindowRgn(hwnd_, rgn, FALSE);\r
+\r
+ create_device();\r
+\r
+ timer_.start();\r
+ //show();\r
+ show();\r
+ text(title_);\r
+ return std::is_same<proc_t,wndproc>::value?0:FALSE;\r
+ }\r
+\r
+ template <typename ProcType>\r
+ typename base_win32_window<ProcType>::result_t base_win32_window<ProcType>::on_paint() \r
+ {\r
+ //{\r
+ sf::paint_struct p(hwnd_);\r
+ // gdi_object<HBRUSH> brush(::CreateSolidBrush(RGB(255,0,0)));\r
+ // {\r
+ // FillRect(p->hdc,&p->rcPaint,brush);\r
+ // }\r
+ //}\r
+ render();\r
+ return std::is_same<proc_t,wndproc>::value?0:FALSE;\r
+ }\r
+\r
+ template <typename ProcType>\r
+ void base_win32_window<ProcType>::render()\r
+ {\r
+\r
+ if(init_)\r
+ {\r
+ static float rot = 0.0f;\r
+\r
+ float color[4] = { 0.0f, 0.0f, 0.0f, 0.5f }; \r
+\r
+ // 描画ターゲットのクリア\r
+ d3d_context_->ClearRenderTargetView(view_.Get(),color);\r
+ // 深度バッファのクリア\r
+ d3d_context_->ClearDepthStencilView(depth_view_.Get(), D3D11_CLEAR_DEPTH, 1.0f, 0 );\r
+\r
+ // 色の変更\r
+ mesh_color_.x = 1.0f;\r
+ mesh_color_.y = 1.0f;\r
+ mesh_color_.z = 1.0f;\r
+\r
+ // 定数更新\r
+\r
+ cb_changes_every_frame cb;\r
+\r
+ mat_world_ = XMMatrixIdentity();\r
+// mat_world_._11 = 2.0f / width_;\r
+ mat_world_.r[0].m128_f32[0] = 2.0f / width_;\r
+ // mat_world_._22 = 2.0f / height_ * -1.0f;\r
+ mat_world_.r[1].m128_f32[1] = 2.0f / height_ * -1.0f;\r
+// mat_world_._41 = -1.0f;\r
+ mat_world_.r[3].m128_f32[0] = -1.0f;\r
+// mat_world_._42 = 1.0f;\r
+ mat_world_.r[3].m128_f32[1] = 1.0f;\r
+ mat_world_ *= XMMatrixRotationX(rot);\r
+ rot += 0.005f;\r
+ cb.mWorld = XMMatrixTranspose(mat_world_);\r
+ cb.vLightColor = mesh_color_;\r
+ d3d_context_->UpdateSubresource( cb_changes_every_frame_.Get(), 0, NULL, &cb, 0, 0 );\r
\r
+ // 四角形\r
+ d3d_context_->VSSetShader( v_shader_.Get(), NULL, 0 );\r
+ d3d_context_->VSSetConstantBuffers( 0, 1, cb_never_changes_.GetAddressOf() );\r
+ d3d_context_->VSSetConstantBuffers( 1, 1, cb_change_on_resize_.GetAddressOf() );\r
+ d3d_context_->VSSetConstantBuffers( 2, 1, cb_changes_every_frame_.GetAddressOf() );\r
+ d3d_context_->PSSetShader( p_shader_.Get(), NULL, 0 );\r
+ d3d_context_->PSSetConstantBuffers( 2, 1, cb_changes_every_frame_.GetAddressOf() );\r
+ d3d_context_->PSSetShaderResources( 0, 1, shader_res_view_.GetAddressOf() );\r
+ d3d_context_->PSSetSamplers( 0, 1, sampler_state_.GetAddressOf() );\r
\r
+ d3d_context_->DrawIndexed( 6, 0, 0 );\r
+\r
+ // 画面に転送\r
+ IDXGISurface1Ptr surface;\r
+ THROW_IF_ERR(back_buffer_.As<IDXGISurface1>(&surface));\r
+ HDC sdc;\r
+ THROW_IF_ERR(surface->GetDC( FALSE, &sdc ));\r
+\r
+ //get_dc ddc(hwnd_);\r
+ get_window_dc ddc(hwnd_);\r
+// RECT rc;\r
+// GetWindowRect(hwnd_,&rc);\r
+/* POINT wnd_pos = {rc.left,rc.top};\r
+ SIZE wnd_size = {width_,height_};\r
+ */\r
+ //BLENDFUNCTION blend;\r
+ // blend.BlendOp = AC_SRC_OVER;\r
+ // blend.BlendFlags = 0;\r
+ // blend.SourceConstantAlpha = 128; // 不透明度（レイヤードウィンドウ全体のアルファ値）\r
+ // blend.AlphaFormat = AC_SRC_ALPHA;\r
+ // デバイスコンテキストにおけるレイヤの位置\r
+ POINT po;\r
+ po.x = po.y = 0;\r
+ BOOL err;\r
+ err = BitBlt(ddc.get(),0,0,width_,height_,sdc,0,0,SRCCOPY);\r
+// err = AlphaBlend(ddc.get(),0,0,width_,height_,sdc,0,0,width_,height_,blend);\r
+ //err = UpdateLayeredWindow(hwnd_, ddc.get(), &wnd_pos, &wnd_size, sdc, &po, RGB(255,0,0), &blend, ULW_ALPHA | ULW_COLORKEY );\r
+ BOOST_ASSERT(err == TRUE);\r
+ surface->ReleaseDC( NULL);\r
+ surface.Reset();\r
+ // OMステージに登録する\r
+ d3d_context_->OMSetRenderTargets( 1, view_.GetAddressOf(), depth_view_.Get() );\r
+ }\r
+\r
+ }\r
+\r
+ template <typename ProcType>\r
+ typename base_win32_window<ProcType>::result_t base_win32_window<ProcType>::on_dwm_composition_changed()\r
+ {\r
+ BOOL enabled;\r
+ DwmIsCompositionEnabled(&enabled);\r
+ if(enabled)\r
+ {\r
+ EnableBlurBehind(hwnd_);\r
+ }\r
+ return std::is_same<proc_t,wndproc>::value?0:FALSE;\r
+ }\r
+ template struct base_win32_window<wndproc>;\r
+ template struct base_win32_window<dlgproc>;\r
+\r
+ //ID2D1FactoryPtr base_win32_window::factory() { return impl_->factory();};\r
+ //ID2D1HwndRenderTargetPtr base_win32_window::render_target() { return impl_->render_target();};\r
+ //IDWriteFactoryPtr base_win32_window::write_factory() {return impl_->write_factory();};\r
+\r
+ subclass_window::subclass_window(HWND hwnd) \r
+ : base_win32_window (\r
+ std::wstring(L""),std::wstring(L""),false,0,0\r
+ ),is_subclassed_(false)\r
+ {\r
+ attach(hwnd);\r
+ }\r
+\r
+ subclass_window::subclass_window()\r
+ : base_win32_window (\r
+ std::wstring(L""),std::wstring(L""),false,0,0\r
+ ),is_subclassed_(false)\r
+ {\r
+\r
+ }\r
+\r
+ subclass_window::~subclass_window()\r
+ {\r
+ detatch();\r
+ }\r
+\r
+ void subclass_window::attach(HWND hwnd)\r
+ {\r
+ if(is_subclassed_)\r
+ detatch();\r
+\r
+ hwnd_ = hwnd;\r
+ proc_backup_ = reinterpret_cast<WNDPROC>(::GetWindowLongPtrW(hwnd_,GWLP_WNDPROC));\r
+ SetWindowLongPtrW(hwnd_,GWLP_WNDPROC,reinterpret_cast<LONG_PTR>(thunk_proc_));\r
+ is_subclassed_ = true;\r
+ }\r
+\r
+ void subclass_window::detatch()\r
+ {\r
+ if(is_subclassed_)\r
+ {\r
+ SetWindowLongPtrW(hwnd_,GWLP_WNDPROC,reinterpret_cast<LONG_PTR>(proc_backup_));\r
+ is_subclassed_ = false;\r
+ }\r
+ }\r
}\r
\r
#pragma once
/*
- ==============================================================================
-
- This file is part of the Shooting3
- Copyright 2005-7 by Satoshi Fujiwara.
-
- Shooting3 can be redistributed and/or modified under the terms of the
- GNU General Public License, as published by the Free Software Foundation;
- either version 2 of the License, or (at your option) any later version.
-
- S.F.Tracker is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with S.F.Tracker; if not, visit www.gnu.org/licenses or write to the
- Free Software Foundation, Inc., 59 Temple Place, Suite 330,
- Boston, MA 02111-1307 USA
-
- ==============================================================================
*/
// Windows Header Files:
+#define XBYAK64
#include "exception.h"
+#include "base_window.h"
+#include "dpi.h"
#include "xbyak.h"
-//#include "input.h"
+#include "windows.h"
+#include "windowsx.h"
+#include "CommCtrl.h"
+#include <type_traits>
+#include "timer.h"
+//#include <boost/type_traits/is_same.hpp>
+// DLLのリンク
+#pragma comment(lib,"d2d1.lib")
+#pragma comment(lib,"winmm.lib")
+#pragma comment(lib,"dwrite.lib")
+#pragma comment(lib,"dwmapi.lib")
-_COM_SMARTPTR_TYPEDEF(ID2D1Factory,__uuidof(ID2D1Factory));
-_COM_SMARTPTR_TYPEDEF(IWICImagingFactory, __uuidof(IWICImagingFactory));
-_COM_SMARTPTR_TYPEDEF(IDWriteFactory , __uuidof(IDWriteFactory));
-_COM_SMARTPTR_TYPEDEF(IDWriteGdiInterop , __uuidof(IDWriteGdiInterop));
-_COM_SMARTPTR_TYPEDEF(IDWriteFontFace , __uuidof(IDWriteFontFace));
-_COM_SMARTPTR_TYPEDEF(IDWriteFont , __uuidof(IDWriteFont));
-_COM_SMARTPTR_TYPEDEF(IDWriteFontFamily , __uuidof(IDWriteFontFamily));
-_COM_SMARTPTR_TYPEDEF(IDWriteFontCollection , __uuidof(IDWriteFontCollection));
-_COM_SMARTPTR_TYPEDEF(IDWriteLocalizedStrings , __uuidof(IDWriteLocalizedStrings));
-_COM_SMARTPTR_TYPEDEF(ID2D1HwndRenderTarget , __uuidof(ID2D1HwndRenderTarget));
-_COM_SMARTPTR_TYPEDEF(ID2D1BitmapRenderTarget , __uuidof(ID2D1BitmapRenderTarget));
-_COM_SMARTPTR_TYPEDEF(ID2D1GdiInteropRenderTarget , __uuidof(ID2D1GdiInteropRenderTarget));
-_COM_SMARTPTR_TYPEDEF(IDWriteTextFormat, __uuidof(IDWriteTextFormat));
-_COM_SMARTPTR_TYPEDEF(IDWriteTextLayout, __uuidof(IDWriteTextLayout));
-_COM_SMARTPTR_TYPEDEF(ID2D1PathGeometry , __uuidof(ID2D1PathGeometry));
-_COM_SMARTPTR_TYPEDEF(ID2D1LinearGradientBrush , __uuidof(ID2D1LinearGradientBrush));
-_COM_SMARTPTR_TYPEDEF(ID2D1GradientStopCollection , __uuidof(ID2D1GradientStopCollection));
-_COM_SMARTPTR_TYPEDEF(ID2D1SolidColorBrush , __uuidof(ID2D1SolidColorBrush));
-_COM_SMARTPTR_TYPEDEF(ID2D1BitmapBrush , __uuidof(ID2D1BitmapBrush));
-_COM_SMARTPTR_TYPEDEF(ID2D1Bitmap , __uuidof(ID2D1Bitmap));
-_COM_SMARTPTR_TYPEDEF(IWICBitmapDecoder,__uuidof(IWICBitmapDecoder));
-_COM_SMARTPTR_TYPEDEF(IWICBitmapFrameDecode,__uuidof(IWICBitmapFrameDecode));
-_COM_SMARTPTR_TYPEDEF(IWICStream,__uuidof(IWICStream));
-_COM_SMARTPTR_TYPEDEF(IWICFormatConverter,__uuidof(IWICFormatConverter));
-_COM_SMARTPTR_TYPEDEF(IWICBitmapScaler,__uuidof(IWICBitmapScaler));
-
-template <class COM_SMART_PTR > inline void safe_release(COM_SMART_PTR& ptr)
-{
- if(ptr)
- {
- ptr.Release();
- }
-};
+//#include "input.h"
+// Direct Write
+
+_WRL_PTR_TYPEDEF(IDWriteFactory);
+_WRL_PTR_TYPEDEF(IDWriteGdiInterop);
+_WRL_PTR_TYPEDEF(IDWriteFontFace);
+_WRL_PTR_TYPEDEF(IDWriteFont);
+_WRL_PTR_TYPEDEF(IDWriteFontFamily);
+_WRL_PTR_TYPEDEF(IDWriteFontCollection);
+_WRL_PTR_TYPEDEF(IDWriteLocalizedStrings);
+_WRL_PTR_TYPEDEF(IDWriteTextFormat);
+_WRL_PTR_TYPEDEF(IDWriteTextLayout);
+_WRL_PTR_TYPEDEF(IDWriteFontFile);
+//_WRL_PTR_TYPEDEF(IDWriteFontFile);
+
+// Direct2D
+
+_WRL_PTR_TYPEDEF(ID2D1Factory);
+_WRL_PTR_TYPEDEF(ID2D1HwndRenderTarget);
+_WRL_PTR_TYPEDEF(ID2D1BitmapRenderTarget);
+_WRL_PTR_TYPEDEF(ID2D1GdiInteropRenderTarget);
+_WRL_PTR_TYPEDEF(ID2D1DCRenderTarget);
+_WRL_PTR_TYPEDEF(ID2D1PathGeometry);
+_WRL_PTR_TYPEDEF(ID2D1LinearGradientBrush);
+_WRL_PTR_TYPEDEF(ID2D1GradientStopCollection);
+_WRL_PTR_TYPEDEF(ID2D1SolidColorBrush);
+_WRL_PTR_TYPEDEF(ID2D1BitmapBrush);
+_WRL_PTR_TYPEDEF(ID2D1Bitmap);
+
+// WIC
+
+_WRL_PTR_TYPEDEF(IWICImagingFactory);
+_WRL_PTR_TYPEDEF(IWICBitmapDecoder);
+_WRL_PTR_TYPEDEF(IWICBitmapFrameDecode);
+_WRL_PTR_TYPEDEF(IWICStream);
+_WRL_PTR_TYPEDEF(IWICFormatConverter);
+_WRL_PTR_TYPEDEF(IWICBitmapScaler);
+_WRL_PTR_TYPEDEF(ITaskbarList3);
+
+// DXGI
+
+_WRL_PTR_TYPEDEF(IDXGISwapChain);
+_WRL_PTR_TYPEDEF(IDXGIFactory1);
+_WRL_PTR_TYPEDEF(IDXGIAdapter1);
+_WRL_PTR_TYPEDEF(IDXGIDevice1);
+_WRL_PTR_TYPEDEF(IDXGIKeyedMutex);
+_WRL_PTR_TYPEDEF(IDXGIObject);
+_WRL_PTR_TYPEDEF(IDXGIDeviceSubObject);
+_WRL_PTR_TYPEDEF(IDXGISurface1);
+_WRL_PTR_TYPEDEF(IDXGIOutput);
+//_WRL_PTR_TYPEDEF(IDXGI);
+//_WRL_PTR_TYPEDEF(IDXGI);
+
+// Direct3D
+
+_WRL_PTR_TYPEDEF(ID3D11Device);
+_WRL_PTR_TYPEDEF(ID3D11DeviceContext);
+_WRL_PTR_TYPEDEF(ID3D11RenderTargetView);
+_WRL_PTR_TYPEDEF(ID3D11DepthStencilView);
+_WRL_PTR_TYPEDEF(ID3D11VertexShader);
+_WRL_PTR_TYPEDEF(ID3D11PixelShader);
+_WRL_PTR_TYPEDEF(ID3D11InputLayout);
+_WRL_PTR_TYPEDEF(ID3D11Buffer);
+_WRL_PTR_TYPEDEF(ID3D11Texture2D);
+_WRL_PTR_TYPEDEF(ID3DBlob);
+_WRL_PTR_TYPEDEF(ID3D11ShaderResourceView);
+_WRL_PTR_TYPEDEF(ID3D11SamplerState);
+_WRL_PTR_TYPEDEF(ID3D11Resource);
namespace sf{
-ID2D1BitmapPtr load_bitmap_from_file(
+ /* inline template <class Exc = win32_error_exception> void throw_if_err<>()(HRESULT hr)
+ {
+ if(hr != S_OK){throw Exc(hr);}
+ };*/
+
+
+ ID2D1BitmapPtr load_bitmap_from_file(
ID2D1HwndRenderTargetPtr render_target,
IWICImagingFactoryPtr wic_factory,
- std::wstring uri,
- boost::uint32_t destination_width = 0,
- boost::uint32_t destination_height = 0
+ std::wstring uri,
+ uint32_t destination_width = 0,
+ uint32_t destination_height = 0
);
-/** WNDCLASSEXラッパクラス */
-struct window_class_ex
-{
- window_class_ex(
- const wchar_t* menu_name ,
- const std::wstring& class_name ,
- HINSTANCE hInstance = NULL,
- WNDPROC lpfnWndProc = ::DefWindowProcW,
- boost::uint32_t style = CS_HREDRAW | CS_VREDRAW,
- boost::int32_t cbClsExtra = 0,
- HICON hIcon = ::LoadIcon(NULL,IDI_APPLICATION),
- HCURSOR hCursor = ::LoadCursor(NULL, IDC_ARROW),
- HBRUSH hbrBackground = NULL,
- HICON hIconSm = NULL
- ) : is_register_(false)
- {
-
- if(::GetClassInfoExW(hInstance,class_name.c_str(),&wndclass_) == 0)
- {
- if(::GetLastError() == ERROR_CLASS_DOES_NOT_EXIST)
- {
- ::ZeroMemory(&wndclass_,sizeof(wndclass_));
- wndclass_.lpszMenuName = (LPCWSTR)menu_name;
- wndclass_.lpszClassName = class_name.c_str();
- wndclass_.cbSize = sizeof(::WNDCLASSEXW);
- wndclass_.cbWndExtra = sizeof(LONG_PTR);
- wndclass_.hInstance = hInstance;
- wndclass_.lpfnWndProc = lpfnWndProc;
- wndclass_.style = style;
- wndclass_.cbClsExtra = cbClsExtra;
- wndclass_.hIcon = hIcon;
- wndclass_.hCursor = hCursor;
- wndclass_.hbrBackground = hbrBackground;
- wndclass_.hIconSm = hIconSm;
- atom_ = ::RegisterClassExW(&wndclass_) ;
- BOOST_ASSERT(atom_ != 0);
- is_register_ = true;
- } else {
- throw win32_error_exception();
- }
- } else {
- is_register_ = false;
- }
- };
+ /** WNDCLASSEXラッパクラス */
+ struct window_class_ex
+ {
+ window_class_ex(
+ const wchar_t* menu_name ,
+ const std::wstring& class_name ,
+ HINSTANCE hInstance = NULL,
+ WNDPROC lpfnWndProc = ::DefWindowProcW,
+ uint32_t style = CS_HREDRAW | CS_VREDRAW,
+ int32_t cbClsExtra = 0,
+ int32_t cbWndExtra = sizeof(LONG_PTR),
+ HICON hIcon = ::LoadIcon(NULL,IDI_APPLICATION),
+ HCURSOR hCursor = ::LoadCursor(NULL, IDC_ARROW),
+ HBRUSH hbrBackground = ::CreateSolidBrush(0xff000000),
+ HICON hIconSm = NULL
+ ) : is_register_(false)
+ {
+
+ if(::GetClassInfoExW(hInstance,class_name.c_str(),&wndclass_) == 0)
+ {
+ if(::GetLastError() == ERROR_CLASS_DOES_NOT_EXIST)
+ {
+ ::ZeroMemory(&wndclass_,sizeof(wndclass_));
+ wndclass_.lpszMenuName = (LPCWSTR)menu_name;
+ wndclass_.lpszClassName = class_name.c_str();
+ wndclass_.cbSize = sizeof(::WNDCLASSEXW);
+ wndclass_.cbWndExtra = cbWndExtra;
+ wndclass_.hInstance = hInstance;
+ wndclass_.lpfnWndProc = lpfnWndProc;
+ wndclass_.style = style;
+ wndclass_.cbClsExtra = cbClsExtra;
+ wndclass_.hIcon = hIcon;
+ wndclass_.hCursor = hCursor;
+ wndclass_.hbrBackground = hbrBackground;
+ wndclass_.hIconSm = hIconSm;
+ atom_ = ::RegisterClassExW(&wndclass_) ;
+ BOOST_ASSERT(atom_ != 0);
+ is_register_ = true;
+ } else {
+ throw win32_error_exception();
+ }
+ } else {
+ is_register_ = false;
+ }
+ };
+
+ ~window_class_ex()
+ {
+ if(is_register_){
+ ::UnregisterClassW(wndclass_.lpszClassName,wndclass_.hInstance);
+ }
+ }
+
+ private:
+ bool is_register_;
+ ATOM atom_;
+ ::WNDCLASSEXW wndclass_;
+ };
+
+ struct get_dc {
+ get_dc(HWND hwnd) : hwnd_(hwnd),hdc_(GetDC(hwnd)) {}
+ HDC get(){return hdc_;}
+ ~get_dc(){::ReleaseDC(hwnd_,hdc_);}
+ private:
+ HDC hdc_;
+ HWND hwnd_;
+ };
+
+ struct get_window_dc {
+ get_window_dc(HWND hwnd) : hwnd_(hwnd),hdc_(GetWindowDC(hwnd)) {}
+ HDC get(){return hdc_;}
+ ~get_window_dc(){::ReleaseDC(hwnd_,hdc_);}
+ private:
+ HDC hdc_;
+ HWND hwnd_;
+ };
+
+ struct compatible_dc {
+ compatible_dc(HDC hdc) : hdc_(::CreateCompatibleDC(hdc)){};
+ ~compatible_dc(){::DeleteDC(hdc_);};
+ HDC get() { return hdc_;};
+ private:
+ HDC hdc_;
+ };
+
+ struct ref_dc {
+ ref_dc(HDC& hdc) : hdc_(hdc) {};
+ ~ref_dc(){};
+ HDC get() { return hdc_;};
+ private:
+ HDC& hdc_;
+ };
+
+ struct d2_dc {
+ d2_dc(ID2D1GdiInteropRenderTargetPtr& ptr,D2D1_DC_INITIALIZE_MODE mode) :hdc_(0),ptr_(ptr)
+ {
+ hr_ = ptr->GetDC(mode,&hdc_);
+ };
+ ~d2_dc(){ptr_->ReleaseDC(NULL);};
+ HDC get() { return hdc_;};
+ private:
+ HRESULT hr_;
+ HDC hdc_;
+ ID2D1GdiInteropRenderTargetPtr& ptr_;
+ };
+
+ template <typename Holder>
+ struct device_context
+ {
+ explicit device_context(Holder* holder) : holder_(holder){};
+ ~device_context() {}
+ operator HDC(){return holder_->get();}
+ private:
+ std::unique_ptr<Holder> holder_;
+ };
+
+ //struct handle_holder : boost::noncopyable
+ //{
+ // explicit handle_holder(HANDLE handle) : handle_(handle) {};
+ // ~handle_holder(){if(handle_) ::CloseHandle(handle_);}
+ // operator HANDLE(){return handle_;}
+ //private:
+ // HANDLE handle_;
+ //};
+
+
+ struct HBITMAP_deleter {
+ typedef HBITMAP pointer;
+ void operator ()(HBITMAP handle) {
+ if (handle) {
+ ::DeleteObject(handle);
+ }
+ }
+ };
+
+ //template <typename Handle,typename Handle_Deleter>
+ //struct handle_holder {
+ // typedef boost::unique_ptr<Handle,Handle_Deleter> holder_type;
+ // handle_holder(Handle handle) : holder_(handle) {}
+ // operator Handle(){return holder_->get();}
+ //private:
+ // holder_type holder_;
+ //};
+
+ typedef std::unique_ptr<HBITMAP,HBITMAP_deleter> bitmap_holder;
+
+ typedef device_context<d2_dc> d2_dc_type;
+
+ struct paint_struct
+ {
+ paint_struct(HWND hwnd) : hwnd_(hwnd)
+ {
+ ::BeginPaint(hwnd,&paintstruct_);
+ }
+ ~paint_struct() {::EndPaint(hwnd_,&paintstruct_);}
+ PAINTSTRUCT* operator->(){return &paintstruct_;}
+ private:
+ HWND hwnd_;
+ PAINTSTRUCT paintstruct_;
+ };
+
+ // GDI オブジェクト管理テンプレート
+ template <class GdiObject>
+ struct gdi_object: boost::noncopyable
+ {
+ explicit gdi_object(GdiObject obj) : gdiobj_(obj) {}
+ ~gdi_object(){::DeleteObject(gdiobj_);}
+ operator GdiObject(){return gdiobj_;}
+ private:
+ GdiObject gdiobj_;
+ };
+
+ //
+ struct select_object
+ {
+ select_object(HDC dc,HGDIOBJ o) : dc_(dc),o_(::SelectObject(dc,o)) {}
+ ~select_object(){::SelectObject(dc_,o_);}
+ private:
+ HDC dc_;
+ HGDIOBJ o_;
+ };
+
+ // Direct2D BeginDrawヘルパ関数
+ template <typename T >
+ struct begin_draw
+ {
+ typedef std::function<void(HRESULT hr)> err_handler_type;
+
+ begin_draw(T& render_target,err_handler_type& handler = err_handler_type([](HRESULT hr)->void{throw sf::win32_error_exception(hr);}))
+ : render_target_(render_target) ,
+ handler_(handler)
+ {render_target->BeginDraw();}
+
+ ~begin_draw(){
+ HRESULT hr = S_OK;
+ hr = render_target_->EndDraw();
+ if( hr != S_OK)
+ {
+ handler_(hr);
+ }
+ }
+ private:
+ T& render_target_;
+ err_handler_type handler_;
+ };
+
+ struct mouse
+ {
+ mouse() : x_(0.0f),y_(0.0f),left_button_(false),middle_button_(false),right_button_(false){}
+ private:
+ float x_,y_;
+ bool left_button_,middle_button_,right_button_;
+ };
+
+
+ // ウィンドウプロシージャの識別用クラス
+ struct wndproc
+ {
+ typedef WNDPROC proc_type;
+ typedef LRESULT return_type;
+ static inline return_type def_wnd_proc(HWND hwnd,uint32_t message, WPARAM wParam, LPARAM lParam)
+ {
+ return ::DefWindowProcW(hwnd,message,wParam,lParam);
+ }
+ };
+
+ // ダイアログプロシージャの識別用クラス
+ struct dlgproc
+ {
+ typedef DLGPROC proc_type;
+ typedef INT_PTR return_type;
+ static inline return_type def_wnd_proc(HWND hwnd,uint32_t message, WPARAM wParam, LPARAM lParam)
+ {
+ return FALSE;
+ }
+ };
+
+ /** window ベースクラス */
+ template <typename ProcType = wndproc>
+ struct base_win32_window : public base_window
+ {
+ typedef ProcType proc_t;
+ typedef typename proc_t::return_type result_t;
+// typedef proc_t::return_type result_t;
+
+ operator HWND() const {return hwnd_;};
+
+ virtual void * raw_handle() const {return hwnd_;};
+ // virtual void show(uint32_t show_flag);
+
+ virtual void show() {
+ ::ShowWindow(hwnd_,SW_SHOW);
+ ::GetWindowPlacement(hwnd_,&wp_);
+ }
+
+ // Window を画面から隠す
+ virtual bool is_show() {
+ return ( wp_.showCmd == SW_SHOWMAXIMIZED
+ || wp_.showCmd == SW_SHOWMINIMIZED
+ || wp_.showCmd == SW_SHOWNORMAL );
+ };
+
+ //
+ virtual void hide()
+ {
+ ::ShowWindow(hwnd_,SW_HIDE);
+ ::GetWindowPlacement(hwnd_,&wp_);
+ };
+
+ virtual void text(std::wstring& text)
+ {
+ ::SetWindowTextW(*this,text.c_str());
+ };
+
+ virtual void send_message(uint32_t message,uint32_t wparam,uint32_t lparam )
+ {
+ ::SendNotifyMessage(hwnd_,message,wparam,lparam);
+ }
+
+ virtual void post_message(uint32_t message,uint32_t wparam,uint32_t lparam )
+ {
+ ::PostMessage(hwnd_,message,wparam,lparam);
+ }
+
+ virtual void message_box(const std::wstring& text,const std::wstring& caption,uint32_t type = MB_OK)
+ {
+ ::MessageBox(hwnd_,text.c_str(),caption.c_str(),type);
+ }
+
+ virtual void update();
+
+ virtual void create_device_independent_resources();
+ virtual void create_device();
+ virtual void create_swapchain_dependent_resources();
+
+ virtual void discard_swapchain_dependent_resources();
+ virtual void discard_device();
+ virtual void discard_device_independant_resources();
+
+ protected:
+
+ base_win32_window(
+ const std::wstring& title,
+ const std::wstring& name,bool fit_to_display,
+ float width,float height);
+
+
+ ~base_win32_window();
+
+ void register_class (
+ const wchar_t* menu_name,
+ uint32_t style,
+ int32_t cbClsExtra = 0,
+ int32_t cbWndExtra = sizeof(LONG_PTR),
+ HICON hIcon = ::LoadIcon(NULL,IDI_APPLICATION),
+ HCURSOR hCursor = ::LoadCursor(NULL, IDC_ARROW),
+ HBRUSH hbrBackground = ::CreateSolidBrush(0xff000000),
+ HICON hIconSm = NULL
+ );
+
+ /** デフォルト設定 */
+ void register_class();
+ void create_window(HWND parent = NULL);
+
+ void calc_client_size()
+ {
+ //クライアント領域の現在の幅、高さを求める
+ RECT rc;
+ GetClientRect( hwnd_, &rc );
+ client_width_ = rc.right - rc.left;
+ client_height_ = rc.bottom - rc.top;
+ }
+ public:
+ // SetWindowLong API
+ void set_long(int index,long data)
+ {
+ SetLastError(0);
+ if(::SetWindowLongW(hwnd_,index,data) == 0)
+ {
+ long err = 0;
+ if( (err = GetLastError()) != 0){
+ SetLastError(err);
+ throw sf::win32_error_exception();
+ }
+ };
+ }
+
+ void set_pos(
+ HWND hwnd_insert_after, // 配置順序のハンドル
+ int x, // 横方向の位置
+ int y, // 縦方向の位置
+ int cx, // 幅
+ int cy, // 高さ
+ UINT flags // ウィンドウ位置のオプション
+ )
+ {
+ BOOL res = SetWindowPos(hwnd_,hwnd_insert_after,x,y,cx,cy,flags);
+ if(!res)
+ {
+ throw win32_error_exception();
+ }
+ }
+
+ bool invalidate_rect(bool erase = false,const RECT * rect_ptr = 0)
+ {
+ return ::InvalidateRect(*this,rect_ptr,erase) == TRUE;
+ }
+
+ void enable_control(uint32_t id,bool enable)
+ {
+ ::EnableWindow(GetDlgItem(hwnd_,id),enable?TRUE:FALSE);
+ }
+
+ void enable_control(HWND hwnd,uint32_t id,bool enable)
+ {
+ ::EnableWindow(GetDlgItem(hwnd,id),enable?TRUE:FALSE);
+ };
+
+ virtual result_t window_proc(HWND hwnd,uint32_t message, WPARAM wParam, LPARAM lParam);
+ virtual result_t other_window_proc(HWND hwnd,uint32_t message, WPARAM wParam, LPARAM lParam)
+ {
+ return proc_t::def_wnd_proc(hwnd,message,wParam,lParam);
+ };
+
+ // デフォルトウィンドウメッセージハンドラ
+ virtual result_t on_nccreate(CREATESTRUCT *p) ;//{ return std::is_same<proc_t,wndproc>::value?1:FALSE;}
+ virtual result_t on_create(CREATESTRUCT *p); //{ return std::is_same<proc_t,wndproc>::value?0:FALSE;}
+ virtual result_t on_init_dialog(HWND default_focus_ctrl,LPARAM data) {return TRUE;}
+ virtual result_t on_size(uint32_t flag,uint32_t width,uint32_t height);//{return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ //virtual LRESULT
+ virtual result_t on_paint();
+ virtual result_t on_display_change(uint32_t bpp,uint32_t h_resolution,uint32_t v_resolution) { invalidate_rect();return std::is_same<proc_t,wndproc>::value?0:FALSE;}
+ virtual result_t on_erase_backgroud(HDC dc) {return std::is_same<proc_t,wndproc>::value?1:TRUE;}
+ virtual result_t on_hscroll(uint32_t state,uint32_t position,HWND ctrl_hwnd) {return std::is_same<proc_t,wndproc>::value?0:FALSE;}
+ virtual result_t on_vscroll(uint32_t state,uint32_t position,HWND ctrl_hwnd) {return std::is_same<proc_t,wndproc>::value?0:FALSE;}
+ virtual result_t on_left_mouse_button_down(uint32_t mouse_key,int x,int y ) { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_left_mouse_button_up(uint32_t mouse_key,int x,int y) { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_left_mouse_button_double_click(uint32_t mouse_key,int x,int y) { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_mouse_move(uint32_t mouse_key,int x,int y) {return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_mouse_wheel(uint32_t mouse_key,int delta,int x,int y) { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ //virtual bool on_mouse_enter(uint32_t mouse_key,int x,int y) { return false; }
+ virtual result_t on_mouse_leave() { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_destroy(){
+ //::PostQuitMessage(0);
+ return std::is_same<proc_t,wndproc>::value?0:FALSE;
+ }
+
+ virtual result_t on_close()
+ {
+ discard_device();
+ // Windowの破棄
+ BOOL ret(::DestroyWindow(hwnd_));
+ BOOST_ASSERT(ret != 0);
+// return TRUE;
+ return std::is_same<proc_t,wndproc>::value?1:TRUE;
+ }
+
+ virtual result_t on_set_cursor() { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_key_down(uint32_t vkey,uint32_t ext_key,uint32_t repeat) { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_key_up(uint32_t vkey,uint32_t ext_key,uint32_t repeat) { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_app_command(uint32_t command,uint32_t device,uint32_t keystate) {return std::is_same<proc_t,wndproc>::value?0:FALSE;}
+ virtual result_t on_command(uint32_t wparam, uint32_t lparam) { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_timer(uint32_t timer_id) {
+ //::InvalidateRect(hwnd_,NULL,FALSE);
+ render();
+ return std::is_same<proc_t,wndproc>::value?0:FALSE;
+ }
+ virtual result_t on_notify(NMHDR* nmhdr) { return std::is_same<proc_t,wndproc>::value?0:FALSE; }
+ virtual result_t on_dwm_composition_changed();
+ virtual void render();
+ protected:
+ void get_dxgi_information();
+
+ // Window生成後呼ばれる関数
+ // WM_NCCREATEメッセージの時にthunkに切り替える
+ static result_t CALLBACK start_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+ {
+ if(message == WM_NCCREATE)
+ {
+ LPCREATESTRUCT param = reinterpret_cast<LPCREATESTRUCT>(lParam);
+ base_win32_window* ptr = reinterpret_cast<base_win32_window*>(param->lpCreateParams);
+ ptr->hwnd_ = hwnd;
+ // ウィンドウプロシージャをインスタンスと結び付けるthunkプロシージャに入れ替える
+ LONG_PTR r = SetWindowLongPtr(hwnd,GWLP_WNDPROC,reinterpret_cast<LONG_PTR>(ptr->thunk_proc_));
+ assert(r == reinterpret_cast<LONG_PTR>(&start_wnd_proc));
+ return ptr->window_proc(hwnd,message,wParam,lParam);
+ }
+ return ::DefWindowProcW(hwnd,message,wParam,lParam);
+ };
+
+ static result_t CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+ {
+ base_win32_window* ptr = reinterpret_cast<base_win32_window*>(hwnd);
+ return ptr->window_proc(ptr->hwnd_,message,wParam,lParam);
+ };
+
+ // thisとhwndをつなぐthunkクラス
+ struct hwnd_this_thunk : public Xbyak::CodeGenerator {
+ hwnd_this_thunk(base_win32_window* impl,typename proc_t::proc_type proc)
+ {
+ // rcxにhwndが格納されているので、それをimpl->hwndに保存
+// mov(ptr[&(impl->hwnd_)],rcx); // <-- エラー発生部分
+ mov(rax,(size_t)&impl->hwnd_); // <-- 訂正
+ mov(ptr[rax],rcx); // <-- 訂正
+ // 代わりにthisのアドレスをrcxに格納
+ mov(rcx,(LONG_PTR)impl);
+ // r10にproc(Window プロシージャ)へのアドレスを格納
+ mov(r10,(LONG_PTR)proc);
+ // Window プロシージャへへジャンプ
+ jmp(r10);
+ }
+ };
+
+ void update_window_size()
+ {
+ RECT r;
+ GetWindowRect(hwnd_,&r);
+ width_ = r.right - r.left;
+ height_ = r.bottom - r.top;
+ }
+
+ void init_view_matrix();
+
+ HWND hwnd_;
+ hwnd_this_thunk thunk_;
+ std::wstring title_;
+ std::wstring name_;
+ float width_,height_;
+ bool fit_to_display_;
+ std::shared_ptr<sf::window_class_ex> wnd_class_;
+ typename proc_t::proc_type thunk_proc_;
+ dpi dpi_;
+ WINDOWPLACEMENT wp_;
+ bool init_;
+
+ ID2D1FactoryPtr factory_;
+ ID2D1HwndRenderTargetPtr render_target_;
+ IDWriteFactoryPtr write_factory_;
+ IWICImagingFactoryPtr wic_imaging_factory_;
+ IDWriteTextFormatPtr write_text_format_;
+
+ IDXGIFactory1Ptr dxgi_factory_;
+ IDXGIAdapter1Ptr adapter_;
+ IDXGIOutputPtr output_;
+ ID3D11DevicePtr d3d_device_;
+ ID3D11DeviceContextPtr d3d_context_;
+ ID3D11Texture2DPtr texture_;
+ ID3D11RenderTargetViewPtr view_;
+ ID3D11Texture2DPtr depth_texture_;
+ ID3D11DepthStencilViewPtr depth_view_;
+ ID3D11VertexShaderPtr v_shader_;
+ ID3D11InputLayoutPtr input_layout_;
+ ID3D11PixelShaderPtr p_shader_;
+ ID3D11BufferPtr v_buffer_;
+ ID3D11BufferPtr i_buffer_;
+ ID3D11BufferPtr cb_never_changes_;
+ ID3D11BufferPtr cb_change_on_resize_;
+ ID3D11BufferPtr cb_changes_every_frame_;
+ ID3D11ShaderResourceViewPtr shader_res_view_;
+ ID3D11SamplerStatePtr sampler_state_;
+ ID3D11Texture2DPtr back_buffer_;
+
+ ID3D11SamplerStatePtr cube_sampler_state_;
+ ID3D11Texture2DPtr cube_texture_;
+ ID3D11Texture2DPtr cube_depth_texture_;
+ ID3D11ShaderResourceViewPtr cube_shader_res_view_;
+ ID3D11RenderTargetViewPtr cube_view_;
+ ID3D11DepthStencilViewPtr cube_depth_view_;
+
+ DXGI_MODE_DESC actual_desc_;
+ IDXGISwapChainPtr swap_chain_;
+ std::wstring dxgi_info_;
+
+
- ~window_class_ex()
- {
- if(is_register_){
- ::UnregisterClassW(wndclass_.lpszClassName,wndclass_.hInstance);
- }
- }
-
-private:
- bool is_register_;
- ATOM atom_;
- ::WNDCLASSEXW wndclass_;
-};
-
-
-
-struct get_dc {
- get_dc(HWND hwnd) : hwnd_(hwnd),hdc_(GetDC(hwnd)) {}
- HDC get(){return hdc_;}
- ~get_dc(){::ReleaseDC(hwnd_,hdc_);}
-private:
- HDC hdc_;
- HWND hwnd_;
-};
-
-struct compatible_dc {
- compatible_dc(HDC hdc) : hdc_(::CreateCompatibleDC(hdc)){};
- ~compatible_dc(){::DeleteDC(hdc_);};
- HDC get() { return hdc_;};
-private:
- HDC hdc_;
-};
-
-struct ref_dc {
- ref_dc(HDC& hdc) : hdc_(hdc) {};
- ~ref_dc(){};
- HDC get() { return hdc_;};
-private:
- HDC& hdc_;
-};
-
-struct d2_dc {
- d2_dc(ID2D1GdiInteropRenderTargetPtr& ptr,D2D1_DC_INITIALIZE_MODE mode) :hdc_(0),ptr_(ptr)
+ DirectX::XMMATRIX mat_world_;
+ DirectX::XMMATRIX mat_view_;
+ DirectX::XMMATRIX mat_projection_;
+ DirectX::XMMATRIX cube_mat_projection_;
+
+ DirectX::XMFLOAT4 mesh_color_;
+ float client_width_,client_height_;
+
+ timer timer_;
+
+ // __declspec ( thread ) static std::queue<proc_t::proc_type> ptrs_ ;// thread local storage
+
+ };
+
+ typedef base_win32_window<> base_win32_window_t;
+ typedef base_win32_window<dlgproc> base_win32_dialog_t;
+
+ /// サブクラスウィンドウ
+ struct subclass_window : public base_win32_window_t
+ {
+ subclass_window(HWND hwnd);
+ subclass_window();
+ void attach(HWND hwnd);
+ void detatch();
+ ~subclass_window();
+ virtual result_t window_proc(HWND hwnd,uint32_t message, WPARAM wParam, LPARAM lParam)
+ {
+ return CallWindowProc(proc_backup_,hwnd,message,wParam,lParam);
+ };
+ protected:
+ bool is_subclassed_;
+ WNDPROC proc_backup_;
+ };
+
+ struct av_mm_thread_characteristics
{
- hr_ = ptr->GetDC(mode,&hdc_);
+ av_mm_thread_characteristics(std::wstring& str) : task_name_(str)
+ {
+ handle_ = ::AvSetMmThreadCharacteristicsW(str.c_str(),(LPDWORD)&task_index_);
+ }
+
+ bool set_priority(AVRT_PRIORITY p){return (::AvSetMmThreadPriority(handle_,p) == TRUE);}
+
+ ~av_mm_thread_characteristics()
+ {
+ ::AvRevertMmThreadCharacteristics(handle_);
+ }
+
+ private:
+ std::wstring task_name_;
+ uint32_t task_index_;
+ HANDLE handle_;
};
- ~d2_dc(){ptr_->ReleaseDC(NULL);};
- HDC get() { return hdc_;};
-private:
- HRESULT hr_;
- HDC hdc_;
- ID2D1GdiInteropRenderTargetPtr& ptr_;
-};
-
-template <typename Holder>
-struct device_context
-{
- explicit device_context(Holder* holder) : holder_(holder){};
- ~device_context() {}
- operator HDC(){return holder_->get();}
-private:
- boost::scoped_ptr<Holder> holder_;
-};
-
-typedef device_context<d2_dc> d2_dc_type;
-
-struct paint_struct
-{
- paint_struct(HWND hwnd) : hwnd_(hwnd)
- {
- ::BeginPaint(hwnd,&paintstruct_);
- }
- ~paint_struct() {::EndPaint(hwnd_,&paintstruct_);}
- PAINTSTRUCT* operator->(){return &paintstruct_;}
-private:
- HWND hwnd_;
- PAINTSTRUCT paintstruct_;
-};
-
-template <typename T>
-struct begin_draw
-{
- begin_draw(T& render_target) : render_target_(render_target) ,is_end_(false) {render_target->BeginDraw();}
- HRESULT end_draw()
- {
- HRESULT hr = S_OK;
- if(!is_end_) {
- hr = render_target_->EndDraw();
- is_end_ = true;
- }
-
- return hr;
- };
- ~begin_draw(){ if(!is_end_) { render_target_->EndDraw();}}
-private:
- T& render_target_;
- bool is_end_;
-};
-
-struct mouse
-{
- mouse() : x_(0.0f),y_(0.0f),left_button_(false),middle_button_(false),right_button_(false){}
-private:
- float x_,y_;
- bool left_button_,middle_button_,right_button_;
-};
-
-/** window ベースクラス */
-struct base_window
-{
- typedef boost::signals2::signal<LRESULT (HWND,boost::uint32_t,WPARAM, LPARAM) > on_message_type;
- on_message_type on_message;
- typedef boost::signals2::signal<void ()> on_render_type;
- on_render_type on_render;
- operator HWND();
-protected:
- base_window(
- const std::wstring& title,
- const std::wstring& name,bool fit_to_display,
- float width,float height);
- ~base_window();
- void register_class (
- wchar_t* menu_name,
- boost::uint32_t style,
- boost::int32_t cbClsExtra = 0,
- HICON hIcon = ::LoadIcon(NULL,IDI_APPLICATION),
- HCURSOR hCursor = ::LoadCursor(NULL, IDC_ARROW),
- HBRUSH hbrBackground = NULL,
- HICON hIconSm = NULL
- );
-
- /** デフォルト設定 */
- void register_class();
- void create_window();
- void update();
- void show(boost::uint32_t show_flag);
- virtual void discard_device();
- virtual void create_device();
- virtual void create_device_independent_resources();
- //ID2D1FactoryPtr factory();
- //ID2D1HwndRenderTargetPtr render_target();
- //IDWriteFactoryPtr write_factory();
-
- virtual LRESULT window_proc(HWND hwnd,boost::uint32_t message, WPARAM wParam, LPARAM lParam);
-protected:
- static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
- {
- base_window* ptr = reinterpret_cast<base_window*>(hwnd);
- hwnd = ptr->hwnd_;
- return ptr->window_proc(hwnd,message,wParam,lParam);
- };
-
- struct hwnd_this_thunk : public Xbyak::CodeGenerator {
- hwnd_this_thunk(base_window* impl,WNDPROC proc)
- {
- push(eax);
- mov(eax,ptr[esp + 8]);
- mov(ptr[&(impl->hwnd_)],eax);
- mov(eax,(DWORD)impl);
- mov(ptr[esp + 8],eax);
- pop(eax);
- jmp(proc);
- }
- };
-
- //ID3D11DevicePtr d3d_device_;
- //D3D_DRIVER_TYPE driver_type_;
- //D3D_FEATURE_LEVEL feature_level_;
- //IDXGISwapChainPtr swap_chain_;
- //ID3D11DeviceContextPtr device_context_;
- //ID3D11RenderTargetViewPtr render_target_view_;
- //ID3DX11EffectPtr effect_;
- //ID3DX11EffectTechnique* technique_;
- //ID3D11InputLayoutPtr vertex_layout_;
- //ID3D11BufferPtr vertex_buffer_;
- //ID3D11BufferPtr index_buffer_;
- //ID3D11ShaderResourceViewPtr texture_rv_;
- //ID3D11ShaderResourceViewPtr sprite_tex_;
- //ID3DX11EffectMatrixVariable* world_variable_;
- //ID3DX11EffectMatrixVariable* view_variable_;
- //ID3DX11EffectMatrixVariable* projection_variable_;
- //ID3DX11EffectVectorVariable* mesh_color_variable_;
- //ID3DX11EffectShaderResourceVariable* diffuse_variable_;
- //D3DXMATRIX world_;
- //D3DXMATRIX view_;
- //D3DXMATRIX projection_;
- //D3DXVECTOR4 mesh_color_;
- //ID3DX10SpritePtr sprite_;
- //D3DX10_SPRITE sprite_buffer_[1];
- //ID3D11BlendStatePtr sprite_blend_state_;
-
- HWND hwnd_;
- ID2D1FactoryPtr factory_;
-// ID2D1DCRenderTargetPtr render_target_;
- ID2D1HwndRenderTargetPtr render_target_;
- IDWriteFactoryPtr write_factory_;
- IWICImagingFactoryPtr wic_imaging_factory_;
- //ID2D1BitmapPtr bitmap_;
- hwnd_this_thunk thunk_;
- std::wstring title_;
- std::wstring name_;
- float width_,height_;
- bool fit_to_display_;
- boost::shared_ptr<sf::window_class_ex> wnd_class_;
- WNDPROC thunk_proc_;
-// boost::shared_ptr<input> input_;
-};
-
-//struct toplevel_window;
-//typedef boost::shared_ptr<toplevel_window> toplevel_window_ptr;
-//
-///** toplevel_window を生成する関数 */
-//toplevel_window_ptr create_toplevel_window (
-// const std::wstring& menu_name,
-// const std::wstring& name,
-// const boost::uint32_t show_flag = SW_SHOWNORMAL,
-// bool fit_to_display = false,
-// float width = 640,
-// float height = 480
-//);
-//
-//
-//
-///** toplevel ウィンドウクラス */
-///* このクラスは、create_toplevel_window 関数からのみ生成可能 */
-//struct toplevel_window : public base_window
-//{
-// friend toplevel_window_ptr create_toplevel_window
-// (
-// const std::wstring& menu_name,
-// const std::wstring& name,
-// const boost::uint32_t show_flag,
-// bool fit_to_display ,
-// float width ,
-// float height
-// );
-// void main_loop();
-//protected:
-// void render();
-// toplevel_window(const std::wstring& menu_name,const std::wstring& name,bool fit_to_display,float width = 640,float height = 480) : base_window(menu_name,name,fit_to_display,width,height)
-// {
-// on_render.connect(boost::bind(&toplevel_window::render,this));
-// };
-// LRESULT toplevel_window::window_proc(HWND hwnd,boost::uint32_t message, WPARAM wParam, LPARAM lParam);
-//};
-
-struct av_mm_thread_characteristics
-{
- av_mm_thread_characteristics(std::wstring& str) : task_name_(str)
- {
- handle_ = ::AvSetMmThreadCharacteristicsW(str.c_str(),(LPDWORD)&task_index_);
- }
-
- bool set_priority(AVRT_PRIORITY p){return (::AvSetMmThreadPriority(handle_,p) == TRUE);}
-
- ~av_mm_thread_characteristics()
- {
- ::AvRevertMmThreadCharacteristics(handle_);
- }
-
-private:
- std::wstring task_name_;
- boost::uint32_t task_index_;
- HANDLE handle_;
-};
-
-struct widget
-{
- void draw();
- float x_,y_;
-};
-
-typedef sf::begin_draw<ID2D1BitmapRenderTargetPtr> begin_draw_bitmap;
-typedef sf::begin_draw<ID2D1HwndRenderTargetPtr> begin_draw_hwnd;
+
+ struct widget
+ {
+ void draw();
+ float x_,y_;
+ };
+
+ typedef sf::begin_draw<ID2D1BitmapRenderTargetPtr> begin_draw_bitmap;
+ typedef sf::begin_draw<ID2D1HwndRenderTargetPtr> begin_draw_hwnd;
}
\ No newline at end of file
// stdafx.obj にはプリコンパイル型情報が含まれます。\r
\r
#include "stdafx.h"\r
-\r
// TODO: このファイルではなく、STDAFX.H で必要な\r
// 追加ヘッダーを参照してください。\r
+#pragma comment(lib, "winmm.lib")\r
+#pragma comment(lib, "Avrt.lib")\r
+#pragma comment(lib, "Mmdevapi.lib")\r
+\r
// を記述します。\r
//\r
\r
-#pragma once\r
-\r
\r
#pragma once\r
#include <SDKDDKVer.h>\r
\r
\r
// TODO: プログラムに必要な追加ヘッダーをここで参照してください。\r
-//#include "code_converter.h"\r
-//#include "logger.h"\r
-//#include "dout.h"\r
+#include "code_converter.h"\r
+#include "logger.h"\r
+#include "dout.h"\r
//#include "dxerr.h"\r
#include <wrl.h>\r
#using <windows.winmd>\r
\r
//_WRL_PTR_TYPEDEF();\r
//_WRL_PTR_TYPEDEF();\r
-\r
-/*\r
-#ifndef UNICODE\r
-#define UNICODE\r
-#endif\r
-// STL\r
-#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers\r
-//\r
-// Modify the following defines if you have to target a platform prior to the ones specified below.\r
-// Refer to MSDN for the latest info on corresponding values for different platforms.\r
-#ifndef WINVER // Allow use of features specific to Windows 7 or later.\r
-#define WINVER 0x0800 // Change this to the appropriate value to target other versions of Windows.\r
-#endif\r
-\r
-#define DIRECTINPUT_VERSION 0x0800\r
-#include <tchar.h>\r
-#include <iostream>\r
-#include <fstream>\r
-#include <exception>\r
-#include <memory>\r
-#include <string>\r
-#include <map>\r
-#include <locale>\r
-#include <fstream>\r
-#include <algorithm>\r
-#include <functional>\r
-\r
-#include "sf_com.h"\r
-#include "dinput.h"\r
-#include <wincodec.h>\r
-#include <windows.h>\r
-#include <windowsx.h>\r
-#include <wincodec.h>\r
-#include <wincodecsdk.h>\r
-\r
-#include <comdef.h>\r
-#include "avrt.h"\r
-#include "mmsystem.h"\r
-#include <d2d1.h>\r
-#include <d2d1helper.h>\r
-#include <dwrite.h>\r
-#include "dwmapi.h" \r
-//#include <wincodec.h>\r
-//#include <wincodecsdk.h>\r
-//#include <d3dx11effect.h>\r
-//#include <d3dxGlobal.h>\r
-//#include "exception.h"\r
-//#include "singleton.h"\r
-//#include "code_converter.h"\r
-//#include "logger.h"\r
-\r
-\r
-// Boost\r
-//#include <boost/archive/xml_woarchive.hpp>\r
-//#include <boost/archive/xml_wiarchive.hpp>\r
-//#include <boost/archive/text_woarchive.hpp>\r
-//#include <boost/archive/text_wiarchive.hpp>\r
-//#include <boost/archive/text_oarchive.hpp>\r
-//#include <boost/archive/text_iarchive.hpp>\r
-//#include <boost/archive/binary_woarchive.hpp>\r
-//#include <boost/archive/binary_wiarchive.hpp>\r
-//#include <boost/archive/binary_oarchive.hpp>\r
-//#include <boost/archive/binary_iarchive.hpp>\r
-\r
-//#include <boost/serialization/export.hpp>\r
-//#include <boost/serialization/is_abstract.hpp>\r
-//#include <boost/serialization/version.hpp>\r
-//#include <boost/serialization/serialization.hpp>\r
-//#include <boost/serialization/split_member.hpp>\r
-//#include <boost/serialization/string.hpp>\r
-//#include <boost/serialization/shared_ptr.hpp>\r
-//#include <boost/serialization/vector.hpp>\r
-//#include <boost/serialization/nvp.hpp>\r
-//#include <boost/serialization/void_cast.hpp>\r
-#include <boost/scoped_ptr.hpp> \r
-#include <boost/scoped_array.hpp> \r
-#include <boost/shared_ptr.hpp> \r
-#include <boost/shared_array.hpp> \r
-#include <boost/intrusive_ptr.hpp>\r
-#include <boost/format.hpp>\r
-#include <boost/lexical_cast.hpp>\r
-#include <boost/array.hpp>\r
-#include <boost/thread.hpp>\r
-#include <boost/optional.hpp>\r
-#include <boost/bind.hpp>\r
-#include <boost/function.hpp>\r
-#include <boost/variant.hpp>\r
-#include <boost/any.hpp>\r
-#include <boost/signals2.hpp>\r
-#include <boost/tuple/tuple.hpp>\r
-#include <boost/ptr_container/ptr_container.hpp>\r
-#include <boost/thread/condition.hpp>\r
-//#include <boost/serialization/ptr_vector.hpp>\r
-#include <boost/ptr_container/ptr_array.hpp>\r
-#include <boost/ptr_container/serialize_ptr_container.hpp>\r
-//#include "serialization.h"\r
-#include <boost/filesystem/path.hpp>\r
-#include <boost/filesystem/operations.hpp>\r
-#include <boost/filesystem/convenience.hpp>\r
-\r
-// TODO: プログラムに必要な追加ヘッダーをここで参照してください。\r
-*/
\ No newline at end of file
#define IDT_STED2_WAIT_TIMER 1
-class CSTedScreenWin32 : public CSTedScreenBase,public sf::base_window
+class CSTedScreenWin32 : public CSTedScreenBase,public sf::base_win32_window<>
{
public:
typedef boost::shared_ptr<CSTedScreenWin32> ptr_type;
return instance_;
}
+ virtual void create();
+
+
//static CSTedScreenWin32* New(int in_screensize=14);
~CSTedScreenWin32();
void Tidy(void);
};
-#define THROW_IF_ERR(hres) \
- if (FAILED(hres)) { throw sf::win32_error_exception(hres); }
-
#endif /* STED_SCREEN_H */
--- /dev/null
+#include "StdAfx.h"
+
+#if _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
+#endif
+
+#include "sf_windows.h"
+#include "taskbar.h"
+
+
+namespace sf {
+
+const int taskbar::none = TBPF_NOPROGRESS;
+const int taskbar::indeterminate = TBPF_INDETERMINATE;
+const int taskbar::normal = TBPF_NORMAL;
+const int taskbar::error = TBPF_ERROR;
+const int taskbar::paused = TBPF_PAUSED;
+
+long taskbar::register_message()
+{
+ return ::RegisterWindowMessage(L"TaskbarButtonCreated");
+}
+
+struct taskbar::impl
+{
+ typedef throw_if_err<sf::taskbar::exception> throw_if_err_;
+
+ impl(){}
+ ~impl()
+ {
+ discard();
+ }
+
+ void create() {
+ throw_if_err_()(CoCreateInstance(CLSID_TaskbarList,nullptr,CLSCTX::CLSCTX_INPROC_SERVER,__uuidof(ITaskbarList4),(LPVOID*)taskbar_.GetAddressOf()));
+ }
+ bool is_create() const
+ {
+ return (taskbar_ != 0);
+ }
+ void discard()
+ {
+ safe_release(taskbar_);
+ }
+
+ void overlay_icon(const sf::base_window& w,const sf::icon& ic,const std::wstring& description)
+ {
+ throw_if_err_()(taskbar_->SetOverlayIcon(reinterpret_cast<HWND>(w.raw_handle()),ic.get(),description.c_str()));
+ }
+
+ void progress_state(const sf::base_window& w,TBPFLAG state)
+ {
+ throw_if_err_()(taskbar_->SetProgressState(reinterpret_cast<HWND>(w.raw_handle()),state));
+ }
+
+ void progress_value(const sf::base_window& w,boost::uint64_t completed, boost::uint64_t total)
+ {
+ throw_if_err_()(taskbar_->SetProgressValue(reinterpret_cast<HWND>(w.raw_handle()),completed,total));
+ }
+
+ void add_thumb_buttons(const sf::base_window& w,const std::vector<THUMBBUTTON>& tbs){
+ taskbar_->ThumbBarAddButtons(reinterpret_cast<HWND>(w.raw_handle()),tbs.size(),const_cast<LPTHUMBBUTTON>(&(tbs[0])));
+ };
+
+ void update_thumb_buttons(const sf::base_window& w,const std::vector<THUMBBUTTON>& tbs){
+ taskbar_->ThumbBarUpdateButtons(reinterpret_cast<HWND>(w.raw_handle()),tbs.size(),const_cast<LPTHUMBBUTTON>(&(tbs[0])));
+ };
+
+private:
+ _WRL_PTR_TYPEDEF(ITaskbarList4);
+ ITaskbarList4Ptr taskbar_;
+};
+
+
+taskbar::taskbar() : impl_(new sf::taskbar::impl()) {}
+taskbar::~taskbar() { discard();};
+
+void taskbar::create(){impl_->create();};
+bool taskbar::is_create() const {return impl_->is_create();};
+void taskbar::discard(){impl_->discard();};
+void taskbar::overlay_icon(const sf::base_window& w,const icon& ic,const std::wstring& description){impl_->overlay_icon(w,ic,description);};
+void taskbar::progress_state(const sf::base_window& w,int state){impl_->progress_state(w,(TBPFLAG)state);};
+void taskbar::progress_value(const sf::base_window& w,boost::uint64_t completed, boost::uint64_t total){impl_->progress_value(w,completed,total);};
+void taskbar::add_thumb_buttons(const sf::base_window& w,const thumb_button_manager& tm){
+ BOOST_ASSERT(!tm.is_added);
+ impl_->add_thumb_buttons(w,tm.thumbbuttons_);
+ tm.is_added = true;
+};
+void taskbar::update_thumb_buttons(const sf::base_window& w,const thumb_button_manager& tm){
+ BOOST_ASSERT(tm.is_added);
+ if(tm.is_added){
+ impl_->update_thumb_buttons(w,tm.thumbbuttons_);
+ }
+};
+
+}
\ No newline at end of file
--- /dev/null
+#pragma once
+
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-10 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+
+#include "exception.h"
+#include "icon.h"
+
+namespace sf
+{
+
+ ///** インターフェース */
+ //struct thumb_button : boost::noncopyable
+ //{
+ // typedef std::shared_ptr<thumb_button> ptr;
+ // static ptr create_thumb_button();
+ // virtual void show() = 0;
+ // virtual void hide() = 0;
+ // virtual void enable() = 0;
+ // virtual void disable() = 0;
+ //private:
+ // thumb_button();
+ //};
+
+ struct taskbar;
+
+ /** サムネイルボタン管理 */
+ struct thumb_button_manager
+ {
+ friend struct taskbar;
+ // Thumb Buttonは最大7個まで
+ static const int THUMB_BUTTON_MAX = 7;
+
+ // THUMBBUTTON構造体操作クラス
+ struct thumb_button {
+
+ // コンストラクタ
+ thumb_button(uint32_t id ,const icon& i,const std::wstring& tool_tip,THUMBBUTTON& t) : thumb_(t)
+ {
+ BOOST_ASSERT(tool_tip.size() < 259);
+ memset(&thumb_,0,sizeof(THUMBBUTTON));
+ thumb_.dwMask = THB_ICON | THB_TOOLTIP | THB_FLAGS;
+ thumb_.hIcon = i.get();
+ thumb_.iId = id;
+ std::copy(tool_tip.begin(),tool_tip.end(),thumb_.szTip);
+ //thumb_.szTip = const_cast<wchar_t*>(tool_tip_.c_str());
+ }
+
+ // 今回はプロパティ・チェイニングなアクセス方法にしてみた。
+ /** アイコン */
+ thumb_button& set_icon(icon& ic) {thumb_.hIcon = ic.get(); return *this;};
+ /** IDのセット */
+ thumb_button& id(uint32_t v) {thumb_.iId = v; return *this;}
+ /** ツールチップ */
+ thumb_button& tool_tip(const std::wstring& v) {
+ BOOST_ASSERT(v.size() < 259);
+ std::copy(v.begin(),v.end(),thumb_.szTip);
+ thumb_.szTip[v.size()] = L'\0';
+ return *this;
+ }
+ /** 有効化・無効化 */
+ thumb_button& enable(bool v){v?(thumb_.dwFlags &= ~THBF_ENABLED):(thumb_.dwFlags |= THBF_DISABLED); return *this;}
+ /** クリックされたらサムネイルを閉じるか */
+ thumb_button& dismission_click(bool v){ v?(thumb_.dwFlags |= THBF_DISMISSONCLICK):(thumb_.dwFlags &= ~THBF_DISMISSONCLICK); return *this;}
+ /** ボタンの外枠を描画するかどうか */
+ thumb_button& no_background(bool v){v?(thumb_.dwFlags |= THBF_NOBACKGROUND):(thumb_.dwFlags &= ~THBF_NOBACKGROUND);return *this;}
+ /** 隠すか・表示するか */
+ thumb_button& hidden(bool v){v?(thumb_.dwFlags |= THBF_HIDDEN):(thumb_.dwFlags &= ~ THBF_HIDDEN);return *this;}
+ /** ボタンアクションを起こすかどうか。ボタンを通知目的で使用する際に用いる。*/
+ thumb_button& no_interacive(bool v){v?(thumb_.dwFlags |= THBF_NONINTERACTIVE):(thumb_.dwFlags &= ~THBF_NONINTERACTIVE);return *this;}
+
+ private:
+ THUMBBUTTON& thumb_;
+ };
+
+ thumb_button_manager() : is_added(false) {}
+
+ // Thumb Buttonは7個までに制限されている
+ thumb_button& add_thumb_button(uint32_t id,const icon& i,const std::wstring& str)
+ {
+ // 事前条件
+ BOOST_ASSERT(thumb_buttons_.size() < 7 && is_added == false);
+ if(!is_added){
+ thumbbuttons_.push_back(THUMBBUTTON());
+ thumb_buttons_.push_back(thumb_button(id,i,str, (thumbbuttons_.at(thumbbuttons_.size() - 1))));
+ }
+ return thumb_buttons_.at(thumb_buttons_.size() - 1);
+ }
+
+ thumb_button& at(uint32_t i){
+ BOOST_ASSERT(i < thumb_buttons_.size());
+ return thumb_buttons_.at(i);
+ }
+
+ size_t size() const {return thumb_buttons_.size();}
+ private:
+ mutable bool is_added;
+ // メモリ配列を合わせるためにこうした。
+ std::vector<THUMBBUTTON> thumbbuttons_;
+ std::vector<thumb_button> thumb_buttons_;
+ //typedef boost::ptr_vector<thumb_button> thumb_buttons;
+ };
+
+ /** タスクバーAPIのラップクラス。本来であればインターフェースにする方が良いかもしれないけれど */
+ struct taskbar : boost::noncopyable
+ {
+ struct exception
+ : public sf::win32_error_exception
+ {
+ exception(uint32_t hr) : win32_error_exception(hr) {};
+ exception() : win32_error_exception() {} ;
+ };
+
+ taskbar();
+ ~taskbar();
+ void create();
+ void discard();
+ void overlay_icon(const sf::base_window& w,const icon& ic,const std::wstring& description);
+ void progress_state(const sf::base_window& w,int state);
+ void progress_value(const sf::base_window& w,boost::uint64_t completed, boost::uint64_t total);
+
+ void add_thumb_buttons(const sf::base_window& w,const thumb_button_manager& tm);
+ void update_thumb_buttons(const sf::base_window& w,const thumb_button_manager& tm);
+ bool is_create() const;
+
+ static long register_message();
+
+ static const int none;
+ static const int indeterminate;
+ static const int normal;
+ static const int error;
+ static const int paused;
+
+ private:
+ struct impl;
+ std::shared_ptr<impl> impl_;
+ friend struct impl;
+ };
+
+}
+
--- /dev/null
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-11 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+
+#include "StdAfx.h"
+
+#if _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
+#endif
+
+#include "sf_windows.h"
+#include "timer.h"
+
+namespace sf {
+timer::timer(sf::base_window& window,uint32_t timeout) : window_(window),timeout_(timeout),timer_id_(0)
+{
+
+}
+void timer::start(){
+ if(!::SetTimer(reinterpret_cast<HWND>(window_.raw_handle()),(UINT_PTR)&timer_id_,timeout_,NULL)){
+ throw timer::exception();
+ };
+};
+
+void timer::player_stop()
+{
+ if(timer_id_)
+ {
+ ::KillTimer(reinterpret_cast<HWND>(window_.raw_handle()),(UINT_PTR)&timer_id_);
+ timer_id_ = 0;
+ }
+};
+
+}
--- /dev/null
+/*
+ ==============================================================================
+
+ This file is part of the async
+ Copyright 2005-11 by Satoshi Fujiwara.
+
+ async can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ async is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with async; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ==============================================================================
+*/
+#pragma once
+#include "base_window.h"
+namespace sf{
+struct timer
+{
+ struct exception
+ : public sf::win32_error_exception
+ {
+ exception(uint32_t hr) : win32_error_exception(hr) {};
+ exception() : win32_error_exception() {} ;
+ };
+
+ timer(sf::base_window& window,uint32_t timeout);
+ void start();
+ void player_stop();
+ ~timer(){player_stop();};
+private:
+ sf::base_window& window_;
+ uint32_t timer_id_;
+ uint32_t timeout_;
+};
+}
+
if (in_page != 0)
{
- text_bitmap_target_->DrawRectangle(r1,color_brush);
+ text_bitmap_target_->DrawRectangle(r1,color_brush.Get());
//br = ::CreateSolidBrush(c);
//mbr = MASK_ON;
} else {
- text_bitmap_target_->DrawRectangle(r1,brush_text_clear_);
+ text_bitmap_target_->DrawRectangle(r1,brush_text_clear_.Get());
//br = fBrushTextClear;
//mbr = MASK_OFF;
}
text_bitmap_target_->SetAntialiasMode(backup);
- THROW_IF_ERR(b.end_draw());
}
// if (!br) return;
D2D1_ANTIALIAS_MODE backup(text_bitmap_target_->GetAntialiasMode());
text_bitmap_target_->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
- text_bitmap_target_->DrawLine(D2D1::Point2F(x0,y),D2D1::Point2F(x1,y),brush);
+ text_bitmap_target_->DrawLine(D2D1::Point2F(x0,y),D2D1::Point2F(x1,y),brush.Get());
text_bitmap_target_->SetAntialiasMode(backup);
//if (in_linestyle != 0 /*&& in_page!=0*/)
//::SelectObject(fTextMaskDC, morig);
//if (p) ::DeleteObject(p);
//if (mp) ::DeleteObject(mp);
- THROW_IF_ERR(begin.end_draw());
+ //THROW_IF_ERR(begin.end_draw());
InvalidateRect(x0,y,x1-x0,1);
}
if (!toWindowPos(in_x, in_y+in_h, &x, &y1)) return;
ID2D1SolidColorBrushPtr brush;
- sf::begin_draw_bitmap begin(text_bitmap_target_);
+ {
+ sf::begin_draw_bitmap begin(text_bitmap_target_);
- if (in_linestyle != 0 /*&& in_page!=0*/) {
- text_bitmap_target_->CreateSolidColorBrush(D2D1::ColorF(PageToColor(in_page)),&brush);
- } else {
- text_bitmap_target_->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::White),&brush);
+ if (in_linestyle != 0 /*&& in_page!=0*/) {
+ text_bitmap_target_->CreateSolidColorBrush(D2D1::ColorF(PageToColor(in_page)),&brush);
+ } else {
+ text_bitmap_target_->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::White),&brush);
+ }
+ D2D1_ANTIALIAS_MODE backup(text_bitmap_target_->GetAntialiasMode());
+ text_bitmap_target_->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
+ text_bitmap_target_->DrawLine(D2D1::Point2F(x,y0),D2D1::Point2F(x,y1),brush.Get());
+ text_bitmap_target_->SetAntialiasMode(backup);
}
- D2D1_ANTIALIAS_MODE backup(text_bitmap_target_->GetAntialiasMode());
- text_bitmap_target_->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
- text_bitmap_target_->DrawLine(D2D1::Point2F(x,y0),D2D1::Point2F(x,y1),brush);
- text_bitmap_target_->SetAntialiasMode(backup);
- THROW_IF_ERR(begin.end_draw());
+ //THROW_IF_ERR(begin.end_draw());
//if (in_linestyle!=0 /*&& in_page!=0*/) {
// p = ::CreatePen(PS_SOLID, 1, PageToColor(in_page));
::SetTextColor(dc,c);
::SetBkColor(dc,b);
}
- THROW_IF_ERR(begin.end_draw());
}
InvalidateRect(x,y,w,h);
}
::SetTextColor(dc, c);
::SetBkColor(dc, b);
}
- THROW_IF_ERR(begin.end_draw());
}
/*
text_bitmap_target_->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
if (in_page != 0)
{
- text_bitmap_target_->FillRectangle(r1,color_brush);
+ text_bitmap_target_->FillRectangle(r1,color_brush.Get());
//br = ::CreateSolidBrush(c);
//mbr = MASK_ON;
} else {
//mbr = MASK_OFF;
}
text_bitmap_target_->SetAntialiasMode(backup);
- THROW_IF_ERR(b.end_draw());
}
// if (in_linestyle!=0 && in_page!=0) {
// c = PageToColor(in_page);
D2D1_ANTIALIAS_MODE backup(text_bitmap_target_->GetAntialiasMode());
text_bitmap_target_->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
- text_bitmap_target_->FillRectangle(D2D1::RectF(sx,sy,sx+lx,dy),brush_text_clear_);
+ text_bitmap_target_->FillRectangle(D2D1::RectF(sx,sy,sx+lx,dy),brush_text_clear_.Get());
// ::FillRect(dc, &r, fBrushTextClear);
// ::FillRect(fTextMaskDC, &r, MASK_OFF);
text_bitmap_target_->SetAntialiasMode(backup);
}
}
}
- THROW_IF_ERR(begin.end_draw());
}
void
if (!TextToWindowPos(in_xs, in_ys, &w, &d)) return;
if (!toWindowPos(in_xs, in_ys, &d, &h)) return;
- sf::begin_draw_bitmap begin(text_bitmap_target_);
{
+ sf::begin_draw_bitmap begin(text_bitmap_target_);
sf::d2_dc_type dc(new sf::d2_dc(text_dc_target_,D2D1_DC_INITIALIZE_MODE_COPY));
::BitBlt(dc, x1,y1,w,h, dc, x0, y0, SRCCOPY);
}
- THROW_IF_ERR(begin.end_draw());
// ::BitBlt(fTextDC, x1, y1, w, h, fTextDC, x0, y0, SRCCOPY);
// ::BitBlt(fTextMaskDC, x1, y1, w, h, fTextMaskDC, x0, y0, SRCCOPY);
if (sx==ex || sy==ey) {
// pen = ::CreatePen(PS_SOLID, 1, c);
- graphics_bitmap_target_[d]->DrawLine(D2D1::Point2F(sx,sy),D2D1::Point2F(ex,ey),brush);
+ graphics_bitmap_target_[d]->DrawLine(D2D1::Point2F(sx,sy),D2D1::Point2F(ex,ey),brush.Get());
//if (pen) {
//::DeleteObject(pen);
/*}*/
} else {
- graphics_bitmap_target_[d]->DrawRectangle(D2D1::RectF(sx,sy,ex,ey),brush);
+ graphics_bitmap_target_[d]->DrawRectangle(D2D1::RectF(sx,sy,ex,ey),brush.Get());
//br = ::CreateSolidBrush(c);
// if (br) {
////::FrameRect(fGraphicsWindowDC[d], &r, br);
}
graphics_bitmap_target_[d]->SetAntialiasMode(backup);
// エラーチェック
- THROW_IF_ERR(begin.end_draw());
::SetRect(&r, sx, sy, ex, ey);
InvalidateRect(&r);
}
sf::begin_draw_bitmap begin(graphics_bitmap_target_[d]);
D2D1_ANTIALIAS_MODE backup(graphics_bitmap_target_[d]->GetAntialiasMode());
graphics_bitmap_target_[d]->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
- graphics_bitmap_target_[d]->DrawLine(D2D1::Point2F(sx,sy),D2D1::Point2F(ex,ey),brush);
+ graphics_bitmap_target_[d]->DrawLine(D2D1::Point2F(sx,sy),D2D1::Point2F(ex,ey),brush.Get());
graphics_bitmap_target_[d]->SetAntialiasMode(backup);
// エラーチェック
- THROW_IF_ERR(begin.end_draw());
}
//pen = ::CreatePen(PS_SOLID, 1, c);
//if (pen) {
graphics_bitmap_target_[d]->CreateSolidColorBrush(D2D1::ColorF(c),&brush);
- sf::begin_draw_bitmap begin(graphics_bitmap_target_[d]);
- D2D1_ANTIALIAS_MODE backup(graphics_bitmap_target_[d]->GetAntialiasMode());
- graphics_bitmap_target_[d]->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
- graphics_bitmap_target_[d]->FillRectangle(D2D1::RectF(sx,sy,ex,ey),brush);
- graphics_bitmap_target_[d]->SetAntialiasMode(backup);
- THROW_IF_ERR(begin.end_draw());
-
+ {
+ sf::begin_draw_bitmap begin(graphics_bitmap_target_[d]);
+ D2D1_ANTIALIAS_MODE backup(graphics_bitmap_target_[d]->GetAntialiasMode());
+ graphics_bitmap_target_[d]->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
+ graphics_bitmap_target_[d]->FillRectangle(D2D1::RectF(sx,sy,ex,ey),brush.Get());
+ graphics_bitmap_target_[d]->SetAntialiasMode(backup);
+ }
// br = ::CreateSolidBrush(c);
// if (br) {
// ::FillRect(fGraphicsWindowDC[d], &r, br);
::SetRect(&r, 0, 0, fWindowWidth, fWindowHeight);
sf::begin_draw_bitmap begin(text_bitmap_target_);
text_bitmap_target_->Clear(D2D1::ColorF(0,0));
- THROW_IF_ERR(begin.end_draw());
// ::FillRect(fTextDC, &r, fBrushTextClear);
// ::FillRect(fTextMaskDC, &r, MASK_OFF);
::SetRect(&r, 0, 0, fWindowWidth, fWindowHeight);
sf::begin_draw_bitmap begin(graphics_bitmap_target_[fCurrentGraphics]);
graphics_bitmap_target_[fCurrentGraphics]->Clear();
- THROW_IF_ERR(begin.end_draw());
//::FillRect(fGraphicsWindowDC[fCurrentGraphics], &r, fBrushClear);
InvalidateRect(&r);
}
if (fMidiOutPort[i]==-1) continue;
outid = (fMidiOutPort[i]>=0) ? fMidiOutPort[i] : MIDI_MAPPER;
if (outid>=outdevs) outid = MIDI_MAPPER;
- result = ::midiOutOpen(&dout, outid, (DWORD_PTR)hwnd_, NULL, CALLBACK_WINDOW);
+ result = ::midiOutOpen(&dout, outid, (DWORD_PTR)raw_handle(), NULL, CALLBACK_WINDOW);
if (result==MMSYSERR_NOERROR) {
fMidiOutDevice[i] = dout;
}
if (indevs>0 && fMidiInPort>=0) {
inid = (fMidiInPort>=0) ? fMidiInPort : MIDI_MAPPER;
if (inid>=indevs) inid = indevs-1;
- result = ::midiInOpen(&din, 0, (DWORD_PTR)hwnd_, NULL, CALLBACK_WINDOW);
+ result = ::midiInOpen(&din, 0, (DWORD_PTR)raw_handle(), NULL, CALLBACK_WINDOW);
if (result==MMSYSERR_NOERROR) {
fMidiInDevice = din;
result = ::midiInStart(din);
CSTedScreenWin32::MidiPlayerWait(void)
{
// 5msのタイマセット
- ::SetTimer(hwnd_, IDT_STED2_WAIT_TIMER, 5, NULL);
+ ::SetTimer((HWND)raw_handle(), IDT_STED2_WAIT_TIMER, 5, NULL);
// 何かイベントが発生するまでメッセージループを回す。
while(fKeyEventNotified == 0 && fKeyBufferAvailable == 0 && !fTimerEventNotified /* && fMidiBufferAvailable == 0 */)
{
//u = toUCS2(in_str, in_len, &len);
IDWriteTextLayoutPtr l;
- write_factory_->CreateTextLayout(in_str,in_len,text_fmt_,fWindowWidth,fTextLineHeight,&l);
+ write_factory_->CreateTextLayout(in_str,in_len,text_fmt_.Get(),fWindowWidth,fTextLineHeight,&l);
DWRITE_TEXT_METRICS m;
l->GetMetrics(&m);
THROW_IF_ERR(text_bitmap_target_->GetBitmap(&b));
D2D1_RECT_F dr = D2D1::RectF(sx,ey,w + sx,h + ey);
D2D1_RECT_F sr = D2D1::RectF(sx,sy,w + sx,h + sy);
- text_bitmap_target_->DrawBitmap(b,dr,1.0f,D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,sr);
+ text_bitmap_target_->DrawBitmap(b.Get(),dr,1.0f,D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,sr);
//::BitBlt(fTextDC, sx, ey, w, h, fTextDC, sx, sy, SRCCOPY);
//::BitBlt(fTextMaskDC, sx, ey, w, h, fTextMaskDC, sx, sy, SRCCOPY);
}
if (!TextToWindowPos(&x, &y)) return;
- IDWriteTextLayoutPtr l;
- write_factory_->CreateTextLayout(u,len,text_fmt_,fWindowWidth,fTextLineHeight,&l);
+ IDWriteTextLayoutPtr layout;
+ write_factory_->CreateTextLayout(u,len,text_fmt_.Get(),fWindowWidth,fTextLineHeight,&layout);
DWRITE_TEXT_METRICS m;
- l->GetMetrics(&m);
+ layout->GetMetrics(&m);
text_bitmap_target_->PushAxisAlignedClip(D2D1::RectF(x,y,x + m.widthIncludingTrailingWhitespace,y + m.height),text_bitmap_target_->GetAntialiasMode());
//text_bitmap_target_->FillRectangle(D2D1::RectF(x,y,x + m.widthIncludingTrailingWhitespace,y + m.height),brush_text_clear_);
text_bitmap_target_->Clear();
text_bitmap_target_->PopAxisAlignedClip();
- text_bitmap_target_->DrawTextLayout(D2D1::Point2F(x,y),l,brush_text_);
+ text_bitmap_target_->DrawTextLayout(D2D1::Point2F(x,y),layout.Get(),brush_text_.Get());
//text_bitmap_target_->DrawTextW(
// u,len,text_fmt_,D2D1::RectF(x,y,x + fWindowWidth ,y + fTextLineHeight),brush_text_);
//text_bitmap_target_->DrawTextW(
h = fTextLineHeight;
IDWriteTextLayoutPtr layout;
- write_factory_->CreateTextLayout(u,len,text_fmt_,fWindowWidth,fTextLineHeight,&layout);
+ write_factory_->CreateTextLayout(u,len,text_fmt_.Get(),fWindowWidth,fTextLineHeight,&layout);
DWRITE_TEXT_METRICS m;
layout->GetMetrics(&m);
//::TextOut(fGraphicsWindowDC[c], x, y, u, len);
- sf::begin_draw<ID2D1BitmapRenderTargetPtr> begin(graphics_bitmap_target_[c]);
- //graphics_bitmap_target_[c]->PushAxisAlignedClip(D2D1::RectF(x,y,x + m.widthIncludingTrailingWhitespace,y + m.height),graphics_bitmap_target_[c]->GetAntialiasMode());
- ////text_bitmap_target_->FillRectangle(D2D1::RectF(x,y,x + m.widthIncludingTrailingWhitespace,y + m.height),brush_text_clear_);
- //graphics_bitmap_target_[c]->Clear();
- //graphics_bitmap_target_[c]->PopAxisAlignedClip();
- graphics_bitmap_target_[c]->DrawTextLayout(D2D1::Point2F(x,y),layout,brush_text_);
- THROW_IF_ERR(begin.end_draw());
+ {
+ sf::begin_draw<ID2D1BitmapRenderTargetPtr> begin(graphics_bitmap_target_[c]);
+ //graphics_bitmap_target_[c]->PushAxisAlignedClip(D2D1::RectF(x,y,x + m.widthIncludingTrailingWhitespace,y + m.height),graphics_bitmap_target_[c]->GetAntialiasMode());
+ ////text_bitmap_target_->FillRectangle(D2D1::RectF(x,y,x + m.widthIncludingTrailingWhitespace,y + m.height),brush_text_clear_);
+ //graphics_bitmap_target_[c]->Clear();
+ //graphics_bitmap_target_[c]->PopAxisAlignedClip();
+ graphics_bitmap_target_[c]->DrawTextLayout(D2D1::Point2F(x,y),layout.Get(),brush_text_.Get());
+ }
+ //THROW_IF_ERR(begin.end_draw());
::SetRect(&r, x, y, x + m.widthIncludingTrailingWhitespace, y + m.height);
InvalidateRect(&r);
timeBeginPeriod(1);\r
\r
instance_.reset(new CSTedScreenWin32(std::wstring(window_menu),std::wstring(window_class),false,0.0f,0.0f));\r
- instance_->register_class(\r
- (wchar_t*)IDC_STED2,\r
- CS_HREDRAW | CS_VREDRAW,\r
- 0,\r
- LoadIcon(HINST_THISCOMPONENT, (LPCTSTR)IDI_STED2),\r
- LoadCursor(NULL, IDC_ARROW),\r
- CreateSolidBrush(0x00000000),\r
- LoadIcon(HINST_THISCOMPONENT, (LPCTSTR)IDI_SMALL)\r
- );\r
- instance_->create_window();\r
- instance_->show(TRUE);\r
+ instance_->create();\r
+ instance_->show();\r
instance_->update();\r
instance_->Construct(16);\r
\r
\r
}\r
\r
+ void CSTedScreenWin32::create()\r
+ {\r
+ create_device_independent_resources();\r
+ // icon_ = ::LoadIconW(HINST_THISCOMPONENT,MAKEINTRESOURCE(IDI_ICON1));\r
+ register_class(\r
+ (wchar_t*)IDC_STED2,\r
+ CS_HREDRAW | CS_VREDRAW,\r
+ 0,\r
+ 0,\r
+ LoadIcon(HINST_THISCOMPONENT, (LPCTSTR)IDI_STED2),\r
+ LoadCursor(NULL, IDC_ARROW),\r
+ CreateSolidBrush(0x00000000),\r
+ LoadIcon(HINST_THISCOMPONENT, (LPCTSTR)IDI_SMALL)\r
+ );\r
+\r
+// register_class(this->name_.c_str(),CS_HREDRAW | CS_VREDRAW ,0,DLGWINDOWEXTRA,icon_.get());\r
+ create_window();\r
+ };\r
+\r
/* class */\r
\r
CSTedScreenWin32::CSTedScreenWin32(const std::wstring& menu_name,const std::wstring& name,bool fit_to_display,float width,float height) :\r
-sf::base_window(menu_name,name,fit_to_display,width,height)\r
+sf::base_win32_window<>(menu_name,name,fit_to_display,width,height)\r
{\r
\r
// fWindow = NULL;\r
//fBrushTextClear = NULL;\r
\r
discard_device();\r
- safe_release(render_target_);\r
+ render_target_.Reset();\r
\r
if (fFileDirHandle) {\r
::FindClose(fFileDirHandle);\r
sf::begin_draw<ID2D1BitmapRenderTargetPtr> draw_g_bitmap1(graphics_bitmap_target_[0]);\r
sf::begin_draw<ID2D1BitmapRenderTargetPtr> draw_g_bitmap2(graphics_bitmap_target_[1]);\r
\r
- text_bitmap_target_->FillRectangle(r,brush_text_clear_);\r
- graphics_bitmap_target_[0]->FillRectangle(r,brush_clear_);\r
- graphics_bitmap_target_[1]->FillRectangle(r,brush_clear_);\r
+ text_bitmap_target_->FillRectangle(r,brush_text_clear_.Get());\r
+ graphics_bitmap_target_[0]->FillRectangle(r,brush_clear_.Get());\r
+ graphics_bitmap_target_[1]->FillRectangle(r,brush_clear_.Get());\r
\r
//::FillRect(fTextDC, &r, fBrushTextClear);\r
//::FillRect(fTextMaskDC, &r, MASK_OFF);\r
render_target_->PushAxisAlignedClip(r,render_target_->GetAntialiasMode());\r
render_target_->Clear(D2D1::ColorF(0.0f,0.0f,0.0f,1.0f));\r
render_target_->PopAxisAlignedClip();\r
- render_target_->DrawBitmap(bitmap_graphics,r,1.0f,D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,r);\r
- render_target_->DrawBitmap(bitmap_text,r,1.0f,D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,r);\r
+ render_target_->DrawBitmap(bitmap_graphics.Get(),r,1.0f,D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,r);\r
+ render_target_->DrawBitmap(bitmap_text.Get(),r,1.0f,D2D1_BITMAP_INTERPOLATION_MODE_LINEAR,r);\r
\r
//ID2D1SolidColorBrushPtr brushr;\r
//render_target_->CreateSolidColorBrush(D2D1::ColorF(1.0f,0.0f,0.0f), &brushr);\r
//::BitBlt(dc, x,y,w,h, fGraphicsWindowDC[fCurrentGraphics], x,y, SRCCOPY);\r
//::BitBlt(dc, x,y,w,h, fTextMaskDC, x,y, SRCPAINT);\r
//::BitBlt(dc, x,y,w,h, fTextDC, x,y, SRCAND);\r
- THROW_IF_ERR(begin.end_draw());\r
+ // THROW_IF_ERR(begin.end_draw());\r
}\r
\r
fOffScreenIsDirty = FALSE;\r
void CSTedScreenWin32::discard_device()\r
{\r
::OutputDebugStringW(L"discard_device()\n");\r
- safe_release(graphics_dc_target_[0]);\r
- safe_release(graphics_dc_target_[1]);\r
- safe_release(text_dc_target_);\r
- safe_release(graphics_bitmap_target_[0]);\r
- safe_release(graphics_bitmap_target_[1]);\r
- safe_release(text_bitmap_target_);\r
- safe_release(brush_mask_on_);\r
- safe_release(brush_mask_off_);\r
- safe_release(brush_clear_);\r
- safe_release(brush_text_clear_);\r
- safe_release(brush_text_);\r
+ graphics_dc_target_[0].Reset();\r
+ graphics_dc_target_[1].Reset();\r
+ text_dc_target_.Reset();\r
+ graphics_bitmap_target_[0].Reset();\r
+ graphics_bitmap_target_[1].Reset();\r
+ text_bitmap_target_.Reset();\r
+ brush_mask_on_.Reset();\r
+ brush_mask_off_.Reset();\r
+ brush_clear_.Reset();\r
+ brush_text_clear_.Reset();\r
+ brush_text_.Reset();\r
\r
}\r
\r
\r
// GDI描画用のレンダーターゲット \r
THROW_IF_ERR\r
- (text_bitmap_target_->QueryInterface(__uuidof(ID2D1GdiInteropRenderTarget), (void**)&text_dc_target_));\r
+ (text_bitmap_target_.As( &text_dc_target_));\r
THROW_IF_ERR\r
- (graphics_bitmap_target_[0]->QueryInterface(__uuidof(ID2D1GdiInteropRenderTarget), (void**)&graphics_dc_target_[0]));\r
+ (graphics_bitmap_target_[0].As(&graphics_dc_target_[0]));\r
THROW_IF_ERR\r
- (graphics_bitmap_target_[1]->QueryInterface(__uuidof(ID2D1GdiInteropRenderTarget), (void**)&text_dc_target_[1]));\r
+ (graphics_bitmap_target_[1].As(&text_dc_target_));\r
\r
THROW_IF_ERR(\r
render_target_->CreateSolidColorBrush\r
\r
void CSTedScreenWin32::create_device_independent_resources()\r
{\r
- base_window::create_device_independent_resources();\r
+ base_win32_window<>::create_device_independent_resources();\r
// Text Formatの作成\r
THROW_IF_ERR(write_factory_->CreateTextFormat(\r
L"みかちゃん", // Font family name.\r
OSDN Git Service
