Add physics examples
This commit is contained in:
parent
5c866f1426
commit
6eea90dca6
BIN
cw 6/cw 6.zip
Normal file
BIN
cw 6/cw 6.zip
Normal file
Binary file not shown.
6
cw 8/Zadania.txt
Normal file
6
cw 8/Zadania.txt
Normal file
@ -0,0 +1,6 @@
|
||||
There are two files with tasks in src directory (main_8_1.cpp and main_8_2.cpp).
|
||||
See function initPhysicsScene() for the details.
|
||||
|
||||
links:
|
||||
https://gameworksdocs.nvidia.com/PhysX/4.1/documentation/physxguide/Manual/Index.html
|
||||
https://gameworksdocs.nvidia.com/PhysX/4.1/documentation/physxapi/files/index.html
|
125
cw 8/grk-cw8.vcxproj
Normal file
125
cw 8/grk-cw8.vcxproj
Normal file
@ -0,0 +1,125 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="src\Camera.cpp" />
|
||||
<ClCompile Include="src\main_8_1.cpp" />
|
||||
<ClCompile Include="src\Physics.cpp" />
|
||||
<ClCompile Include="src\Render_Utils.cpp" />
|
||||
<ClCompile Include="src\Shader_Loader.cpp" />
|
||||
<ClCompile Include="src\SOIL\image_DXT.c" />
|
||||
<ClCompile Include="src\SOIL\image_helper.c" />
|
||||
<ClCompile Include="src\SOIL\SOIL.c" />
|
||||
<ClCompile Include="src\SOIL\stb_image_aug.c" />
|
||||
<ClCompile Include="src\Texture.cpp" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="src\Camera.h" />
|
||||
<ClInclude Include="src\Physics.h" />
|
||||
<ClInclude Include="src\Render_Utils.h" />
|
||||
<ClInclude Include="src\Shader_Loader.h" />
|
||||
<ClInclude Include="src\SOIL\image_DXT.h" />
|
||||
<ClInclude Include="src\SOIL\image_helper.h" />
|
||||
<ClInclude Include="src\SOIL\SOIL.h" />
|
||||
<ClInclude Include="src\SOIL\stbi_DDS_aug.h" />
|
||||
<ClInclude Include="src\SOIL\stbi_DDS_aug_c.h" />
|
||||
<ClInclude Include="src\SOIL\stb_image_aug.h" />
|
||||
<ClInclude Include="src\Texture.h" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<None Include="shaders\shader_color.frag" />
|
||||
<None Include="shaders\shader_color.vert" />
|
||||
<None Include="shaders\shader_tex.frag" />
|
||||
<None Include="shaders\shader_tex.vert" />
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{4EE187F6-DEE7-4917-86D9-08C36D54920F}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>grk-cw8</RootNamespace>
|
||||
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
|
||||
<ProjectName>grk-cw8</ProjectName>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
<PlatformToolset>v142</PlatformToolset>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
<PlatformToolset>v142</PlatformToolset>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
<LibraryPath>$(SolutionDir)dependencies\freeglut\lib;$(SolutionDir)dependencies\glew-2.0.0\lib\Release\Win32;$(SolutionDir)dependencies\assimp;$(LibraryPath)</LibraryPath>
|
||||
<IncludePath>$(SolutionDir)dependencies\freeglut\include\GL;$(SolutionDir)dependencies\glew-2.0.0\include\GL;$(SolutionDir)dependencies\glm;$(SolutionDir)dependencies\assimp\include;$(IncludePath)</IncludePath>
|
||||
<ExecutablePath>$(ExecutablePath)</ExecutablePath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
<IncludePath>$(SolutionDir)dependencies\freeglut\include\GL;$(SolutionDir)dependencies\glew-2.0.0\include\GL;$(SolutionDir)dependencies\glm;$(SolutionDir)dependencies\assimp\include;$(IncludePath)</IncludePath>
|
||||
<LibraryPath>$(SolutionDir)dependencies\freeglut\lib;$(SolutionDir)dependencies\glew-2.0.0\lib\Release\Win32;$(SolutionDir)dependencies\assimp\Release;$(LibraryPath)</LibraryPath>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
<AdditionalIncludeDirectories>$(SolutionDir)dependencies\physx-4.1\include;$(SolutionDir)dependencies\physx-4.1\source\common\include;$(SolutionDir)dependencies\physx-4.1\source\common\src;$(SolutionDir)dependencies\physx-4.1\source\physx\src;$(SolutionDir)dependencies\physx-4.1\source\physx\src\device;$(SolutionDir)dependencies\physx-4.1\source\physx\src\buffering;$(SolutionDir)dependencies\physx-4.1\source\physxgpu\include;$(SolutionDir)dependencies\physx-4.1\source\geomutils\include;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\contact;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\common;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\convex;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\distance;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\sweep;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\gjk;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\intersection;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\mesh;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\hf;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\pcm;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\ccd;$(SolutionDir)dependencies\physx-4.1\source\lowlevel\api\include;$(SolutionDir)dependencies\physx-4.1\source\lowlevel\software\include;$(SolutionDir)dependencies\physx-4.1\source\lowlevel\common\include\pipeline;$(SolutionDir)dependencies\physx-4.1\source\lowlevelaabb\include;$(SolutionDir)dependencies\physx-4.1\source\lowleveldynamics\include;$(SolutionDir)dependencies\physx-4.1\source\simulationcontroller\include;$(SolutionDir)dependencies\physx-4.1\source\simulationcontroller\src;$(SolutionDir)dependencies\physx-4.1\source\physxcooking\src;$(SolutionDir)dependencies\physx-4.1\source\physxcooking\src\mesh;$(SolutionDir)dependencies\physx-4.1\source\physxcooking\src\convex;$(SolutionDir)dependencies\physx-4.1\source\scenequery\include;$(SolutionDir)dependencies\physx-4.1\source\physxmetadata\core\include;$(SolutionDir)dependencies\physx-4.1\source\immediatemode\include;$(SolutionDir)dependencies\physx-4.1\source\pvd\include;$(SolutionDir)dependencies\physx-4.1\source\foundation\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<AdditionalDependencies>$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\PhysXExtensions_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\PhysX_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\PhysXPvdSDK_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\PhysXVehicle_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\PhysXCharacterKinematic_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\PhysXCooking_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\PhysXCommon_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\SnippetUtils_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\SnippetRender_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\debug\PhysXFoundation_32.lib;opengl32.lib;freeglut.lib;glew32.lib;zlibd.lib;assimp-vc141-mtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
<AdditionalIncludeDirectories>$(SolutionDir)dependencies\physx-4.1\include;$(SolutionDir)dependencies\physx-4.1\source\common\include;$(SolutionDir)dependencies\physx-4.1\source\common\src;$(SolutionDir)dependencies\physx-4.1\source\physx\src;$(SolutionDir)dependencies\physx-4.1\source\physx\src\device;$(SolutionDir)dependencies\physx-4.1\source\physx\src\buffering;$(SolutionDir)dependencies\physx-4.1\source\physxgpu\include;$(SolutionDir)dependencies\physx-4.1\source\geomutils\include;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\contact;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\common;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\convex;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\distance;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\sweep;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\gjk;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\intersection;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\mesh;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\hf;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\pcm;$(SolutionDir)dependencies\physx-4.1\source\geomutils\src\ccd;$(SolutionDir)dependencies\physx-4.1\source\lowlevel\api\include;$(SolutionDir)dependencies\physx-4.1\source\lowlevel\software\include;$(SolutionDir)dependencies\physx-4.1\source\lowlevel\common\include\pipeline;$(SolutionDir)dependencies\physx-4.1\source\lowlevelaabb\include;$(SolutionDir)dependencies\physx-4.1\source\lowleveldynamics\include;$(SolutionDir)dependencies\physx-4.1\source\simulationcontroller\include;$(SolutionDir)dependencies\physx-4.1\source\simulationcontroller\src;$(SolutionDir)dependencies\physx-4.1\source\physxcooking\src;$(SolutionDir)dependencies\physx-4.1\source\physxcooking\src\mesh;$(SolutionDir)dependencies\physx-4.1\source\physxcooking\src\convex;$(SolutionDir)dependencies\physx-4.1\source\scenequery\include;$(SolutionDir)dependencies\physx-4.1\source\physxmetadata\core\include;$(SolutionDir)dependencies\physx-4.1\source\immediatemode\include;$(SolutionDir)dependencies\physx-4.1\source\pvd\include;$(SolutionDir)dependencies\physx-4.1\source\foundation\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
<AdditionalDependencies>$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\PhysXExtensions_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\PhysX_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\PhysXPvdSDK_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\PhysXVehicle_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\PhysXCharacterKinematic_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\PhysXCooking_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\PhysXCommon_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\SnippetUtils_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\SnippetRender_static_32.lib;$(SolutionDir)dependencies\physx-4.1\lib\win.x86_32.vc141.mt\release\PhysXFoundation_32.lib;opengl32.lib;freeglut.lib;glew32.lib;zlib.lib;assimp-vc141-mt.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
104
cw 8/grk-cw8.vcxproj.filters
Normal file
104
cw 8/grk-cw8.vcxproj.filters
Normal file
@ -0,0 +1,104 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup>
|
||||
<Filter Include="Source Files">
|
||||
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
|
||||
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Header Files">
|
||||
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
|
||||
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Resource Files">
|
||||
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
|
||||
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Source Files\SOIL">
|
||||
<UniqueIdentifier>{ab7cb6c3-cb29-4749-8f2f-ab23aaaf59cc}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Shader Files">
|
||||
<UniqueIdentifier>{0a247bb8-2e8e-4a90-b0ef-17415b0941ba}</UniqueIdentifier>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="src\Render_Utils.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\Shader_Loader.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\Camera.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\Texture.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\SOIL\image_DXT.c">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\SOIL\image_helper.c">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\SOIL\SOIL.c">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\SOIL\stb_image_aug.c">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\Physics.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="src\main_8_1.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="src\Render_Utils.h">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\Shader_Loader.h">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\Camera.h">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\Texture.h">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\SOIL\image_DXT.h">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\SOIL\image_helper.h">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\SOIL\SOIL.h">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\SOIL\stb_image_aug.h">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\SOIL\stbi_DDS_aug.h">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\SOIL\stbi_DDS_aug_c.h">
|
||||
<Filter>Source Files\SOIL</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="src\Physics.h">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<None Include="shaders\shader_color.frag">
|
||||
<Filter>Shader Files</Filter>
|
||||
</None>
|
||||
<None Include="shaders\shader_color.vert">
|
||||
<Filter>Shader Files</Filter>
|
||||
</None>
|
||||
<None Include="shaders\shader_tex.frag">
|
||||
<Filter>Shader Files</Filter>
|
||||
</None>
|
||||
<None Include="shaders\shader_tex.vert">
|
||||
<Filter>Shader Files</Filter>
|
||||
</None>
|
||||
</ItemGroup>
|
||||
</Project>
|
4
cw 8/grk-cw8.vcxproj.user
Normal file
4
cw 8/grk-cw8.vcxproj.user
Normal file
@ -0,0 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup />
|
||||
</Project>
|
29
cw 8/models/box.obj
Normal file
29
cw 8/models/box.obj
Normal file
@ -0,0 +1,29 @@
|
||||
# Blender v2.66 (sub 1) OBJ File: ''
|
||||
# www.blender.org
|
||||
g Cube
|
||||
v 1.000000 -1.000000 -1.000000
|
||||
v 1.000000 -1.000000 1.000000
|
||||
v -1.000000 -1.000000 1.000000
|
||||
v -1.000000 -1.000000 -1.000000
|
||||
v 1.000000 1.000000 -1.000000
|
||||
v 1.000000 1.000000 1.000001
|
||||
v -1.000000 1.000000 1.000000
|
||||
v -1.000000 1.000000 -1.000000
|
||||
vt 0.000000 0.000000
|
||||
vt 1.000000 0.000000
|
||||
vt 1.000000 1.000000
|
||||
vt 0.000000 1.000000
|
||||
vt 1.000012 0.000000
|
||||
vn 0.000000 -1.000000 0.000000
|
||||
vn 0.000000 1.000000 0.000000
|
||||
vn 1.000000 0.000000 0.000000
|
||||
vn -0.000000 -0.000000 1.000000
|
||||
vn -1.000000 -0.000000 -0.000000
|
||||
vn 0.000000 0.000000 -1.000000
|
||||
s off
|
||||
f 1/1/1 2/2/1 3/3/1 4/4/1
|
||||
f 5/4/2 8/1/2 7/5/2 6/3/2
|
||||
f 1/2/3 5/3/3 6/4/3 2/1/3
|
||||
f 2/4/4 6/1/4 7/2/4 3/3/4
|
||||
f 3/1/5 7/2/5 8/3/5 4/4/5
|
||||
f 5/3/6 1/4/6 4/1/6 8/2/6
|
18
cw 8/models/plane.obj
Normal file
18
cw 8/models/plane.obj
Normal file
@ -0,0 +1,18 @@
|
||||
v 0 -100 -100
|
||||
v 0 -100 100
|
||||
v 0 100 -100
|
||||
v 0 100 100
|
||||
|
||||
vt 0 0
|
||||
vt 20 0
|
||||
vt 0 20
|
||||
vt 20 20
|
||||
|
||||
vn 0 1 0
|
||||
|
||||
s off
|
||||
f 1/3/1 3/1/1 4/2/1
|
||||
f 1/3/1 4/2/1 2/4/1
|
||||
|
||||
f 1/3/1 4/2/1 3/1/1
|
||||
f 1/3/1 2/4/1 4/2/1
|
1568
cw 8/models/sphere.obj
Normal file
1568
cw 8/models/sphere.obj
Normal file
File diff suppressed because it is too large
Load Diff
14
cw 8/shaders/shader_color.frag
Normal file
14
cw 8/shaders/shader_color.frag
Normal file
@ -0,0 +1,14 @@
|
||||
#version 410 core
|
||||
|
||||
uniform vec3 objectColor;
|
||||
uniform vec3 lightDir;
|
||||
|
||||
in vec3 interpNormal;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec3 normal = normalize(interpNormal);
|
||||
float ambient = 0.2;
|
||||
float diffuse = max(dot(normal, -lightDir), 0.0);
|
||||
gl_FragColor = vec4(objectColor * (ambient + (1-ambient) * diffuse), 1.0);
|
||||
}
|
16
cw 8/shaders/shader_color.vert
Normal file
16
cw 8/shaders/shader_color.vert
Normal file
@ -0,0 +1,16 @@
|
||||
#version 410 core
|
||||
|
||||
layout(location = 0) in vec3 vertexPosition;
|
||||
layout(location = 1) in vec2 vertexTexCoord;
|
||||
layout(location = 2) in vec3 vertexNormal;
|
||||
|
||||
uniform mat4 modelViewProjectionMatrix;
|
||||
uniform mat4 modelMatrix;
|
||||
|
||||
out vec3 interpNormal;
|
||||
|
||||
void main()
|
||||
{
|
||||
gl_Position = modelViewProjectionMatrix * vec4(vertexPosition, 1.0);
|
||||
interpNormal = (modelMatrix * vec4(vertexNormal, 0.0)).xyz;
|
||||
}
|
17
cw 8/shaders/shader_tex.frag
Normal file
17
cw 8/shaders/shader_tex.frag
Normal file
@ -0,0 +1,17 @@
|
||||
#version 410 core
|
||||
|
||||
uniform sampler2D textureSampler;
|
||||
uniform vec3 lightDir;
|
||||
|
||||
in vec3 interpNormal;
|
||||
in vec2 interpTexCoord;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec2 modifiedTexCoord = vec2(interpTexCoord.x, 1.0 - interpTexCoord.y); // Poprawka dla tekstur Ziemi, ktore bez tego wyswietlaja sie 'do gory nogami'
|
||||
vec3 color = texture2D(textureSampler, modifiedTexCoord).rgb;
|
||||
vec3 normal = normalize(interpNormal);
|
||||
float ambient = 0.2;
|
||||
float diffuse = max(dot(normal, -lightDir), 0.0);
|
||||
gl_FragColor = vec4(color * (ambient + (1-ambient) * diffuse), 1.0);
|
||||
}
|
18
cw 8/shaders/shader_tex.vert
Normal file
18
cw 8/shaders/shader_tex.vert
Normal file
@ -0,0 +1,18 @@
|
||||
#version 410 core
|
||||
|
||||
layout(location = 0) in vec3 vertexPosition;
|
||||
layout(location = 1) in vec2 vertexTexCoord;
|
||||
layout(location = 2) in vec3 vertexNormal;
|
||||
|
||||
uniform mat4 modelViewProjectionMatrix;
|
||||
uniform mat4 modelMatrix;
|
||||
|
||||
out vec3 interpNormal;
|
||||
out vec2 interpTexCoord;
|
||||
|
||||
void main()
|
||||
{
|
||||
gl_Position = modelViewProjectionMatrix * vec4(vertexPosition, 1.0);
|
||||
interpNormal = (modelMatrix * vec4(vertexNormal, 0.0)).xyz;
|
||||
interpTexCoord = vertexTexCoord;
|
||||
}
|
31
cw 8/src/Camera.cpp
Normal file
31
cw 8/src/Camera.cpp
Normal file
@ -0,0 +1,31 @@
|
||||
#include "Camera.h"
|
||||
|
||||
glm::mat4 Core::createPerspectiveMatrix(float zNear, float zFar)
|
||||
{
|
||||
return glm::perspectiveFovRH(glm::radians(50.f), 1.f, 1.f, zNear, zFar);
|
||||
}
|
||||
|
||||
glm::mat4 Core::createViewMatrix( glm::vec3 position, glm::vec3 forward, glm::vec3 up )
|
||||
{
|
||||
glm::vec3 side = glm::cross(forward, up);
|
||||
|
||||
// Trzeba pamietac o minusie przy ustawianiu osi Z kamery.
|
||||
// Wynika to z tego, ze standardowa macierz perspektywiczna zaklada, ze "z przodu" jest ujemna (a nie dodatnia) czesc osi Z.
|
||||
glm::mat4 cameraRotation;
|
||||
cameraRotation[0][0] = side.x; cameraRotation[1][0] = side.y; cameraRotation[2][0] = side.z;
|
||||
cameraRotation[0][1] = up.x; cameraRotation[1][1] = up.y; cameraRotation[2][1] = up.z;
|
||||
cameraRotation[0][2] = -forward.x; cameraRotation[1][2] = -forward.y; cameraRotation[2][2] = -forward.z;
|
||||
|
||||
glm::mat4 cameraTranslation;
|
||||
cameraTranslation[3] = glm::vec4(-position, 1.0f);
|
||||
|
||||
return cameraRotation * cameraTranslation;
|
||||
}
|
||||
|
||||
glm::mat4 Core::createViewMatrixQuat(glm::vec3 position, glm::quat rotation)
|
||||
{
|
||||
glm::mat4 cameraTranslation;
|
||||
cameraTranslation[3] = glm::vec4(-position, 1.0f);
|
||||
|
||||
return glm::mat4_cast(rotation) * cameraTranslation;
|
||||
}
|
17
cw 8/src/Camera.h
Normal file
17
cw 8/src/Camera.h
Normal file
@ -0,0 +1,17 @@
|
||||
#pragma once
|
||||
|
||||
#include "glm.hpp"
|
||||
#include "ext.hpp"
|
||||
|
||||
namespace Core
|
||||
{
|
||||
glm::mat4 createPerspectiveMatrix(float zNear = 0.1f, float zFar = 100.0f);
|
||||
|
||||
// position - pozycja kamery
|
||||
// forward - wektor "do przodu" kamery (jednostkowy)
|
||||
// up - wektor "w gore" kamery (jednostkowy)
|
||||
// up i forward musza byc ortogonalne!
|
||||
glm::mat4 createViewMatrix(glm::vec3 position, glm::vec3 forward, glm::vec3 up);
|
||||
|
||||
glm::mat4 createViewMatrixQuat(glm::vec3 position, glm::quat rotation);
|
||||
}
|
48
cw 8/src/Physics.cpp
Normal file
48
cw 8/src/Physics.cpp
Normal file
@ -0,0 +1,48 @@
|
||||
#include "Physics.h"
|
||||
|
||||
#define PX_RELEASE(x) if(x) { x->release(); x = NULL; }
|
||||
|
||||
Physics::Physics(float gravity)
|
||||
{
|
||||
foundation = PxCreateFoundation(PX_PHYSICS_VERSION, allocator, errorCallback);
|
||||
|
||||
physics = PxCreatePhysics(PX_PHYSICS_VERSION, *foundation, PxTolerancesScale(), true);
|
||||
|
||||
PxSceneDesc sceneDesc(physics->getTolerancesScale());
|
||||
sceneDesc.gravity = PxVec3(0.0f, -gravity, 0.0f);
|
||||
dispatcher = PxDefaultCpuDispatcherCreate(2);
|
||||
sceneDesc.cpuDispatcher = dispatcher;
|
||||
sceneDesc.filterShader = PxDefaultSimulationFilterShader;
|
||||
scene = physics->createScene(sceneDesc);
|
||||
}
|
||||
Physics::Physics(float gravity,
|
||||
PxSimulationFilterShader simulationFilterShader,
|
||||
PxSimulationEventCallback* simulationEventCallback)
|
||||
{
|
||||
foundation = PxCreateFoundation(PX_PHYSICS_VERSION, allocator, errorCallback);
|
||||
|
||||
physics = PxCreatePhysics(PX_PHYSICS_VERSION, *foundation, PxTolerancesScale(), true);
|
||||
|
||||
PxSceneDesc sceneDesc(physics->getTolerancesScale());
|
||||
sceneDesc.gravity = PxVec3(0.0f, -gravity, 0.0f);
|
||||
dispatcher = PxDefaultCpuDispatcherCreate(2);
|
||||
sceneDesc.cpuDispatcher = dispatcher;
|
||||
sceneDesc.filterShader = simulationFilterShader;
|
||||
sceneDesc.kineKineFilteringMode = PxPairFilteringMode::eKEEP; // So kin-kin contacts with be reported
|
||||
sceneDesc.staticKineFilteringMode = PxPairFilteringMode::eKEEP; // So static-kin constacts will be reported
|
||||
sceneDesc.simulationEventCallback = simulationEventCallback;
|
||||
scene = physics->createScene(sceneDesc);
|
||||
}
|
||||
Physics::~Physics()
|
||||
{
|
||||
PX_RELEASE(scene);
|
||||
PX_RELEASE(dispatcher);
|
||||
PX_RELEASE(physics);
|
||||
PX_RELEASE(foundation);
|
||||
}
|
||||
|
||||
void Physics::step(float dt)
|
||||
{
|
||||
scene->simulate(dt);
|
||||
scene->fetchResults(true);
|
||||
}
|
24
cw 8/src/Physics.h
Normal file
24
cw 8/src/Physics.h
Normal file
@ -0,0 +1,24 @@
|
||||
#pragma once
|
||||
|
||||
#include "PxPhysicsAPI.h"
|
||||
using namespace physx;
|
||||
|
||||
class Physics
|
||||
{
|
||||
public:
|
||||
Physics(float gravity);
|
||||
Physics(float gravity,
|
||||
PxSimulationFilterShader simulationFilterShader,
|
||||
PxSimulationEventCallback* simulationEventCallback);
|
||||
virtual ~Physics();
|
||||
PxPhysics* physics = nullptr;
|
||||
PxScene* scene = nullptr;
|
||||
|
||||
void step(float dt);
|
||||
|
||||
private:
|
||||
PxDefaultAllocator allocator;
|
||||
PxDefaultErrorCallback errorCallback;
|
||||
PxFoundation* foundation = nullptr;
|
||||
PxDefaultCpuDispatcher* dispatcher = nullptr;
|
||||
};
|
89
cw 8/src/Render_Utils.cpp
Normal file
89
cw 8/src/Render_Utils.cpp
Normal file
@ -0,0 +1,89 @@
|
||||
#include "Render_Utils.h"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include "glew.h"
|
||||
#include "freeglut.h"
|
||||
|
||||
|
||||
void Core::RenderContext::initFromOBJ(obj::Model& model)
|
||||
{
|
||||
vertexArray = 0;
|
||||
vertexBuffer = 0;
|
||||
vertexIndexBuffer = 0;
|
||||
unsigned int vertexDataBufferSize = sizeof(float) * model.vertex.size();
|
||||
unsigned int vertexNormalBufferSize = sizeof(float) * model.normal.size();
|
||||
unsigned int vertexTexBufferSize = sizeof(float) * model.texCoord.size();
|
||||
|
||||
size = model.faces["default"].size();
|
||||
unsigned int vertexElementBufferSize = sizeof(unsigned short) * size;
|
||||
|
||||
|
||||
glGenVertexArrays(1, &vertexArray);
|
||||
glBindVertexArray(vertexArray);
|
||||
|
||||
|
||||
glGenBuffers(1, &vertexIndexBuffer);
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexIndexBuffer);
|
||||
glBufferData(GL_ELEMENT_ARRAY_BUFFER, vertexElementBufferSize, &model.faces["default"][0], GL_STATIC_DRAW);
|
||||
|
||||
glGenBuffers(1, &vertexBuffer);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
|
||||
|
||||
glEnableVertexAttribArray(0);
|
||||
glEnableVertexAttribArray(1);
|
||||
glEnableVertexAttribArray(2);
|
||||
|
||||
glBufferData(GL_ARRAY_BUFFER, vertexDataBufferSize + vertexNormalBufferSize + vertexTexBufferSize, NULL, GL_STATIC_DRAW);
|
||||
|
||||
glBufferSubData(GL_ARRAY_BUFFER, 0, vertexDataBufferSize, &model.vertex[0]);
|
||||
|
||||
glBufferSubData(GL_ARRAY_BUFFER, vertexDataBufferSize, vertexNormalBufferSize, &model.normal[0]);
|
||||
|
||||
glBufferSubData(GL_ARRAY_BUFFER, vertexDataBufferSize + vertexNormalBufferSize, vertexTexBufferSize, &model.texCoord[0]);
|
||||
|
||||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)(0));
|
||||
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (void*)(vertexDataBufferSize));
|
||||
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)(vertexNormalBufferSize + vertexDataBufferSize));
|
||||
}
|
||||
|
||||
void Core::DrawVertexArray(const float * vertexArray, int numVertices, int elementSize )
|
||||
{
|
||||
glVertexAttribPointer(0, elementSize, GL_FLOAT, false, 0, vertexArray);
|
||||
glEnableVertexAttribArray(0);
|
||||
|
||||
glDrawArrays(GL_TRIANGLES, 0, numVertices);
|
||||
}
|
||||
|
||||
void Core::DrawVertexArrayIndexed( const float * vertexArray, const int * indexArray, int numIndexes, int elementSize )
|
||||
{
|
||||
glVertexAttribPointer(0, elementSize, GL_FLOAT, false, 0, vertexArray);
|
||||
glEnableVertexAttribArray(0);
|
||||
|
||||
glDrawElements(GL_TRIANGLES, numIndexes, GL_UNSIGNED_INT, indexArray);
|
||||
}
|
||||
|
||||
|
||||
//void Core::DrawVertexArray( const VertexData & data )
|
||||
//{
|
||||
// int numAttribs = std::min(VertexData::MAX_ATTRIBS, data.NumActiveAttribs);
|
||||
// for(int i = 0; i < numAttribs; i++)
|
||||
// {
|
||||
// glVertexAttribPointer(i, data.Attribs[i].Size, GL_FLOAT, false, 0, data.Attribs[i].Pointer);
|
||||
// glEnableVertexAttribArray(i);
|
||||
// }
|
||||
// glDrawArrays(GL_TRIANGLES, 0, data.NumVertices);
|
||||
//}
|
||||
|
||||
void Core::DrawContext(Core::RenderContext& context)
|
||||
{
|
||||
|
||||
glBindVertexArray(context.vertexArray);
|
||||
glDrawElements(
|
||||
GL_TRIANGLES, // mode
|
||||
context.size, // count
|
||||
GL_UNSIGNED_SHORT, // type
|
||||
(void*)0 // element array buffer offset
|
||||
);
|
||||
glBindVertexArray(0);
|
||||
}
|
68
cw 8/src/Render_Utils.h
Normal file
68
cw 8/src/Render_Utils.h
Normal file
@ -0,0 +1,68 @@
|
||||
#pragma once
|
||||
#include "glm.hpp"
|
||||
#include "glew.h"
|
||||
#include "objload.h"
|
||||
|
||||
#define BUFFER_OFFSET(i) ((char *)NULL + (i))
|
||||
|
||||
namespace Core
|
||||
{
|
||||
struct RenderContext
|
||||
{
|
||||
GLuint vertexArray;
|
||||
GLuint vertexBuffer;
|
||||
GLuint vertexIndexBuffer;
|
||||
int size = 0;
|
||||
|
||||
void initFromOBJ(obj::Model& model);
|
||||
};
|
||||
|
||||
|
||||
// vertexArray - jednowymiarowa tablica zawierajaca wartosci opisujace pozycje kolejnych wierzcholkow w jednym ciagu (x1, y1, z1, w1, x2, y2, z2, w2, ...)
|
||||
// numVertices - liczba wierzcholkow do narysowania
|
||||
// elementSize - liczba wartosci opisujacych pojedynczy wierzcholek (np. 3 gdy wierzcholek opisany jest trojka (x, y, z))
|
||||
void DrawVertexArray(const float * vertexArray, int numVertices, int elementSize);
|
||||
|
||||
// indexArray - jednowymiarowa tablica zawierajaca indeksy wierzcholkow kolejnych trojkatow w jednym ciagu (t1_i1, t1_i2, t1_i3, t2_i1, t2_i2, t2_i3, ...)
|
||||
// numIndexes - liczba indeksow w tablicy indexArray
|
||||
void DrawVertexArrayIndexed(const float * vertexArray, const int * indexArray, int numIndexes, int elementSize);
|
||||
|
||||
|
||||
struct VertexAttribute
|
||||
{
|
||||
const void * Pointer;
|
||||
int Size;
|
||||
};
|
||||
|
||||
//struct VertexData
|
||||
//{
|
||||
// static const int MAX_ATTRIBS = 8;
|
||||
// VertexAttribute Attribs[MAX_ATTRIBS];
|
||||
// int NumActiveAttribs;
|
||||
// int NumVertices;
|
||||
//};
|
||||
|
||||
// Ta funkcja sluzy do rysowania trojkatow, ktorych wierzcholki moga byc opisane wiecej niz jednym atrybutem.
|
||||
// Funkcja przyjmuje jako parametr strukture, w ktorej nalezy zawrzec wszystkie potrzebne dane.
|
||||
//
|
||||
// Przykladowe wywolanie funkcji - narysowanie trojkata jak na pierwszych zajeciach:
|
||||
/*
|
||||
|
||||
const float vertices[] = {
|
||||
0.25f, 0.25f, 0.0f, 1.0f,
|
||||
0.25f, -0.25f, 0.0f, 1.0f,
|
||||
-0.25f, -0.25f, 0.0f, 1.0f
|
||||
};
|
||||
|
||||
Core::VertexData vertexData;
|
||||
vertexData.NumActiveAttribs = 1; // Liczba uzywanych atrybutow wierzcholka
|
||||
vertexData.Attribs[0].Pointer = vertices; // Wskaznik na dane zerowego atrybutu
|
||||
vertexData.Attribs[0].Size = 4; // Wielkosc zerowego atrybutu (ilosc liczb opisujacych ten atrybut w pojedynczym wierzcholku)
|
||||
vertexData.NumVertices = 3; // Liczba wierzcholkow do narysowania
|
||||
Core::DrawVertexArray(vertexData);
|
||||
|
||||
*/
|
||||
//void DrawVertexArray(const VertexData & data);
|
||||
|
||||
void DrawContext(RenderContext& context);
|
||||
}
|
36
cw 8/src/SOIL/Physics.cpp
Normal file
36
cw 8/src/SOIL/Physics.cpp
Normal file
@ -0,0 +1,36 @@
|
||||
#include "Physics.h"
|
||||
|
||||
#define PX_RELEASE(x) if(x) { x->release(); x = NULL; }
|
||||
|
||||
Physics::Physics(float gravity,
|
||||
PxSimulationFilterShader simulationFilterShader,
|
||||
PxSimulationEventCallback *simulationEventCallback)
|
||||
{
|
||||
foundation = PxCreateFoundation(PX_PHYSICS_VERSION, allocator, errorCallback);
|
||||
|
||||
physics = PxCreatePhysics(PX_PHYSICS_VERSION, *foundation, PxTolerancesScale(), true);
|
||||
|
||||
PxSceneDesc sceneDesc(physics->getTolerancesScale());
|
||||
sceneDesc.gravity = PxVec3(0.0f, -gravity, 0.0f);
|
||||
dispatcher = PxDefaultCpuDispatcherCreate(2);
|
||||
sceneDesc.cpuDispatcher = dispatcher;
|
||||
sceneDesc.filterShader = simulationFilterShader;
|
||||
sceneDesc.kineKineFilteringMode = PxPairFilteringMode::eKEEP; // So kin-kin contacts with be reported
|
||||
sceneDesc.staticKineFilteringMode = PxPairFilteringMode::eKEEP; // So static-kin constacts will be reported
|
||||
sceneDesc.simulationEventCallback = simulationEventCallback;
|
||||
scene = physics->createScene(sceneDesc);
|
||||
}
|
||||
|
||||
Physics::~Physics()
|
||||
{
|
||||
PX_RELEASE(scene);
|
||||
PX_RELEASE(dispatcher);
|
||||
PX_RELEASE(physics);
|
||||
PX_RELEASE(foundation);
|
||||
}
|
||||
|
||||
void Physics::step(float dt)
|
||||
{
|
||||
scene->simulate(dt);
|
||||
scene->fetchResults(true);
|
||||
}
|
23
cw 8/src/SOIL/Physics.h
Normal file
23
cw 8/src/SOIL/Physics.h
Normal file
@ -0,0 +1,23 @@
|
||||
#pragma once
|
||||
|
||||
#include "PxPhysicsAPI.h"
|
||||
using namespace physx;
|
||||
|
||||
class Physics
|
||||
{
|
||||
public:
|
||||
Physics(float gravity,
|
||||
PxSimulationFilterShader simulationFilterShader,
|
||||
PxSimulationEventCallback *simulationEventCallback);
|
||||
virtual ~Physics();
|
||||
PxPhysics* physics = nullptr;
|
||||
PxScene* scene = nullptr;
|
||||
|
||||
void step(float dt);
|
||||
|
||||
private:
|
||||
PxDefaultAllocator allocator;
|
||||
PxDefaultErrorCallback errorCallback;
|
||||
PxFoundation* foundation = nullptr;
|
||||
PxDefaultCpuDispatcher* dispatcher = nullptr;
|
||||
};
|
2024
cw 8/src/SOIL/SOIL.c
Normal file
2024
cw 8/src/SOIL/SOIL.c
Normal file
File diff suppressed because it is too large
Load Diff
433
cw 8/src/SOIL/SOIL.h
Normal file
433
cw 8/src/SOIL/SOIL.h
Normal file
@ -0,0 +1,433 @@
|
||||
/**
|
||||
@mainpage SOIL
|
||||
|
||||
Jonathan Dummer
|
||||
2007-07-26-10.36
|
||||
|
||||
Simple OpenGL Image Library
|
||||
|
||||
A tiny c library for uploading images as
|
||||
textures into OpenGL. Also saving and
|
||||
loading of images is supported.
|
||||
|
||||
I'm using Sean's Tool Box image loader as a base:
|
||||
http://www.nothings.org/
|
||||
|
||||
I'm upgrading it to load TGA and DDS files, and a direct
|
||||
path for loading DDS files straight into OpenGL textures,
|
||||
when applicable.
|
||||
|
||||
Image Formats:
|
||||
- BMP load & save
|
||||
- TGA load & save
|
||||
- DDS load & save
|
||||
- PNG load
|
||||
- JPG load
|
||||
|
||||
OpenGL Texture Features:
|
||||
- resample to power-of-two sizes
|
||||
- MIPmap generation
|
||||
- compressed texture S3TC formats (if supported)
|
||||
- can pre-multiply alpha for you, for better compositing
|
||||
- can flip image about the y-axis (except pre-compressed DDS files)
|
||||
|
||||
Thanks to:
|
||||
* Sean Barret - for the awesome stb_image
|
||||
* Dan Venkitachalam - for finding some non-compliant DDS files, and patching some explicit casts
|
||||
* everybody at gamedev.net
|
||||
**/
|
||||
|
||||
#ifndef HEADER_SIMPLE_OPENGL_IMAGE_LIBRARY
|
||||
#define HEADER_SIMPLE_OPENGL_IMAGE_LIBRARY
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
The format of images that may be loaded (force_channels).
|
||||
SOIL_LOAD_AUTO leaves the image in whatever format it was found.
|
||||
SOIL_LOAD_L forces the image to load as Luminous (greyscale)
|
||||
SOIL_LOAD_LA forces the image to load as Luminous with Alpha
|
||||
SOIL_LOAD_RGB forces the image to load as Red Green Blue
|
||||
SOIL_LOAD_RGBA forces the image to load as Red Green Blue Alpha
|
||||
**/
|
||||
enum
|
||||
{
|
||||
SOIL_LOAD_AUTO = 0,
|
||||
SOIL_LOAD_L = 1,
|
||||
SOIL_LOAD_LA = 2,
|
||||
SOIL_LOAD_RGB = 3,
|
||||
SOIL_LOAD_RGBA = 4
|
||||
};
|
||||
|
||||
/**
|
||||
Passed in as reuse_texture_ID, will cause SOIL to
|
||||
register a new texture ID using glGenTextures().
|
||||
If the value passed into reuse_texture_ID > 0 then
|
||||
SOIL will just re-use that texture ID (great for
|
||||
reloading image assets in-game!)
|
||||
**/
|
||||
enum
|
||||
{
|
||||
SOIL_CREATE_NEW_ID = 0
|
||||
};
|
||||
|
||||
/**
|
||||
flags you can pass into SOIL_load_OGL_texture()
|
||||
and SOIL_create_OGL_texture().
|
||||
(note that if SOIL_FLAG_DDS_LOAD_DIRECT is used
|
||||
the rest of the flags with the exception of
|
||||
SOIL_FLAG_TEXTURE_REPEATS will be ignored while
|
||||
loading already-compressed DDS files.)
|
||||
|
||||
SOIL_FLAG_POWER_OF_TWO: force the image to be POT
|
||||
SOIL_FLAG_MIPMAPS: generate mipmaps for the texture
|
||||
SOIL_FLAG_TEXTURE_REPEATS: otherwise will clamp
|
||||
SOIL_FLAG_MULTIPLY_ALPHA: for using (GL_ONE,GL_ONE_MINUS_SRC_ALPHA) blending
|
||||
SOIL_FLAG_INVERT_Y: flip the image vertically
|
||||
SOIL_FLAG_COMPRESS_TO_DXT: if the card can display them, will convert RGB to DXT1, RGBA to DXT5
|
||||
SOIL_FLAG_DDS_LOAD_DIRECT: will load DDS files directly without _ANY_ additional processing
|
||||
SOIL_FLAG_NTSC_SAFE_RGB: clamps RGB components to the range [16,235]
|
||||
SOIL_FLAG_CoCg_Y: Google YCoCg; RGB=>CoYCg, RGBA=>CoCgAY
|
||||
SOIL_FLAG_TEXTURE_RECTANGE: uses ARB_texture_rectangle ; pixel indexed & no repeat or MIPmaps or cubemaps
|
||||
**/
|
||||
enum
|
||||
{
|
||||
SOIL_FLAG_POWER_OF_TWO = 1,
|
||||
SOIL_FLAG_MIPMAPS = 2,
|
||||
SOIL_FLAG_TEXTURE_REPEATS = 4,
|
||||
SOIL_FLAG_MULTIPLY_ALPHA = 8,
|
||||
SOIL_FLAG_INVERT_Y = 16,
|
||||
SOIL_FLAG_COMPRESS_TO_DXT = 32,
|
||||
SOIL_FLAG_DDS_LOAD_DIRECT = 64,
|
||||
SOIL_FLAG_NTSC_SAFE_RGB = 128,
|
||||
SOIL_FLAG_CoCg_Y = 256,
|
||||
SOIL_FLAG_TEXTURE_RECTANGLE = 512
|
||||
};
|
||||
|
||||
/**
|
||||
The types of images that may be saved.
|
||||
(TGA supports uncompressed RGB / RGBA)
|
||||
(BMP supports uncompressed RGB)
|
||||
(DDS supports DXT1 and DXT5)
|
||||
**/
|
||||
enum
|
||||
{
|
||||
SOIL_SAVE_TYPE_TGA = 0,
|
||||
SOIL_SAVE_TYPE_BMP = 1,
|
||||
SOIL_SAVE_TYPE_DDS = 2
|
||||
};
|
||||
|
||||
/**
|
||||
Defines the order of faces in a DDS cubemap.
|
||||
I recommend that you use the same order in single
|
||||
image cubemap files, so they will be interchangeable
|
||||
with DDS cubemaps when using SOIL.
|
||||
**/
|
||||
#define SOIL_DDS_CUBEMAP_FACE_ORDER "EWUDNS"
|
||||
|
||||
/**
|
||||
The types of internal fake HDR representations
|
||||
|
||||
SOIL_HDR_RGBE: RGB * pow( 2.0, A - 128.0 )
|
||||
SOIL_HDR_RGBdivA: RGB / A
|
||||
SOIL_HDR_RGBdivA2: RGB / (A*A)
|
||||
**/
|
||||
enum
|
||||
{
|
||||
SOIL_HDR_RGBE = 0,
|
||||
SOIL_HDR_RGBdivA = 1,
|
||||
SOIL_HDR_RGBdivA2 = 2
|
||||
};
|
||||
|
||||
/**
|
||||
Loads an image from disk into an OpenGL texture.
|
||||
\param filename the name of the file to upload as a texture
|
||||
\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_load_OGL_texture
|
||||
(
|
||||
const char *filename,
|
||||
int force_channels,
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Loads 6 images from disk into an OpenGL cubemap texture.
|
||||
\param x_pos_file the name of the file to upload as the +x cube face
|
||||
\param x_neg_file the name of the file to upload as the -x cube face
|
||||
\param y_pos_file the name of the file to upload as the +y cube face
|
||||
\param y_neg_file the name of the file to upload as the -y cube face
|
||||
\param z_pos_file the name of the file to upload as the +z cube face
|
||||
\param z_neg_file the name of the file to upload as the -z cube face
|
||||
\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_load_OGL_cubemap
|
||||
(
|
||||
const char *x_pos_file,
|
||||
const char *x_neg_file,
|
||||
const char *y_pos_file,
|
||||
const char *y_neg_file,
|
||||
const char *z_pos_file,
|
||||
const char *z_neg_file,
|
||||
int force_channels,
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Loads 1 image from disk and splits it into an OpenGL cubemap texture.
|
||||
\param filename the name of the file to upload as a texture
|
||||
\param face_order the order of the faces in the file, any combination of NSWEUD, for North, South, Up, etc.
|
||||
\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_load_OGL_single_cubemap
|
||||
(
|
||||
const char *filename,
|
||||
const char face_order[6],
|
||||
int force_channels,
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Loads an HDR image from disk into an OpenGL texture.
|
||||
\param filename the name of the file to upload as a texture
|
||||
\param fake_HDR_format SOIL_HDR_RGBE, SOIL_HDR_RGBdivA, SOIL_HDR_RGBdivA2
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_load_OGL_HDR_texture
|
||||
(
|
||||
const char *filename,
|
||||
int fake_HDR_format,
|
||||
int rescale_to_max,
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Loads an image from RAM into an OpenGL texture.
|
||||
\param buffer the image data in RAM just as if it were still in a file
|
||||
\param buffer_length the size of the buffer in bytes
|
||||
\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_load_OGL_texture_from_memory
|
||||
(
|
||||
const unsigned char *const buffer,
|
||||
int buffer_length,
|
||||
int force_channels,
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Loads 6 images from memory into an OpenGL cubemap texture.
|
||||
\param x_pos_buffer the image data in RAM to upload as the +x cube face
|
||||
\param x_pos_buffer_length the size of the above buffer
|
||||
\param x_neg_buffer the image data in RAM to upload as the +x cube face
|
||||
\param x_neg_buffer_length the size of the above buffer
|
||||
\param y_pos_buffer the image data in RAM to upload as the +x cube face
|
||||
\param y_pos_buffer_length the size of the above buffer
|
||||
\param y_neg_buffer the image data in RAM to upload as the +x cube face
|
||||
\param y_neg_buffer_length the size of the above buffer
|
||||
\param z_pos_buffer the image data in RAM to upload as the +x cube face
|
||||
\param z_pos_buffer_length the size of the above buffer
|
||||
\param z_neg_buffer the image data in RAM to upload as the +x cube face
|
||||
\param z_neg_buffer_length the size of the above buffer
|
||||
\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_load_OGL_cubemap_from_memory
|
||||
(
|
||||
const unsigned char *const x_pos_buffer,
|
||||
int x_pos_buffer_length,
|
||||
const unsigned char *const x_neg_buffer,
|
||||
int x_neg_buffer_length,
|
||||
const unsigned char *const y_pos_buffer,
|
||||
int y_pos_buffer_length,
|
||||
const unsigned char *const y_neg_buffer,
|
||||
int y_neg_buffer_length,
|
||||
const unsigned char *const z_pos_buffer,
|
||||
int z_pos_buffer_length,
|
||||
const unsigned char *const z_neg_buffer,
|
||||
int z_neg_buffer_length,
|
||||
int force_channels,
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Loads 1 image from RAM and splits it into an OpenGL cubemap texture.
|
||||
\param buffer the image data in RAM just as if it were still in a file
|
||||
\param buffer_length the size of the buffer in bytes
|
||||
\param face_order the order of the faces in the file, any combination of NSWEUD, for North, South, Up, etc.
|
||||
\param force_channels 0-image format, 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_load_OGL_single_cubemap_from_memory
|
||||
(
|
||||
const unsigned char *const buffer,
|
||||
int buffer_length,
|
||||
const char face_order[6],
|
||||
int force_channels,
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Creates a 2D OpenGL texture from raw image data. Note that the raw data is
|
||||
_NOT_ freed after the upload (so the user can load various versions).
|
||||
\param data the raw data to be uploaded as an OpenGL texture
|
||||
\param width the width of the image in pixels
|
||||
\param height the height of the image in pixels
|
||||
\param channels the number of channels: 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_create_OGL_texture
|
||||
(
|
||||
const unsigned char *const data,
|
||||
int width, int height, int channels,
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Creates an OpenGL cubemap texture by splitting up 1 image into 6 parts.
|
||||
\param data the raw data to be uploaded as an OpenGL texture
|
||||
\param width the width of the image in pixels
|
||||
\param height the height of the image in pixels
|
||||
\param channels the number of channels: 1-luminous, 2-luminous/alpha, 3-RGB, 4-RGBA
|
||||
\param face_order the order of the faces in the file, and combination of NSWEUD, for North, South, Up, etc.
|
||||
\param reuse_texture_ID 0-generate a new texture ID, otherwise reuse the texture ID (overwriting the old texture)
|
||||
\param flags can be any of SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS | SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_INVERT_Y | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_DDS_LOAD_DIRECT
|
||||
\return 0-failed, otherwise returns the OpenGL texture handle
|
||||
**/
|
||||
unsigned int
|
||||
SOIL_create_OGL_single_cubemap
|
||||
(
|
||||
const unsigned char *const data,
|
||||
int width, int height, int channels,
|
||||
const char face_order[6],
|
||||
unsigned int reuse_texture_ID,
|
||||
unsigned int flags
|
||||
);
|
||||
|
||||
/**
|
||||
Captures the OpenGL window (RGB) and saves it to disk
|
||||
\return 0 if it failed, otherwise returns 1
|
||||
**/
|
||||
int
|
||||
SOIL_save_screenshot
|
||||
(
|
||||
const char *filename,
|
||||
int image_type,
|
||||
int x, int y,
|
||||
int width, int height
|
||||
);
|
||||
|
||||
/**
|
||||
Loads an image from disk into an array of unsigned chars.
|
||||
Note that *channels return the original channel count of the
|
||||
image. If force_channels was other than SOIL_LOAD_AUTO,
|
||||
the resulting image has force_channels, but *channels may be
|
||||
different (if the original image had a different channel
|
||||
count).
|
||||
\return 0 if failed, otherwise returns 1
|
||||
**/
|
||||
unsigned char*
|
||||
SOIL_load_image
|
||||
(
|
||||
const char *filename,
|
||||
int *width, int *height, int *channels,
|
||||
int force_channels
|
||||
);
|
||||
|
||||
/**
|
||||
Loads an image from memory into an array of unsigned chars.
|
||||
Note that *channels return the original channel count of the
|
||||
image. If force_channels was other than SOIL_LOAD_AUTO,
|
||||
the resulting image has force_channels, but *channels may be
|
||||
different (if the original image had a different channel
|
||||
count).
|
||||
\return 0 if failed, otherwise returns 1
|
||||
**/
|
||||
unsigned char*
|
||||
SOIL_load_image_from_memory
|
||||
(
|
||||
const unsigned char *const buffer,
|
||||
int buffer_length,
|
||||
int *width, int *height, int *channels,
|
||||
int force_channels
|
||||
);
|
||||
|
||||
/**
|
||||
Saves an image from an array of unsigned chars (RGBA) to disk
|
||||
\return 0 if failed, otherwise returns 1
|
||||
**/
|
||||
int
|
||||
SOIL_save_image
|
||||
(
|
||||
const char *filename,
|
||||
int image_type,
|
||||
int width, int height, int channels,
|
||||
const unsigned char *const data
|
||||
);
|
||||
|
||||
/**
|
||||
Frees the image data (note, this is just C's "free()"...this function is
|
||||
present mostly so C++ programmers don't forget to use "free()" and call
|
||||
"delete []" instead [8^)
|
||||
**/
|
||||
void
|
||||
SOIL_free_image_data
|
||||
(
|
||||
unsigned char *img_data
|
||||
);
|
||||
|
||||
/**
|
||||
This function resturn a pointer to a string describing the last thing
|
||||
that happened inside SOIL. It can be used to determine why an image
|
||||
failed to load.
|
||||
**/
|
||||
const char*
|
||||
SOIL_last_result
|
||||
(
|
||||
void
|
||||
);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* HEADER_SIMPLE_OPENGL_IMAGE_LIBRARY */
|
632
cw 8/src/SOIL/image_DXT.c
Normal file
632
cw 8/src/SOIL/image_DXT.c
Normal file
@ -0,0 +1,632 @@
|
||||
/*
|
||||
Jonathan Dummer
|
||||
2007-07-31-10.32
|
||||
|
||||
simple DXT compression / decompression code
|
||||
|
||||
public domain
|
||||
*/
|
||||
|
||||
#include "image_DXT.h"
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/* set this =1 if you want to use the covarince matrix method...
|
||||
which is better than my method of using standard deviations
|
||||
overall, except on the infintesimal chance that the power
|
||||
method fails for finding the largest eigenvector */
|
||||
#define USE_COV_MAT 1
|
||||
|
||||
/********* Function Prototypes *********/
|
||||
/*
|
||||
Takes a 4x4 block of pixels and compresses it into 8 bytes
|
||||
in DXT1 format (color only, no alpha). Speed is valued
|
||||
over prettyness, at least for now.
|
||||
*/
|
||||
void compress_DDS_color_block(
|
||||
int channels,
|
||||
const unsigned char *const uncompressed,
|
||||
unsigned char compressed[8] );
|
||||
/*
|
||||
Takes a 4x4 block of pixels and compresses the alpha
|
||||
component it into 8 bytes for use in DXT5 DDS files.
|
||||
Speed is valued over prettyness, at least for now.
|
||||
*/
|
||||
void compress_DDS_alpha_block(
|
||||
const unsigned char *const uncompressed,
|
||||
unsigned char compressed[8] );
|
||||
|
||||
/********* Actual Exposed Functions *********/
|
||||
int
|
||||
save_image_as_DDS
|
||||
(
|
||||
const char *filename,
|
||||
int width, int height, int channels,
|
||||
const unsigned char *const data
|
||||
)
|
||||
{
|
||||
/* variables */
|
||||
FILE *fout;
|
||||
unsigned char *DDS_data;
|
||||
DDS_header header;
|
||||
int DDS_size;
|
||||
/* error check */
|
||||
if( (NULL == filename) ||
|
||||
(width < 1) || (height < 1) ||
|
||||
(channels < 1) || (channels > 4) ||
|
||||
(data == NULL ) )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
/* Convert the image */
|
||||
if( (channels & 1) == 1 )
|
||||
{
|
||||
/* no alpha, just use DXT1 */
|
||||
DDS_data = convert_image_to_DXT1( data, width, height, channels, &DDS_size );
|
||||
} else
|
||||
{
|
||||
/* has alpha, so use DXT5 */
|
||||
DDS_data = convert_image_to_DXT5( data, width, height, channels, &DDS_size );
|
||||
}
|
||||
/* save it */
|
||||
memset( &header, 0, sizeof( DDS_header ) );
|
||||
header.dwMagic = ('D' << 0) | ('D' << 8) | ('S' << 16) | (' ' << 24);
|
||||
header.dwSize = 124;
|
||||
header.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_LINEARSIZE;
|
||||
header.dwWidth = width;
|
||||
header.dwHeight = height;
|
||||
header.dwPitchOrLinearSize = DDS_size;
|
||||
header.sPixelFormat.dwSize = 32;
|
||||
header.sPixelFormat.dwFlags = DDPF_FOURCC;
|
||||
if( (channels & 1) == 1 )
|
||||
{
|
||||
header.sPixelFormat.dwFourCC = ('D' << 0) | ('X' << 8) | ('T' << 16) | ('1' << 24);
|
||||
} else
|
||||
{
|
||||
header.sPixelFormat.dwFourCC = ('D' << 0) | ('X' << 8) | ('T' << 16) | ('5' << 24);
|
||||
}
|
||||
header.sCaps.dwCaps1 = DDSCAPS_TEXTURE;
|
||||
/* write it out */
|
||||
fout = fopen( filename, "wb");
|
||||
fwrite( &header, sizeof( DDS_header ), 1, fout );
|
||||
fwrite( DDS_data, 1, DDS_size, fout );
|
||||
fclose( fout );
|
||||
/* done */
|
||||
free( DDS_data );
|
||||
return 1;
|
||||
}
|
||||
|
||||
unsigned char* convert_image_to_DXT1(
|
||||
const unsigned char *const uncompressed,
|
||||
int width, int height, int channels,
|
||||
int *out_size )
|
||||
{
|
||||
unsigned char *compressed;
|
||||
int i, j, x, y;
|
||||
unsigned char ublock[16*3];
|
||||
unsigned char cblock[8];
|
||||
int index = 0, chan_step = 1;
|
||||
int block_count = 0;
|
||||
/* error check */
|
||||
*out_size = 0;
|
||||
if( (width < 1) || (height < 1) ||
|
||||
(NULL == uncompressed) ||
|
||||
(channels < 1) || (channels > 4) )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
/* for channels == 1 or 2, I do not step forward for R,G,B values */
|
||||
if( channels < 3 )
|
||||
{
|
||||
chan_step = 0;
|
||||
}
|
||||
/* get the RAM for the compressed image
|
||||
(8 bytes per 4x4 pixel block) */
|
||||
*out_size = ((width+3) >> 2) * ((height+3) >> 2) * 8;
|
||||
compressed = (unsigned char*)malloc( *out_size );
|
||||
/* go through each block */
|
||||
for( j = 0; j < height; j += 4 )
|
||||
{
|
||||
for( i = 0; i < width; i += 4 )
|
||||
{
|
||||
/* copy this block into a new one */
|
||||
int idx = 0;
|
||||
int mx = 4, my = 4;
|
||||
if( j+4 >= height )
|
||||
{
|
||||
my = height - j;
|
||||
}
|
||||
if( i+4 >= width )
|
||||
{
|
||||
mx = width - i;
|
||||
}
|
||||
for( y = 0; y < my; ++y )
|
||||
{
|
||||
for( x = 0; x < mx; ++x )
|
||||
{
|
||||
ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels];
|
||||
ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels+chan_step];
|
||||
ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels+chan_step+chan_step];
|
||||
}
|
||||
for( x = mx; x < 4; ++x )
|
||||
{
|
||||
ublock[idx++] = ublock[0];
|
||||
ublock[idx++] = ublock[1];
|
||||
ublock[idx++] = ublock[2];
|
||||
}
|
||||
}
|
||||
for( y = my; y < 4; ++y )
|
||||
{
|
||||
for( x = 0; x < 4; ++x )
|
||||
{
|
||||
ublock[idx++] = ublock[0];
|
||||
ublock[idx++] = ublock[1];
|
||||
ublock[idx++] = ublock[2];
|
||||
}
|
||||
}
|
||||
/* compress the block */
|
||||
++block_count;
|
||||
compress_DDS_color_block( 3, ublock, cblock );
|
||||
/* copy the data from the block into the main block */
|
||||
for( x = 0; x < 8; ++x )
|
||||
{
|
||||
compressed[index++] = cblock[x];
|
||||
}
|
||||
}
|
||||
}
|
||||
return compressed;
|
||||
}
|
||||
|
||||
unsigned char* convert_image_to_DXT5(
|
||||
const unsigned char *const uncompressed,
|
||||
int width, int height, int channels,
|
||||
int *out_size )
|
||||
{
|
||||
unsigned char *compressed;
|
||||
int i, j, x, y;
|
||||
unsigned char ublock[16*4];
|
||||
unsigned char cblock[8];
|
||||
int index = 0, chan_step = 1;
|
||||
int block_count = 0, has_alpha;
|
||||
/* error check */
|
||||
*out_size = 0;
|
||||
if( (width < 1) || (height < 1) ||
|
||||
(NULL == uncompressed) ||
|
||||
(channels < 1) || ( channels > 4) )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
/* for channels == 1 or 2, I do not step forward for R,G,B vales */
|
||||
if( channels < 3 )
|
||||
{
|
||||
chan_step = 0;
|
||||
}
|
||||
/* # channels = 1 or 3 have no alpha, 2 & 4 do have alpha */
|
||||
has_alpha = 1 - (channels & 1);
|
||||
/* get the RAM for the compressed image
|
||||
(16 bytes per 4x4 pixel block) */
|
||||
*out_size = ((width+3) >> 2) * ((height+3) >> 2) * 16;
|
||||
compressed = (unsigned char*)malloc( *out_size );
|
||||
/* go through each block */
|
||||
for( j = 0; j < height; j += 4 )
|
||||
{
|
||||
for( i = 0; i < width; i += 4 )
|
||||
{
|
||||
/* local variables, and my block counter */
|
||||
int idx = 0;
|
||||
int mx = 4, my = 4;
|
||||
if( j+4 >= height )
|
||||
{
|
||||
my = height - j;
|
||||
}
|
||||
if( i+4 >= width )
|
||||
{
|
||||
mx = width - i;
|
||||
}
|
||||
for( y = 0; y < my; ++y )
|
||||
{
|
||||
for( x = 0; x < mx; ++x )
|
||||
{
|
||||
ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels];
|
||||
ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels+chan_step];
|
||||
ublock[idx++] = uncompressed[(j+y)*width*channels+(i+x)*channels+chan_step+chan_step];
|
||||
ublock[idx++] =
|
||||
has_alpha * uncompressed[(j+y)*width*channels+(i+x)*channels+channels-1]
|
||||
+ (1-has_alpha)*255;
|
||||
}
|
||||
for( x = mx; x < 4; ++x )
|
||||
{
|
||||
ublock[idx++] = ublock[0];
|
||||
ublock[idx++] = ublock[1];
|
||||
ublock[idx++] = ublock[2];
|
||||
ublock[idx++] = ublock[3];
|
||||
}
|
||||
}
|
||||
for( y = my; y < 4; ++y )
|
||||
{
|
||||
for( x = 0; x < 4; ++x )
|
||||
{
|
||||
ublock[idx++] = ublock[0];
|
||||
ublock[idx++] = ublock[1];
|
||||
ublock[idx++] = ublock[2];
|
||||
ublock[idx++] = ublock[3];
|
||||
}
|
||||
}
|
||||
/* now compress the alpha block */
|
||||
compress_DDS_alpha_block( ublock, cblock );
|
||||
/* copy the data from the compressed alpha block into the main buffer */
|
||||
for( x = 0; x < 8; ++x )
|
||||
{
|
||||
compressed[index++] = cblock[x];
|
||||
}
|
||||
/* then compress the color block */
|
||||
++block_count;
|
||||
compress_DDS_color_block( 4, ublock, cblock );
|
||||
/* copy the data from the compressed color block into the main buffer */
|
||||
for( x = 0; x < 8; ++x )
|
||||
{
|
||||
compressed[index++] = cblock[x];
|
||||
}
|
||||
}
|
||||
}
|
||||
return compressed;
|
||||
}
|
||||
|
||||
/********* Helper Functions *********/
|
||||
int convert_bit_range( int c, int from_bits, int to_bits )
|
||||
{
|
||||
int b = (1 << (from_bits - 1)) + c * ((1 << to_bits) - 1);
|
||||
return (b + (b >> from_bits)) >> from_bits;
|
||||
}
|
||||
|
||||
int rgb_to_565( int r, int g, int b )
|
||||
{
|
||||
return
|
||||
(convert_bit_range( r, 8, 5 ) << 11) |
|
||||
(convert_bit_range( g, 8, 6 ) << 05) |
|
||||
(convert_bit_range( b, 8, 5 ) << 00);
|
||||
}
|
||||
|
||||
void rgb_888_from_565( unsigned int c, int *r, int *g, int *b )
|
||||
{
|
||||
*r = convert_bit_range( (c >> 11) & 31, 5, 8 );
|
||||
*g = convert_bit_range( (c >> 05) & 63, 6, 8 );
|
||||
*b = convert_bit_range( (c >> 00) & 31, 5, 8 );
|
||||
}
|
||||
|
||||
void compute_color_line_STDEV(
|
||||
const unsigned char *const uncompressed,
|
||||
int channels,
|
||||
float point[3], float direction[3] )
|
||||
{
|
||||
const float inv_16 = 1.0f / 16.0f;
|
||||
int i;
|
||||
float sum_r = 0.0f, sum_g = 0.0f, sum_b = 0.0f;
|
||||
float sum_rr = 0.0f, sum_gg = 0.0f, sum_bb = 0.0f;
|
||||
float sum_rg = 0.0f, sum_rb = 0.0f, sum_gb = 0.0f;
|
||||
/* calculate all data needed for the covariance matrix
|
||||
( to compare with _rygdxt code) */
|
||||
for( i = 0; i < 16*channels; i += channels )
|
||||
{
|
||||
sum_r += uncompressed[i+0];
|
||||
sum_rr += uncompressed[i+0] * uncompressed[i+0];
|
||||
sum_g += uncompressed[i+1];
|
||||
sum_gg += uncompressed[i+1] * uncompressed[i+1];
|
||||
sum_b += uncompressed[i+2];
|
||||
sum_bb += uncompressed[i+2] * uncompressed[i+2];
|
||||
sum_rg += uncompressed[i+0] * uncompressed[i+1];
|
||||
sum_rb += uncompressed[i+0] * uncompressed[i+2];
|
||||
sum_gb += uncompressed[i+1] * uncompressed[i+2];
|
||||
}
|
||||
/* convert the sums to averages */
|
||||
sum_r *= inv_16;
|
||||
sum_g *= inv_16;
|
||||
sum_b *= inv_16;
|
||||
/* and convert the squares to the squares of the value - avg_value */
|
||||
sum_rr -= 16.0f * sum_r * sum_r;
|
||||
sum_gg -= 16.0f * sum_g * sum_g;
|
||||
sum_bb -= 16.0f * sum_b * sum_b;
|
||||
sum_rg -= 16.0f * sum_r * sum_g;
|
||||
sum_rb -= 16.0f * sum_r * sum_b;
|
||||
sum_gb -= 16.0f * sum_g * sum_b;
|
||||
/* the point on the color line is the average */
|
||||
point[0] = sum_r;
|
||||
point[1] = sum_g;
|
||||
point[2] = sum_b;
|
||||
#if USE_COV_MAT
|
||||
/*
|
||||
The following idea was from ryg.
|
||||
(https://mollyrocket.com/forums/viewtopic.php?t=392)
|
||||
The method worked great (less RMSE than mine) most of
|
||||
the time, but had some issues handling some simple
|
||||
boundary cases, like full green next to full red,
|
||||
which would generate a covariance matrix like this:
|
||||
|
||||
| 1 -1 0 |
|
||||
| -1 1 0 |
|
||||
| 0 0 0 |
|
||||
|
||||
For a given starting vector, the power method can
|
||||
generate all zeros! So no starting with {1,1,1}
|
||||
as I was doing! This kind of error is still a
|
||||
slight posibillity, but will be very rare.
|
||||
*/
|
||||
/* use the covariance matrix directly
|
||||
(1st iteration, don't use all 1.0 values!) */
|
||||
sum_r = 1.0f;
|
||||
sum_g = 2.718281828f;
|
||||
sum_b = 3.141592654f;
|
||||
direction[0] = sum_r*sum_rr + sum_g*sum_rg + sum_b*sum_rb;
|
||||
direction[1] = sum_r*sum_rg + sum_g*sum_gg + sum_b*sum_gb;
|
||||
direction[2] = sum_r*sum_rb + sum_g*sum_gb + sum_b*sum_bb;
|
||||
/* 2nd iteration, use results from the 1st guy */
|
||||
sum_r = direction[0];
|
||||
sum_g = direction[1];
|
||||
sum_b = direction[2];
|
||||
direction[0] = sum_r*sum_rr + sum_g*sum_rg + sum_b*sum_rb;
|
||||
direction[1] = sum_r*sum_rg + sum_g*sum_gg + sum_b*sum_gb;
|
||||
direction[2] = sum_r*sum_rb + sum_g*sum_gb + sum_b*sum_bb;
|
||||
/* 3rd iteration, use results from the 2nd guy */
|
||||
sum_r = direction[0];
|
||||
sum_g = direction[1];
|
||||
sum_b = direction[2];
|
||||
direction[0] = sum_r*sum_rr + sum_g*sum_rg + sum_b*sum_rb;
|
||||
direction[1] = sum_r*sum_rg + sum_g*sum_gg + sum_b*sum_gb;
|
||||
direction[2] = sum_r*sum_rb + sum_g*sum_gb + sum_b*sum_bb;
|
||||
#else
|
||||
/* use my standard deviation method
|
||||
(very robust, a tiny bit slower and less accurate) */
|
||||
direction[0] = sqrt( sum_rr );
|
||||
direction[1] = sqrt( sum_gg );
|
||||
direction[2] = sqrt( sum_bb );
|
||||
/* which has a greater component */
|
||||
if( sum_gg > sum_rr )
|
||||
{
|
||||
/* green has greater component, so base the other signs off of green */
|
||||
if( sum_rg < 0.0f )
|
||||
{
|
||||
direction[0] = -direction[0];
|
||||
}
|
||||
if( sum_gb < 0.0f )
|
||||
{
|
||||
direction[2] = -direction[2];
|
||||
}
|
||||
} else
|
||||
{
|
||||
/* red has a greater component */
|
||||
if( sum_rg < 0.0f )
|
||||
{
|
||||
direction[1] = -direction[1];
|
||||
}
|
||||
if( sum_rb < 0.0f )
|
||||
{
|
||||
direction[2] = -direction[2];
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void LSE_master_colors_max_min(
|
||||
int *cmax, int *cmin,
|
||||
int channels,
|
||||
const unsigned char *const uncompressed )
|
||||
{
|
||||
int i, j;
|
||||
/* the master colors */
|
||||
int c0[3], c1[3];
|
||||
/* used for fitting the line */
|
||||
float sum_x[] = { 0.0f, 0.0f, 0.0f };
|
||||
float sum_x2[] = { 0.0f, 0.0f, 0.0f };
|
||||
float dot_max = 1.0f, dot_min = -1.0f;
|
||||
float vec_len2 = 0.0f;
|
||||
float dot;
|
||||
/* error check */
|
||||
if( (channels < 3) || (channels > 4) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
compute_color_line_STDEV( uncompressed, channels, sum_x, sum_x2 );
|
||||
vec_len2 = 1.0f / ( 0.00001f +
|
||||
sum_x2[0]*sum_x2[0] + sum_x2[1]*sum_x2[1] + sum_x2[2]*sum_x2[2] );
|
||||
/* finding the max and min vector values */
|
||||
dot_max =
|
||||
(
|
||||
sum_x2[0] * uncompressed[0] +
|
||||
sum_x2[1] * uncompressed[1] +
|
||||
sum_x2[2] * uncompressed[2]
|
||||
);
|
||||
dot_min = dot_max;
|
||||
for( i = 1; i < 16; ++i )
|
||||
{
|
||||
dot =
|
||||
(
|
||||
sum_x2[0] * uncompressed[i*channels+0] +
|
||||
sum_x2[1] * uncompressed[i*channels+1] +
|
||||
sum_x2[2] * uncompressed[i*channels+2]
|
||||
);
|
||||
if( dot < dot_min )
|
||||
{
|
||||
dot_min = dot;
|
||||
} else if( dot > dot_max )
|
||||
{
|
||||
dot_max = dot;
|
||||
}
|
||||
}
|
||||
/* and the offset (from the average location) */
|
||||
dot = sum_x2[0]*sum_x[0] + sum_x2[1]*sum_x[1] + sum_x2[2]*sum_x[2];
|
||||
dot_min -= dot;
|
||||
dot_max -= dot;
|
||||
/* post multiply by the scaling factor */
|
||||
dot_min *= vec_len2;
|
||||
dot_max *= vec_len2;
|
||||
/* OK, build the master colors */
|
||||
for( i = 0; i < 3; ++i )
|
||||
{
|
||||
/* color 0 */
|
||||
c0[i] = (int)(0.5f + sum_x[i] + dot_max * sum_x2[i]);
|
||||
if( c0[i] < 0 )
|
||||
{
|
||||
c0[i] = 0;
|
||||
} else if( c0[i] > 255 )
|
||||
{
|
||||
c0[i] = 255;
|
||||
}
|
||||
/* color 1 */
|
||||
c1[i] = (int)(0.5f + sum_x[i] + dot_min * sum_x2[i]);
|
||||
if( c1[i] < 0 )
|
||||
{
|
||||
c1[i] = 0;
|
||||
} else if( c1[i] > 255 )
|
||||
{
|
||||
c1[i] = 255;
|
||||
}
|
||||
}
|
||||
/* down_sample (with rounding?) */
|
||||
i = rgb_to_565( c0[0], c0[1], c0[2] );
|
||||
j = rgb_to_565( c1[0], c1[1], c1[2] );
|
||||
if( i > j )
|
||||
{
|
||||
*cmax = i;
|
||||
*cmin = j;
|
||||
} else
|
||||
{
|
||||
*cmax = j;
|
||||
*cmin = i;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
compress_DDS_color_block
|
||||
(
|
||||
int channels,
|
||||
const unsigned char *const uncompressed,
|
||||
unsigned char compressed[8]
|
||||
)
|
||||
{
|
||||
/* variables */
|
||||
int i;
|
||||
int next_bit;
|
||||
int enc_c0, enc_c1;
|
||||
int c0[4], c1[4];
|
||||
float color_line[] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
||||
float vec_len2 = 0.0f, dot_offset = 0.0f;
|
||||
/* stupid order */
|
||||
int swizzle4[] = { 0, 2, 3, 1 };
|
||||
/* get the master colors */
|
||||
LSE_master_colors_max_min( &enc_c0, &enc_c1, channels, uncompressed );
|
||||
/* store the 565 color 0 and color 1 */
|
||||
compressed[0] = (enc_c0 >> 0) & 255;
|
||||
compressed[1] = (enc_c0 >> 8) & 255;
|
||||
compressed[2] = (enc_c1 >> 0) & 255;
|
||||
compressed[3] = (enc_c1 >> 8) & 255;
|
||||
/* zero out the compressed data */
|
||||
compressed[4] = 0;
|
||||
compressed[5] = 0;
|
||||
compressed[6] = 0;
|
||||
compressed[7] = 0;
|
||||
/* reconstitute the master color vectors */
|
||||
rgb_888_from_565( enc_c0, &c0[0], &c0[1], &c0[2] );
|
||||
rgb_888_from_565( enc_c1, &c1[0], &c1[1], &c1[2] );
|
||||
/* the new vector */
|
||||
vec_len2 = 0.0f;
|
||||
for( i = 0; i < 3; ++i )
|
||||
{
|
||||
color_line[i] = (float)(c1[i] - c0[i]);
|
||||
vec_len2 += color_line[i] * color_line[i];
|
||||
}
|
||||
if( vec_len2 > 0.0f )
|
||||
{
|
||||
vec_len2 = 1.0f / vec_len2;
|
||||
}
|
||||
/* pre-proform the scaling */
|
||||
color_line[0] *= vec_len2;
|
||||
color_line[1] *= vec_len2;
|
||||
color_line[2] *= vec_len2;
|
||||
/* compute the offset (constant) portion of the dot product */
|
||||
dot_offset = color_line[0]*c0[0] + color_line[1]*c0[1] + color_line[2]*c0[2];
|
||||
/* store the rest of the bits */
|
||||
next_bit = 8*4;
|
||||
for( i = 0; i < 16; ++i )
|
||||
{
|
||||
/* find the dot product of this color, to place it on the line
|
||||
(should be [-1,1]) */
|
||||
int next_value = 0;
|
||||
float dot_product =
|
||||
color_line[0] * uncompressed[i*channels+0] +
|
||||
color_line[1] * uncompressed[i*channels+1] +
|
||||
color_line[2] * uncompressed[i*channels+2] -
|
||||
dot_offset;
|
||||
/* map to [0,3] */
|
||||
next_value = (int)( dot_product * 3.0f + 0.5f );
|
||||
if( next_value > 3 )
|
||||
{
|
||||
next_value = 3;
|
||||
} else if( next_value < 0 )
|
||||
{
|
||||
next_value = 0;
|
||||
}
|
||||
/* OK, store this value */
|
||||
compressed[next_bit >> 3] |= swizzle4[ next_value ] << (next_bit & 7);
|
||||
next_bit += 2;
|
||||
}
|
||||
/* done compressing to DXT1 */
|
||||
}
|
||||
|
||||
void
|
||||
compress_DDS_alpha_block
|
||||
(
|
||||
const unsigned char *const uncompressed,
|
||||
unsigned char compressed[8]
|
||||
)
|
||||
{
|
||||
/* variables */
|
||||
int i;
|
||||
int next_bit;
|
||||
int a0, a1;
|
||||
float scale_me;
|
||||
/* stupid order */
|
||||
int swizzle8[] = { 1, 7, 6, 5, 4, 3, 2, 0 };
|
||||
/* get the alpha limits (a0 > a1) */
|
||||
a0 = a1 = uncompressed[3];
|
||||
for( i = 4+3; i < 16*4; i += 4 )
|
||||
{
|
||||
if( uncompressed[i] > a0 )
|
||||
{
|
||||
a0 = uncompressed[i];
|
||||
} else if( uncompressed[i] < a1 )
|
||||
{
|
||||
a1 = uncompressed[i];
|
||||
}
|
||||
}
|
||||
/* store those limits, and zero the rest of the compressed dataset */
|
||||
compressed[0] = a0;
|
||||
compressed[1] = a1;
|
||||
/* zero out the compressed data */
|
||||
compressed[2] = 0;
|
||||
compressed[3] = 0;
|
||||
compressed[4] = 0;
|
||||
compressed[5] = 0;
|
||||
compressed[6] = 0;
|
||||
compressed[7] = 0;
|
||||
/* store the all of the alpha values */
|
||||
next_bit = 8*2;
|
||||
scale_me = 7.9999f / (a0 - a1);
|
||||
for( i = 3; i < 16*4; i += 4 )
|
||||
{
|
||||
/* convert this alpha value to a 3 bit number */
|
||||
int svalue;
|
||||
int value = (int)((uncompressed[i] - a1) * scale_me);
|
||||
svalue = swizzle8[ value&7 ];
|
||||
/* OK, store this value, start with the 1st byte */
|
||||
compressed[next_bit >> 3] |= svalue << (next_bit & 7);
|
||||
if( (next_bit & 7) > 5 )
|
||||
{
|
||||
/* spans 2 bytes, fill in the start of the 2nd byte */
|
||||
compressed[1 + (next_bit >> 3)] |= svalue >> (8 - (next_bit & 7) );
|
||||
}
|
||||
next_bit += 3;
|
||||
}
|
||||
/* done compressing to DXT1 */
|
||||
}
|
123
cw 8/src/SOIL/image_DXT.h
Normal file
123
cw 8/src/SOIL/image_DXT.h
Normal file
@ -0,0 +1,123 @@
|
||||
/*
|
||||
Jonathan Dummer
|
||||
2007-07-31-10.32
|
||||
|
||||
simple DXT compression / decompression code
|
||||
|
||||
public domain
|
||||
*/
|
||||
|
||||
#ifndef HEADER_IMAGE_DXT
|
||||
#define HEADER_IMAGE_DXT
|
||||
|
||||
/**
|
||||
Converts an image from an array of unsigned chars (RGB or RGBA) to
|
||||
DXT1 or DXT5, then saves the converted image to disk.
|
||||
\return 0 if failed, otherwise returns 1
|
||||
**/
|
||||
int
|
||||
save_image_as_DDS
|
||||
(
|
||||
const char *filename,
|
||||
int width, int height, int channels,
|
||||
const unsigned char *const data
|
||||
);
|
||||
|
||||
/**
|
||||
take an image and convert it to DXT1 (no alpha)
|
||||
**/
|
||||
unsigned char*
|
||||
convert_image_to_DXT1
|
||||
(
|
||||
const unsigned char *const uncompressed,
|
||||
int width, int height, int channels,
|
||||
int *out_size
|
||||
);
|
||||
|
||||
/**
|
||||
take an image and convert it to DXT5 (with alpha)
|
||||
**/
|
||||
unsigned char*
|
||||
convert_image_to_DXT5
|
||||
(
|
||||
const unsigned char *const uncompressed,
|
||||
int width, int height, int channels,
|
||||
int *out_size
|
||||
);
|
||||
|
||||
/** A bunch of DirectDraw Surface structures and flags **/
|
||||
typedef struct
|
||||
{
|
||||
unsigned int dwMagic;
|
||||
unsigned int dwSize;
|
||||
unsigned int dwFlags;
|
||||
unsigned int dwHeight;
|
||||
unsigned int dwWidth;
|
||||
unsigned int dwPitchOrLinearSize;
|
||||
unsigned int dwDepth;
|
||||
unsigned int dwMipMapCount;
|
||||
unsigned int dwReserved1[ 11 ];
|
||||
|
||||
/* DDPIXELFORMAT */
|
||||
struct
|
||||
{
|
||||
unsigned int dwSize;
|
||||
unsigned int dwFlags;
|
||||
unsigned int dwFourCC;
|
||||
unsigned int dwRGBBitCount;
|
||||
unsigned int dwRBitMask;
|
||||
unsigned int dwGBitMask;
|
||||
unsigned int dwBBitMask;
|
||||
unsigned int dwAlphaBitMask;
|
||||
}
|
||||
sPixelFormat;
|
||||
|
||||
/* DDCAPS2 */
|
||||
struct
|
||||
{
|
||||
unsigned int dwCaps1;
|
||||
unsigned int dwCaps2;
|
||||
unsigned int dwDDSX;
|
||||
unsigned int dwReserved;
|
||||
}
|
||||
sCaps;
|
||||
unsigned int dwReserved2;
|
||||
}
|
||||
DDS_header ;
|
||||
|
||||
/* the following constants were copied directly off the MSDN website */
|
||||
|
||||
/* The dwFlags member of the original DDSURFACEDESC2 structure
|
||||
can be set to one or more of the following values. */
|
||||
#define DDSD_CAPS 0x00000001
|
||||
#define DDSD_HEIGHT 0x00000002
|
||||
#define DDSD_WIDTH 0x00000004
|
||||
#define DDSD_PITCH 0x00000008
|
||||
#define DDSD_PIXELFORMAT 0x00001000
|
||||
#define DDSD_MIPMAPCOUNT 0x00020000
|
||||
#define DDSD_LINEARSIZE 0x00080000
|
||||
#define DDSD_DEPTH 0x00800000
|
||||
|
||||
/* DirectDraw Pixel Format */
|
||||
#define DDPF_ALPHAPIXELS 0x00000001
|
||||
#define DDPF_FOURCC 0x00000004
|
||||
#define DDPF_RGB 0x00000040
|
||||
|
||||
/* The dwCaps1 member of the DDSCAPS2 structure can be
|
||||
set to one or more of the following values. */
|
||||
#define DDSCAPS_COMPLEX 0x00000008
|
||||
#define DDSCAPS_TEXTURE 0x00001000
|
||||
#define DDSCAPS_MIPMAP 0x00400000
|
||||
|
||||
/* The dwCaps2 member of the DDSCAPS2 structure can be
|
||||
set to one or more of the following values. */
|
||||
#define DDSCAPS2_CUBEMAP 0x00000200
|
||||
#define DDSCAPS2_CUBEMAP_POSITIVEX 0x00000400
|
||||
#define DDSCAPS2_CUBEMAP_NEGATIVEX 0x00000800
|
||||
#define DDSCAPS2_CUBEMAP_POSITIVEY 0x00001000
|
||||
#define DDSCAPS2_CUBEMAP_NEGATIVEY 0x00002000
|
||||
#define DDSCAPS2_CUBEMAP_POSITIVEZ 0x00004000
|
||||
#define DDSCAPS2_CUBEMAP_NEGATIVEZ 0x00008000
|
||||
#define DDSCAPS2_VOLUME 0x00200000
|
||||
|
||||
#endif /* HEADER_IMAGE_DXT */
|
435
cw 8/src/SOIL/image_helper.c
Normal file
435
cw 8/src/SOIL/image_helper.c
Normal file
@ -0,0 +1,435 @@
|
||||
/*
|
||||
Jonathan Dummer
|
||||
|
||||
image helper functions
|
||||
|
||||
MIT license
|
||||
*/
|
||||
|
||||
#include "image_helper.h"
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
|
||||
/* Upscaling the image uses simple bilinear interpolation */
|
||||
int
|
||||
up_scale_image
|
||||
(
|
||||
const unsigned char* const orig,
|
||||
int width, int height, int channels,
|
||||
unsigned char* resampled,
|
||||
int resampled_width, int resampled_height
|
||||
)
|
||||
{
|
||||
float dx, dy;
|
||||
int x, y, c;
|
||||
|
||||
/* error(s) check */
|
||||
if ( (width < 1) || (height < 1) ||
|
||||
(resampled_width < 2) || (resampled_height < 2) ||
|
||||
(channels < 1) ||
|
||||
(NULL == orig) || (NULL == resampled) )
|
||||
{
|
||||
/* signify badness */
|
||||
return 0;
|
||||
}
|
||||
/*
|
||||
for each given pixel in the new map, find the exact location
|
||||
from the original map which would contribute to this guy
|
||||
*/
|
||||
dx = (width - 1.0f) / (resampled_width - 1.0f);
|
||||
dy = (height - 1.0f) / (resampled_height - 1.0f);
|
||||
for ( y = 0; y < resampled_height; ++y )
|
||||
{
|
||||
/* find the base y index and fractional offset from that */
|
||||
float sampley = y * dy;
|
||||
int inty = (int)sampley;
|
||||
/* if( inty < 0 ) { inty = 0; } else */
|
||||
if( inty > height - 2 ) { inty = height - 2; }
|
||||
sampley -= inty;
|
||||
for ( x = 0; x < resampled_width; ++x )
|
||||
{
|
||||
float samplex = x * dx;
|
||||
int intx = (int)samplex;
|
||||
int base_index;
|
||||
/* find the base x index and fractional offset from that */
|
||||
/* if( intx < 0 ) { intx = 0; } else */
|
||||
if( intx > width - 2 ) { intx = width - 2; }
|
||||
samplex -= intx;
|
||||
/* base index into the original image */
|
||||
base_index = (inty * width + intx) * channels;
|
||||
for ( c = 0; c < channels; ++c )
|
||||
{
|
||||
/* do the sampling */
|
||||
float value = 0.5f;
|
||||
value += orig[base_index]
|
||||
*(1.0f-samplex)*(1.0f-sampley);
|
||||
value += orig[base_index+channels]
|
||||
*(samplex)*(1.0f-sampley);
|
||||
value += orig[base_index+width*channels]
|
||||
*(1.0f-samplex)*(sampley);
|
||||
value += orig[base_index+width*channels+channels]
|
||||
*(samplex)*(sampley);
|
||||
/* move to the next channel */
|
||||
++base_index;
|
||||
/* save the new value */
|
||||
resampled[y*resampled_width*channels+x*channels+c] =
|
||||
(unsigned char)(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* done */
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
mipmap_image
|
||||
(
|
||||
const unsigned char* const orig,
|
||||
int width, int height, int channels,
|
||||
unsigned char* resampled,
|
||||
int block_size_x, int block_size_y
|
||||
)
|
||||
{
|
||||
int mip_width, mip_height;
|
||||
int i, j, c;
|
||||
|
||||
/* error check */
|
||||
if( (width < 1) || (height < 1) ||
|
||||
(channels < 1) || (orig == NULL) ||
|
||||
(resampled == NULL) ||
|
||||
(block_size_x < 1) || (block_size_y < 1) )
|
||||
{
|
||||
/* nothing to do */
|
||||
return 0;
|
||||
}
|
||||
mip_width = width / block_size_x;
|
||||
mip_height = height / block_size_y;
|
||||
if( mip_width < 1 )
|
||||
{
|
||||
mip_width = 1;
|
||||
}
|
||||
if( mip_height < 1 )
|
||||
{
|
||||
mip_height = 1;
|
||||
}
|
||||
for( j = 0; j < mip_height; ++j )
|
||||
{
|
||||
for( i = 0; i < mip_width; ++i )
|
||||
{
|
||||
for( c = 0; c < channels; ++c )
|
||||
{
|
||||
const int index = (j*block_size_y)*width*channels + (i*block_size_x)*channels + c;
|
||||
int sum_value;
|
||||
int u,v;
|
||||
int u_block = block_size_x;
|
||||
int v_block = block_size_y;
|
||||
int block_area;
|
||||
/* do a bit of checking so we don't over-run the boundaries
|
||||
(necessary for non-square textures!) */
|
||||
if( block_size_x * (i+1) > width )
|
||||
{
|
||||
u_block = width - i*block_size_y;
|
||||
}
|
||||
if( block_size_y * (j+1) > height )
|
||||
{
|
||||
v_block = height - j*block_size_y;
|
||||
}
|
||||
block_area = u_block*v_block;
|
||||
/* for this pixel, see what the average
|
||||
of all the values in the block are.
|
||||
note: start the sum at the rounding value, not at 0 */
|
||||
sum_value = block_area >> 1;
|
||||
for( v = 0; v < v_block; ++v )
|
||||
for( u = 0; u < u_block; ++u )
|
||||
{
|
||||
sum_value += orig[index + v*width*channels + u*channels];
|
||||
}
|
||||
resampled[j*mip_width*channels + i*channels + c] = sum_value / block_area;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
scale_image_RGB_to_NTSC_safe
|
||||
(
|
||||
unsigned char* orig,
|
||||
int width, int height, int channels
|
||||
)
|
||||
{
|
||||
const float scale_lo = 16.0f - 0.499f;
|
||||
const float scale_hi = 235.0f + 0.499f;
|
||||
int i, j;
|
||||
int nc = channels;
|
||||
unsigned char scale_LUT[256];
|
||||
/* error check */
|
||||
if( (width < 1) || (height < 1) ||
|
||||
(channels < 1) || (orig == NULL) )
|
||||
{
|
||||
/* nothing to do */
|
||||
return 0;
|
||||
}
|
||||
/* set up the scaling Look Up Table */
|
||||
for( i = 0; i < 256; ++i )
|
||||
{
|
||||
scale_LUT[i] = (unsigned char)((scale_hi - scale_lo) * i / 255.0f + scale_lo);
|
||||
}
|
||||
/* for channels = 2 or 4, ignore the alpha component */
|
||||
nc -= 1 - (channels & 1);
|
||||
/* OK, go through the image and scale any non-alpha components */
|
||||
for( i = 0; i < width*height*channels; i += channels )
|
||||
{
|
||||
for( j = 0; j < nc; ++j )
|
||||
{
|
||||
orig[i+j] = scale_LUT[orig[i+j]];
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
unsigned char clamp_byte( int x ) { return ( (x) < 0 ? (0) : ( (x) > 255 ? 255 : (x) ) ); }
|
||||
|
||||
/*
|
||||
This function takes the RGB components of the image
|
||||
and converts them into YCoCg. 3 components will be
|
||||
re-ordered to CoYCg (for optimum DXT1 compression),
|
||||
while 4 components will be ordered CoCgAY (for DXT5
|
||||
compression).
|
||||
*/
|
||||
int
|
||||
convert_RGB_to_YCoCg
|
||||
(
|
||||
unsigned char* orig,
|
||||
int width, int height, int channels
|
||||
)
|
||||
{
|
||||
int i;
|
||||
/* error check */
|
||||
if( (width < 1) || (height < 1) ||
|
||||
(channels < 3) || (channels > 4) ||
|
||||
(orig == NULL) )
|
||||
{
|
||||
/* nothing to do */
|
||||
return -1;
|
||||
}
|
||||
/* do the conversion */
|
||||
if( channels == 3 )
|
||||
{
|
||||
for( i = 0; i < width*height*3; i += 3 )
|
||||
{
|
||||
int r = orig[i+0];
|
||||
int g = (orig[i+1] + 1) >> 1;
|
||||
int b = orig[i+2];
|
||||
int tmp = (2 + r + b) >> 2;
|
||||
/* Co */
|
||||
orig[i+0] = clamp_byte( 128 + ((r - b + 1) >> 1) );
|
||||
/* Y */
|
||||
orig[i+1] = clamp_byte( g + tmp );
|
||||
/* Cg */
|
||||
orig[i+2] = clamp_byte( 128 + g - tmp );
|
||||
}
|
||||
} else
|
||||
{
|
||||
for( i = 0; i < width*height*4; i += 4 )
|
||||
{
|
||||
int r = orig[i+0];
|
||||
int g = (orig[i+1] + 1) >> 1;
|
||||
int b = orig[i+2];
|
||||
unsigned char a = orig[i+3];
|
||||
int tmp = (2 + r + b) >> 2;
|
||||
/* Co */
|
||||
orig[i+0] = clamp_byte( 128 + ((r - b + 1) >> 1) );
|
||||
/* Cg */
|
||||
orig[i+1] = clamp_byte( 128 + g - tmp );
|
||||
/* Alpha */
|
||||
orig[i+2] = a;
|
||||
/* Y */
|
||||
orig[i+3] = clamp_byte( g + tmp );
|
||||
}
|
||||
}
|
||||
/* done */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
This function takes the YCoCg components of the image
|
||||
and converts them into RGB. See above.
|
||||
*/
|
||||
int
|
||||
convert_YCoCg_to_RGB
|
||||
(
|
||||
unsigned char* orig,
|
||||
int width, int height, int channels
|
||||
)
|
||||
{
|
||||
int i;
|
||||
/* error check */
|
||||
if( (width < 1) || (height < 1) ||
|
||||
(channels < 3) || (channels > 4) ||
|
||||
(orig == NULL) )
|
||||
{
|
||||
/* nothing to do */
|
||||
return -1;
|
||||
}
|
||||
/* do the conversion */
|
||||
if( channels == 3 )
|
||||
{
|
||||
for( i = 0; i < width*height*3; i += 3 )
|
||||
{
|
||||
int co = orig[i+0] - 128;
|
||||
int y = orig[i+1];
|
||||
int cg = orig[i+2] - 128;
|
||||
/* R */
|
||||
orig[i+0] = clamp_byte( y + co - cg );
|
||||
/* G */
|
||||
orig[i+1] = clamp_byte( y + cg );
|
||||
/* B */
|
||||
orig[i+2] = clamp_byte( y - co - cg );
|
||||
}
|
||||
} else
|
||||
{
|
||||
for( i = 0; i < width*height*4; i += 4 )
|
||||
{
|
||||
int co = orig[i+0] - 128;
|
||||
int cg = orig[i+1] - 128;
|
||||
unsigned char a = orig[i+2];
|
||||
int y = orig[i+3];
|
||||
/* R */
|
||||
orig[i+0] = clamp_byte( y + co - cg );
|
||||
/* G */
|
||||
orig[i+1] = clamp_byte( y + cg );
|
||||
/* B */
|
||||
orig[i+2] = clamp_byte( y - co - cg );
|
||||
/* A */
|
||||
orig[i+3] = a;
|
||||
}
|
||||
}
|
||||
/* done */
|
||||
return 0;
|
||||
}
|
||||
|
||||
float
|
||||
find_max_RGBE
|
||||
(
|
||||
unsigned char *image,
|
||||
int width, int height
|
||||
)
|
||||
{
|
||||
float max_val = 0.0f;
|
||||
unsigned char *img = image;
|
||||
int i, j;
|
||||
for( i = width * height; i > 0; --i )
|
||||
{
|
||||
/* float scale = powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
|
||||
float scale = ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
|
||||
for( j = 0; j < 3; ++j )
|
||||
{
|
||||
if( img[j] * scale > max_val )
|
||||
{
|
||||
max_val = img[j] * scale;
|
||||
}
|
||||
}
|
||||
/* next pixel */
|
||||
img += 4;
|
||||
}
|
||||
return max_val;
|
||||
}
|
||||
|
||||
int
|
||||
RGBE_to_RGBdivA
|
||||
(
|
||||
unsigned char *image,
|
||||
int width, int height,
|
||||
int rescale_to_max
|
||||
)
|
||||
{
|
||||
/* local variables */
|
||||
int i, iv;
|
||||
unsigned char *img = image;
|
||||
float scale = 1.0f;
|
||||
/* error check */
|
||||
if( (!image) || (width < 1) || (height < 1) )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
/* convert (note: no negative numbers, but 0.0 is possible) */
|
||||
if( rescale_to_max )
|
||||
{
|
||||
scale = 255.0f / find_max_RGBE( image, width, height );
|
||||
}
|
||||
for( i = width * height; i > 0; --i )
|
||||
{
|
||||
/* decode this pixel, and find the max */
|
||||
float r,g,b,e, m;
|
||||
/* e = scale * powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
|
||||
e = scale * ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
|
||||
r = e * img[0];
|
||||
g = e * img[1];
|
||||
b = e * img[2];
|
||||
m = (r > g) ? r : g;
|
||||
m = (b > m) ? b : m;
|
||||
/* and encode it into RGBdivA */
|
||||
iv = (m != 0.0f) ? (int)(255.0f / m) : 1.0f;
|
||||
iv = (iv < 1) ? 1 : iv;
|
||||
img[3] = (iv > 255) ? 255 : iv;
|
||||
iv = (int)(img[3] * r + 0.5f);
|
||||
img[0] = (iv > 255) ? 255 : iv;
|
||||
iv = (int)(img[3] * g + 0.5f);
|
||||
img[1] = (iv > 255) ? 255 : iv;
|
||||
iv = (int)(img[3] * b + 0.5f);
|
||||
img[2] = (iv > 255) ? 255 : iv;
|
||||
/* and on to the next pixel */
|
||||
img += 4;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
RGBE_to_RGBdivA2
|
||||
(
|
||||
unsigned char *image,
|
||||
int width, int height,
|
||||
int rescale_to_max
|
||||
)
|
||||
{
|
||||
/* local variables */
|
||||
int i, iv;
|
||||
unsigned char *img = image;
|
||||
float scale = 1.0f;
|
||||
/* error check */
|
||||
if( (!image) || (width < 1) || (height < 1) )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
/* convert (note: no negative numbers, but 0.0 is possible) */
|
||||
if( rescale_to_max )
|
||||
{
|
||||
scale = 255.0f * 255.0f / find_max_RGBE( image, width, height );
|
||||
}
|
||||
for( i = width * height; i > 0; --i )
|
||||
{
|
||||
/* decode this pixel, and find the max */
|
||||
float r,g,b,e, m;
|
||||
/* e = scale * powf( 2.0f, img[3] - 128.0f ) / 255.0f; */
|
||||
e = scale * ldexp( 1.0f / 255.0f, (int)(img[3]) - 128 );
|
||||
r = e * img[0];
|
||||
g = e * img[1];
|
||||
b = e * img[2];
|
||||
m = (r > g) ? r : g;
|
||||
m = (b > m) ? b : m;
|
||||
/* and encode it into RGBdivA */
|
||||
iv = (m != 0.0f) ? (int)sqrtf( 255.0f * 255.0f / m ) : 1.0f;
|
||||
iv = (iv < 1) ? 1 : iv;
|
||||
img[3] = (iv > 255) ? 255 : iv;
|
||||
iv = (int)(img[3] * img[3] * r / 255.0f + 0.5f);
|
||||
img[0] = (iv > 255) ? 255 : iv;
|
||||
iv = (int)(img[3] * img[3] * g / 255.0f + 0.5f);
|
||||
img[1] = (iv > 255) ? 255 : iv;
|
||||
iv = (int)(img[3] * img[3] * b / 255.0f + 0.5f);
|
||||
img[2] = (iv > 255) ? 255 : iv;
|
||||
/* and on to the next pixel */
|
||||
img += 4;
|
||||
}
|
||||
return 1;
|
||||
}
|
115
cw 8/src/SOIL/image_helper.h
Normal file
115
cw 8/src/SOIL/image_helper.h
Normal file
@ -0,0 +1,115 @@
|
||||
/*
|
||||
Jonathan Dummer
|
||||
|
||||
Image helper functions
|
||||
|
||||
MIT license
|
||||
*/
|
||||
|
||||
#ifndef HEADER_IMAGE_HELPER
|
||||
#define HEADER_IMAGE_HELPER
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
This function upscales an image.
|
||||
Not to be used to create MIPmaps,
|
||||
but to make it square,
|
||||
or to make it a power-of-two sized.
|
||||
**/
|
||||
int
|
||||
up_scale_image
|
||||
(
|
||||
const unsigned char* const orig,
|
||||
int width, int height, int channels,
|
||||
unsigned char* resampled,
|
||||
int resampled_width, int resampled_height
|
||||
);
|
||||
|
||||
/**
|
||||
This function downscales an image.
|
||||
Used for creating MIPmaps,
|
||||
the incoming image should be a
|
||||
power-of-two sized.
|
||||
**/
|
||||
int
|
||||
mipmap_image
|
||||
(
|
||||
const unsigned char* const orig,
|
||||
int width, int height, int channels,
|
||||
unsigned char* resampled,
|
||||
int block_size_x, int block_size_y
|
||||
);
|
||||
|
||||
/**
|
||||
This function takes the RGB components of the image
|
||||
and scales each channel from [0,255] to [16,235].
|
||||
This makes the colors "Safe" for display on NTSC
|
||||
displays. Note that this is _NOT_ a good idea for
|
||||
loading images like normal- or height-maps!
|
||||
**/
|
||||
int
|
||||
scale_image_RGB_to_NTSC_safe
|
||||
(
|
||||
unsigned char* orig,
|
||||
int width, int height, int channels
|
||||
);
|
||||
|
||||
/**
|
||||
This function takes the RGB components of the image
|
||||
and converts them into YCoCg. 3 components will be
|
||||
re-ordered to CoYCg (for optimum DXT1 compression),
|
||||
while 4 components will be ordered CoCgAY (for DXT5
|
||||
compression).
|
||||
**/
|
||||
int
|
||||
convert_RGB_to_YCoCg
|
||||
(
|
||||
unsigned char* orig,
|
||||
int width, int height, int channels
|
||||
);
|
||||
|
||||
/**
|
||||
This function takes the YCoCg components of the image
|
||||
and converts them into RGB. See above.
|
||||
**/
|
||||
int
|
||||
convert_YCoCg_to_RGB
|
||||
(
|
||||
unsigned char* orig,
|
||||
int width, int height, int channels
|
||||
);
|
||||
|
||||
/**
|
||||
Converts an HDR image from an array
|
||||
of unsigned chars (RGBE) to RGBdivA
|
||||
\return 0 if failed, otherwise returns 1
|
||||
**/
|
||||
int
|
||||
RGBE_to_RGBdivA
|
||||
(
|
||||
unsigned char *image,
|
||||
int width, int height,
|
||||
int rescale_to_max
|
||||
);
|
||||
|
||||
/**
|
||||
Converts an HDR image from an array
|
||||
of unsigned chars (RGBE) to RGBdivA2
|
||||
\return 0 if failed, otherwise returns 1
|
||||
**/
|
||||
int
|
||||
RGBE_to_RGBdivA2
|
||||
(
|
||||
unsigned char *image,
|
||||
int width, int height,
|
||||
int rescale_to_max
|
||||
);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* HEADER_IMAGE_HELPER */
|
3682
cw 8/src/SOIL/stb_image_aug.c
Normal file
3682
cw 8/src/SOIL/stb_image_aug.c
Normal file
File diff suppressed because it is too large
Load Diff
354
cw 8/src/SOIL/stb_image_aug.h
Normal file
354
cw 8/src/SOIL/stb_image_aug.h
Normal file
@ -0,0 +1,354 @@
|
||||
/* stbi-1.16 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
|
||||
when you control the images you're loading
|
||||
|
||||
QUICK NOTES:
|
||||
Primarily of interest to game developers and other people who can
|
||||
avoid problematic images and only need the trivial interface
|
||||
|
||||
JPEG baseline (no JPEG progressive, no oddball channel decimations)
|
||||
PNG non-interlaced
|
||||
BMP non-1bpp, non-RLE
|
||||
TGA (not sure what subset, if a subset)
|
||||
PSD (composited view only, no extra channels)
|
||||
HDR (radiance rgbE format)
|
||||
writes BMP,TGA (define STBI_NO_WRITE to remove code)
|
||||
decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code)
|
||||
supports installable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
|
||||
|
||||
TODO:
|
||||
stbi_info_*
|
||||
|
||||
history:
|
||||
1.16 major bugfix - convert_format converted one too many pixels
|
||||
1.15 initialize some fields for thread safety
|
||||
1.14 fix threadsafe conversion bug; header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
|
||||
1.13 threadsafe
|
||||
1.12 const qualifiers in the API
|
||||
1.11 Support installable IDCT, colorspace conversion routines
|
||||
1.10 Fixes for 64-bit (don't use "unsigned long")
|
||||
optimized upsampling by Fabian "ryg" Giesen
|
||||
1.09 Fix format-conversion for PSD code (bad global variables!)
|
||||
1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz
|
||||
1.07 attempt to fix C++ warning/errors again
|
||||
1.06 attempt to fix C++ warning/errors again
|
||||
1.05 fix TGA loading to return correct *comp and use good luminance calc
|
||||
1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free
|
||||
1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR
|
||||
1.02 support for (subset of) HDR files, float interface for preferred access to them
|
||||
1.01 fix bug: possible bug in handling right-side up bmps... not sure
|
||||
fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all
|
||||
1.00 interface to zlib that skips zlib header
|
||||
0.99 correct handling of alpha in palette
|
||||
0.98 TGA loader by lonesock; dynamically add loaders (untested)
|
||||
0.97 jpeg errors on too large a file; also catch another malloc failure
|
||||
0.96 fix detection of invalid v value - particleman@mollyrocket forum
|
||||
0.95 during header scan, seek to markers in case of padding
|
||||
0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same
|
||||
0.93 handle jpegtran output; verbose errors
|
||||
0.92 read 4,8,16,24,32-bit BMP files of several formats
|
||||
0.91 output 24-bit Windows 3.0 BMP files
|
||||
0.90 fix a few more warnings; bump version number to approach 1.0
|
||||
0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd
|
||||
0.60 fix compiling as c++
|
||||
0.59 fix warnings: merge Dave Moore's -Wall fixes
|
||||
0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian
|
||||
0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less
|
||||
than 16 available
|
||||
0.56 fix bug: zlib uncompressed mode len vs. nlen
|
||||
0.55 fix bug: restart_interval not initialized to 0
|
||||
0.54 allow NULL for 'int *comp'
|
||||
0.53 fix bug in png 3->4; speedup png decoding
|
||||
0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments
|
||||
0.51 obey req_comp requests, 1-component jpegs return as 1-component,
|
||||
on 'test' only check type, not whether we support this variant
|
||||
*/
|
||||
|
||||
#ifndef HEADER_STB_IMAGE_AUGMENTED
|
||||
#define HEADER_STB_IMAGE_AUGMENTED
|
||||
|
||||
//// begin header file ////////////////////////////////////////////////////
|
||||
//
|
||||
// Limitations:
|
||||
// - no progressive/interlaced support (jpeg, png)
|
||||
// - 8-bit samples only (jpeg, png)
|
||||
// - not threadsafe
|
||||
// - channel subsampling of at most 2 in each dimension (jpeg)
|
||||
// - no delayed line count (jpeg) -- IJG doesn't support either
|
||||
//
|
||||
// Basic usage (see HDR discussion below):
|
||||
// int x,y,n;
|
||||
// unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
|
||||
// // ... process data if not NULL ...
|
||||
// // ... x = width, y = height, n = # 8-bit components per pixel ...
|
||||
// // ... replace '0' with '1'..'4' to force that many components per pixel
|
||||
// stbi_image_free(data)
|
||||
//
|
||||
// Standard parameters:
|
||||
// int *x -- outputs image width in pixels
|
||||
// int *y -- outputs image height in pixels
|
||||
// int *comp -- outputs # of image components in image file
|
||||
// int req_comp -- if non-zero, # of image components requested in result
|
||||
//
|
||||
// The return value from an image loader is an 'unsigned char *' which points
|
||||
// to the pixel data. The pixel data consists of *y scanlines of *x pixels,
|
||||
// with each pixel consisting of N interleaved 8-bit components; the first
|
||||
// pixel pointed to is top-left-most in the image. There is no padding between
|
||||
// image scanlines or between pixels, regardless of format. The number of
|
||||
// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
|
||||
// If req_comp is non-zero, *comp has the number of components that _would_
|
||||
// have been output otherwise. E.g. if you set req_comp to 4, you will always
|
||||
// get RGBA output, but you can check *comp to easily see if it's opaque.
|
||||
//
|
||||
// An output image with N components has the following components interleaved
|
||||
// in this order in each pixel:
|
||||
//
|
||||
// N=#comp components
|
||||
// 1 grey
|
||||
// 2 grey, alpha
|
||||
// 3 red, green, blue
|
||||
// 4 red, green, blue, alpha
|
||||
//
|
||||
// If image loading fails for any reason, the return value will be NULL,
|
||||
// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
|
||||
// can be queried for an extremely brief, end-user unfriendly explanation
|
||||
// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
|
||||
// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
|
||||
// more user-friendly ones.
|
||||
//
|
||||
// Paletted PNG and BMP images are automatically depalettized.
|
||||
//
|
||||
//
|
||||
// ===========================================================================
|
||||
//
|
||||
// HDR image support (disable by defining STBI_NO_HDR)
|
||||
//
|
||||
// stb_image now supports loading HDR images in general, and currently
|
||||
// the Radiance .HDR file format, although the support is provided
|
||||
// generically. You can still load any file through the existing interface;
|
||||
// if you attempt to load an HDR file, it will be automatically remapped to
|
||||
// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
|
||||
// both of these constants can be reconfigured through this interface:
|
||||
//
|
||||
// stbi_hdr_to_ldr_gamma(2.2f);
|
||||
// stbi_hdr_to_ldr_scale(1.0f);
|
||||
//
|
||||
// (note, do not use _inverse_ constants; stbi_image will invert them
|
||||
// appropriately).
|
||||
//
|
||||
// Additionally, there is a new, parallel interface for loading files as
|
||||
// (linear) floats to preserve the full dynamic range:
|
||||
//
|
||||
// float *data = stbi_loadf(filename, &x, &y, &n, 0);
|
||||
//
|
||||
// If you load LDR images through this interface, those images will
|
||||
// be promoted to floating point values, run through the inverse of
|
||||
// constants corresponding to the above:
|
||||
//
|
||||
// stbi_ldr_to_hdr_scale(1.0f);
|
||||
// stbi_ldr_to_hdr_gamma(2.2f);
|
||||
//
|
||||
// Finally, given a filename (or an open file or memory block--see header
|
||||
// file for details) containing image data, you can query for the "most
|
||||
// appropriate" interface to use (that is, whether the image is HDR or
|
||||
// not), using:
|
||||
//
|
||||
// stbi_is_hdr(char *filename);
|
||||
|
||||
#ifndef STBI_NO_STDIO
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
|
||||
#define STBI_VERSION 1
|
||||
|
||||
enum
|
||||
{
|
||||
STBI_default = 0, // only used for req_comp
|
||||
|
||||
STBI_grey = 1,
|
||||
STBI_grey_alpha = 2,
|
||||
STBI_rgb = 3,
|
||||
STBI_rgb_alpha = 4,
|
||||
};
|
||||
|
||||
typedef unsigned char stbi_uc;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// WRITING API
|
||||
|
||||
#if !defined(STBI_NO_WRITE) && !defined(STBI_NO_STDIO)
|
||||
// write a BMP/TGA file given tightly packed 'comp' channels (no padding, nor bmp-stride-padding)
|
||||
// (you must include the appropriate extension in the filename).
|
||||
// returns TRUE on success, FALSE if couldn't open file, error writing file
|
||||
extern int stbi_write_bmp (char const *filename, int x, int y, int comp, void *data);
|
||||
extern int stbi_write_tga (char const *filename, int x, int y, int comp, void *data);
|
||||
#endif
|
||||
|
||||
// PRIMARY API - works on images of any type
|
||||
|
||||
// load image by filename, open file, or memory buffer
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
extern int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);
|
||||
#endif
|
||||
extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
// for stbi_load_from_file, file pointer is left pointing immediately after image
|
||||
|
||||
#ifndef STBI_NO_HDR
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
#endif
|
||||
extern float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
|
||||
extern void stbi_hdr_to_ldr_gamma(float gamma);
|
||||
extern void stbi_hdr_to_ldr_scale(float scale);
|
||||
|
||||
extern void stbi_ldr_to_hdr_gamma(float gamma);
|
||||
extern void stbi_ldr_to_hdr_scale(float scale);
|
||||
|
||||
#endif // STBI_NO_HDR
|
||||
|
||||
// get a VERY brief reason for failure
|
||||
// NOT THREADSAFE
|
||||
extern char *stbi_failure_reason (void);
|
||||
|
||||
// free the loaded image -- this is just free()
|
||||
extern void stbi_image_free (void *retval_from_stbi_load);
|
||||
|
||||
// get image dimensions & components without fully decoding
|
||||
extern int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
|
||||
extern int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern int stbi_info (char const *filename, int *x, int *y, int *comp);
|
||||
extern int stbi_is_hdr (char const *filename);
|
||||
extern int stbi_is_hdr_from_file(FILE *f);
|
||||
#endif
|
||||
|
||||
// ZLIB client - used by PNG, available for other purposes
|
||||
|
||||
extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
|
||||
extern char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
|
||||
extern int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
|
||||
|
||||
extern char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
|
||||
extern int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
|
||||
|
||||
// TYPE-SPECIFIC ACCESS
|
||||
|
||||
// is it a jpeg?
|
||||
extern int stbi_jpeg_test_memory (stbi_uc const *buffer, int len);
|
||||
extern stbi_uc *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
extern int stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
|
||||
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern stbi_uc *stbi_jpeg_load (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern int stbi_jpeg_test_file (FILE *f);
|
||||
extern stbi_uc *stbi_jpeg_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
|
||||
extern int stbi_jpeg_info (char const *filename, int *x, int *y, int *comp);
|
||||
extern int stbi_jpeg_info_from_file (FILE *f, int *x, int *y, int *comp);
|
||||
#endif
|
||||
|
||||
// is it a png?
|
||||
extern int stbi_png_test_memory (stbi_uc const *buffer, int len);
|
||||
extern stbi_uc *stbi_png_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
extern int stbi_png_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp);
|
||||
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern stbi_uc *stbi_png_load (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern int stbi_png_info (char const *filename, int *x, int *y, int *comp);
|
||||
extern int stbi_png_test_file (FILE *f);
|
||||
extern stbi_uc *stbi_png_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
extern int stbi_png_info_from_file (FILE *f, int *x, int *y, int *comp);
|
||||
#endif
|
||||
|
||||
// is it a bmp?
|
||||
extern int stbi_bmp_test_memory (stbi_uc const *buffer, int len);
|
||||
|
||||
extern stbi_uc *stbi_bmp_load (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern int stbi_bmp_test_file (FILE *f);
|
||||
extern stbi_uc *stbi_bmp_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
#endif
|
||||
|
||||
// is it a tga?
|
||||
extern int stbi_tga_test_memory (stbi_uc const *buffer, int len);
|
||||
|
||||
extern stbi_uc *stbi_tga_load (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern int stbi_tga_test_file (FILE *f);
|
||||
extern stbi_uc *stbi_tga_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
#endif
|
||||
|
||||
// is it a psd?
|
||||
extern int stbi_psd_test_memory (stbi_uc const *buffer, int len);
|
||||
|
||||
extern stbi_uc *stbi_psd_load (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern int stbi_psd_test_file (FILE *f);
|
||||
extern stbi_uc *stbi_psd_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
#endif
|
||||
|
||||
// is it an hdr?
|
||||
extern int stbi_hdr_test_memory (stbi_uc const *buffer, int len);
|
||||
|
||||
extern float * stbi_hdr_load (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern float * stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
extern stbi_uc *stbi_hdr_load_rgbe (char const *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern float * stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern int stbi_hdr_test_file (FILE *f);
|
||||
extern float * stbi_hdr_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
extern stbi_uc *stbi_hdr_load_rgbe_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
#endif
|
||||
|
||||
// define new loaders
|
||||
typedef struct
|
||||
{
|
||||
int (*test_memory)(stbi_uc const *buffer, int len);
|
||||
stbi_uc * (*load_from_memory)(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
#ifndef STBI_NO_STDIO
|
||||
int (*test_file)(FILE *f);
|
||||
stbi_uc * (*load_from_file)(FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
#endif
|
||||
} stbi_loader;
|
||||
|
||||
// register a loader by filling out the above structure (you must defined ALL functions)
|
||||
// returns 1 if added or already added, 0 if not added (too many loaders)
|
||||
// NOT THREADSAFE
|
||||
extern int stbi_register_loader(stbi_loader *loader);
|
||||
|
||||
// define faster low-level operations (typically SIMD support)
|
||||
#if STBI_SIMD
|
||||
typedef void (*stbi_idct_8x8)(uint8 *out, int out_stride, short data[64], unsigned short *dequantize);
|
||||
// compute an integer IDCT on "input"
|
||||
// input[x] = data[x] * dequantize[x]
|
||||
// write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
|
||||
// CLAMP results to 0..255
|
||||
typedef void (*stbi_YCbCr_to_RGB_run)(uint8 *output, uint8 const *y, uint8 const *cb, uint8 const *cr, int count, int step);
|
||||
// compute a conversion from YCbCr to RGB
|
||||
// 'count' pixels
|
||||
// write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
|
||||
// y: Y input channel
|
||||
// cb: Cb input channel; scale/biased to be 0..255
|
||||
// cr: Cr input channel; scale/biased to be 0..255
|
||||
|
||||
extern void stbi_install_idct(stbi_idct_8x8 func);
|
||||
extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
|
||||
#endif // STBI_SIMD
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
//
|
||||
//
|
||||
//// end header file /////////////////////////////////////////////////////
|
||||
#endif // STBI_INCLUDE_STB_IMAGE_H
|
21
cw 8/src/SOIL/stbi_DDS_aug.h
Normal file
21
cw 8/src/SOIL/stbi_DDS_aug.h
Normal file
@ -0,0 +1,21 @@
|
||||
/*
|
||||
adding DDS loading support to stbi
|
||||
*/
|
||||
|
||||
#ifndef HEADER_STB_IMAGE_DDS_AUGMENTATION
|
||||
#define HEADER_STB_IMAGE_DDS_AUGMENTATION
|
||||
|
||||
// is it a DDS file?
|
||||
extern int stbi_dds_test_memory (stbi_uc const *buffer, int len);
|
||||
|
||||
extern stbi_uc *stbi_dds_load (char *filename, int *x, int *y, int *comp, int req_comp);
|
||||
extern stbi_uc *stbi_dds_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
|
||||
#ifndef STBI_NO_STDIO
|
||||
extern int stbi_dds_test_file (FILE *f);
|
||||
extern stbi_uc *stbi_dds_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
|
||||
#endif
|
||||
|
||||
//
|
||||
//
|
||||
//// end header file /////////////////////////////////////////////////////
|
||||
#endif // HEADER_STB_IMAGE_DDS_AUGMENTATION
|
511
cw 8/src/SOIL/stbi_DDS_aug_c.h
Normal file
511
cw 8/src/SOIL/stbi_DDS_aug_c.h
Normal file
@ -0,0 +1,511 @@
|
||||
|
||||
/// DDS file support, does decoding, _not_ direct uploading
|
||||
/// (use SOIL for that ;-)
|
||||
|
||||
/// A bunch of DirectDraw Surface structures and flags
|
||||
typedef struct {
|
||||
unsigned int dwMagic;
|
||||
unsigned int dwSize;
|
||||
unsigned int dwFlags;
|
||||
unsigned int dwHeight;
|
||||
unsigned int dwWidth;
|
||||
unsigned int dwPitchOrLinearSize;
|
||||
unsigned int dwDepth;
|
||||
unsigned int dwMipMapCount;
|
||||
unsigned int dwReserved1[ 11 ];
|
||||
|
||||
// DDPIXELFORMAT
|
||||
struct {
|
||||
unsigned int dwSize;
|
||||
unsigned int dwFlags;
|
||||
unsigned int dwFourCC;
|
||||
unsigned int dwRGBBitCount;
|
||||
unsigned int dwRBitMask;
|
||||
unsigned int dwGBitMask;
|
||||
unsigned int dwBBitMask;
|
||||
unsigned int dwAlphaBitMask;
|
||||
} sPixelFormat;
|
||||
|
||||
// DDCAPS2
|
||||
struct {
|
||||
unsigned int dwCaps1;
|
||||
unsigned int dwCaps2;
|
||||
unsigned int dwDDSX;
|
||||
unsigned int dwReserved;
|
||||
} sCaps;
|
||||
unsigned int dwReserved2;
|
||||
} DDS_header ;
|
||||
|
||||
// the following constants were copied directly off the MSDN website
|
||||
|
||||
// The dwFlags member of the original DDSURFACEDESC2 structure
|
||||
// can be set to one or more of the following values.
|
||||
#define DDSD_CAPS 0x00000001
|
||||
#define DDSD_HEIGHT 0x00000002
|
||||
#define DDSD_WIDTH 0x00000004
|
||||
#define DDSD_PITCH 0x00000008
|
||||
#define DDSD_PIXELFORMAT 0x00001000
|
||||
#define DDSD_MIPMAPCOUNT 0x00020000
|
||||
#define DDSD_LINEARSIZE 0x00080000
|
||||
#define DDSD_DEPTH 0x00800000
|
||||
|
||||
// DirectDraw Pixel Format
|
||||
#define DDPF_ALPHAPIXELS 0x00000001
|
||||
#define DDPF_FOURCC 0x00000004
|
||||
#define DDPF_RGB 0x00000040
|
||||
|
||||
// The dwCaps1 member of the DDSCAPS2 structure can be
|
||||
// set to one or more of the following values.
|
||||
#define DDSCAPS_COMPLEX 0x00000008
|
||||
#define DDSCAPS_TEXTURE 0x00001000
|
||||
#define DDSCAPS_MIPMAP 0x00400000
|
||||
|
||||
// The dwCaps2 member of the DDSCAPS2 structure can be
|
||||
// set to one or more of the following values.
|
||||
#define DDSCAPS2_CUBEMAP 0x00000200
|
||||
#define DDSCAPS2_CUBEMAP_POSITIVEX 0x00000400
|
||||
#define DDSCAPS2_CUBEMAP_NEGATIVEX 0x00000800
|
||||
#define DDSCAPS2_CUBEMAP_POSITIVEY 0x00001000
|
||||
#define DDSCAPS2_CUBEMAP_NEGATIVEY 0x00002000
|
||||
#define DDSCAPS2_CUBEMAP_POSITIVEZ 0x00004000
|
||||
#define DDSCAPS2_CUBEMAP_NEGATIVEZ 0x00008000
|
||||
#define DDSCAPS2_VOLUME 0x00200000
|
||||
|
||||
static int dds_test(stbi *s)
|
||||
{
|
||||
// check the magic number
|
||||
if (get8(s) != 'D') return 0;
|
||||
if (get8(s) != 'D') return 0;
|
||||
if (get8(s) != 'S') return 0;
|
||||
if (get8(s) != ' ') return 0;
|
||||
// check header size
|
||||
if (get32le(s) != 124) return 0;
|
||||
return 1;
|
||||
}
|
||||
#ifndef STBI_NO_STDIO
|
||||
int stbi_dds_test_file (FILE *f)
|
||||
{
|
||||
stbi s;
|
||||
int r,n = ftell(f);
|
||||
start_file(&s,f);
|
||||
r = dds_test(&s);
|
||||
fseek(f,n,SEEK_SET);
|
||||
return r;
|
||||
}
|
||||
#endif
|
||||
|
||||
int stbi_dds_test_memory (stbi_uc const *buffer, int len)
|
||||
{
|
||||
stbi s;
|
||||
start_mem(&s,buffer, len);
|
||||
return dds_test(&s);
|
||||
}
|
||||
|
||||
// helper functions
|
||||
int stbi_convert_bit_range( int c, int from_bits, int to_bits )
|
||||
{
|
||||
int b = (1 << (from_bits - 1)) + c * ((1 << to_bits) - 1);
|
||||
return (b + (b >> from_bits)) >> from_bits;
|
||||
}
|
||||
void stbi_rgb_888_from_565( unsigned int c, int *r, int *g, int *b )
|
||||
{
|
||||
*r = stbi_convert_bit_range( (c >> 11) & 31, 5, 8 );
|
||||
*g = stbi_convert_bit_range( (c >> 05) & 63, 6, 8 );
|
||||
*b = stbi_convert_bit_range( (c >> 00) & 31, 5, 8 );
|
||||
}
|
||||
void stbi_decode_DXT1_block(
|
||||
unsigned char uncompressed[16*4],
|
||||
unsigned char compressed[8] )
|
||||
{
|
||||
int next_bit = 4*8;
|
||||
int i, r, g, b;
|
||||
int c0, c1;
|
||||
unsigned char decode_colors[4*4];
|
||||
// find the 2 primary colors
|
||||
c0 = compressed[0] + (compressed[1] << 8);
|
||||
c1 = compressed[2] + (compressed[3] << 8);
|
||||
stbi_rgb_888_from_565( c0, &r, &g, &b );
|
||||
decode_colors[0] = r;
|
||||
decode_colors[1] = g;
|
||||
decode_colors[2] = b;
|
||||
decode_colors[3] = 255;
|
||||
stbi_rgb_888_from_565( c1, &r, &g, &b );
|
||||
decode_colors[4] = r;
|
||||
decode_colors[5] = g;
|
||||
decode_colors[6] = b;
|
||||
decode_colors[7] = 255;
|
||||
if( c0 > c1 )
|
||||
{
|
||||
// no alpha, 2 interpolated colors
|
||||
decode_colors[8] = (2*decode_colors[0] + decode_colors[4]) / 3;
|
||||
decode_colors[9] = (2*decode_colors[1] + decode_colors[5]) / 3;
|
||||
decode_colors[10] = (2*decode_colors[2] + decode_colors[6]) / 3;
|
||||
decode_colors[11] = 255;
|
||||
decode_colors[12] = (decode_colors[0] + 2*decode_colors[4]) / 3;
|
||||
decode_colors[13] = (decode_colors[1] + 2*decode_colors[5]) / 3;
|
||||
decode_colors[14] = (decode_colors[2] + 2*decode_colors[6]) / 3;
|
||||
decode_colors[15] = 255;
|
||||
} else
|
||||
{
|
||||
// 1 interpolated color, alpha
|
||||
decode_colors[8] = (decode_colors[0] + decode_colors[4]) / 2;
|
||||
decode_colors[9] = (decode_colors[1] + decode_colors[5]) / 2;
|
||||
decode_colors[10] = (decode_colors[2] + decode_colors[6]) / 2;
|
||||
decode_colors[11] = 255;
|
||||
decode_colors[12] = 0;
|
||||
decode_colors[13] = 0;
|
||||
decode_colors[14] = 0;
|
||||
decode_colors[15] = 0;
|
||||
}
|
||||
// decode the block
|
||||
for( i = 0; i < 16*4; i += 4 )
|
||||
{
|
||||
int idx = ((compressed[next_bit>>3] >> (next_bit & 7)) & 3) * 4;
|
||||
next_bit += 2;
|
||||
uncompressed[i+0] = decode_colors[idx+0];
|
||||
uncompressed[i+1] = decode_colors[idx+1];
|
||||
uncompressed[i+2] = decode_colors[idx+2];
|
||||
uncompressed[i+3] = decode_colors[idx+3];
|
||||
}
|
||||
// done
|
||||
}
|
||||
void stbi_decode_DXT23_alpha_block(
|
||||
unsigned char uncompressed[16*4],
|
||||
unsigned char compressed[8] )
|
||||
{
|
||||
int i, next_bit = 0;
|
||||
// each alpha value gets 4 bits
|
||||
for( i = 3; i < 16*4; i += 4 )
|
||||
{
|
||||
uncompressed[i] = stbi_convert_bit_range(
|
||||
(compressed[next_bit>>3] >> (next_bit&7)) & 15,
|
||||
4, 8 );
|
||||
next_bit += 4;
|
||||
}
|
||||
}
|
||||
void stbi_decode_DXT45_alpha_block(
|
||||
unsigned char uncompressed[16*4],
|
||||
unsigned char compressed[8] )
|
||||
{
|
||||
int i, next_bit = 8*2;
|
||||
unsigned char decode_alpha[8];
|
||||
// each alpha value gets 3 bits, and the 1st 2 bytes are the range
|
||||
decode_alpha[0] = compressed[0];
|
||||
decode_alpha[1] = compressed[1];
|
||||
if( decode_alpha[0] > decode_alpha[1] )
|
||||
{
|
||||
// 6 step intermediate
|
||||
decode_alpha[2] = (6*decode_alpha[0] + 1*decode_alpha[1]) / 7;
|
||||
decode_alpha[3] = (5*decode_alpha[0] + 2*decode_alpha[1]) / 7;
|
||||
decode_alpha[4] = (4*decode_alpha[0] + 3*decode_alpha[1]) / 7;
|
||||
decode_alpha[5] = (3*decode_alpha[0] + 4*decode_alpha[1]) / 7;
|
||||
decode_alpha[6] = (2*decode_alpha[0] + 5*decode_alpha[1]) / 7;
|
||||
decode_alpha[7] = (1*decode_alpha[0] + 6*decode_alpha[1]) / 7;
|
||||
} else
|
||||
{
|
||||
// 4 step intermediate, pluss full and none
|
||||
decode_alpha[2] = (4*decode_alpha[0] + 1*decode_alpha[1]) / 5;
|
||||
decode_alpha[3] = (3*decode_alpha[0] + 2*decode_alpha[1]) / 5;
|
||||
decode_alpha[4] = (2*decode_alpha[0] + 3*decode_alpha[1]) / 5;
|
||||
decode_alpha[5] = (1*decode_alpha[0] + 4*decode_alpha[1]) / 5;
|
||||
decode_alpha[6] = 0;
|
||||
decode_alpha[7] = 255;
|
||||
}
|
||||
for( i = 3; i < 16*4; i += 4 )
|
||||
{
|
||||
int idx = 0, bit;
|
||||
bit = (compressed[next_bit>>3] >> (next_bit&7)) & 1;
|
||||
idx += bit << 0;
|
||||
++next_bit;
|
||||
bit = (compressed[next_bit>>3] >> (next_bit&7)) & 1;
|
||||
idx += bit << 1;
|
||||
++next_bit;
|
||||
bit = (compressed[next_bit>>3] >> (next_bit&7)) & 1;
|
||||
idx += bit << 2;
|
||||
++next_bit;
|
||||
uncompressed[i] = decode_alpha[idx & 7];
|
||||
}
|
||||
// done
|
||||
}
|
||||
void stbi_decode_DXT_color_block(
|
||||
unsigned char uncompressed[16*4],
|
||||
unsigned char compressed[8] )
|
||||
{
|
||||
int next_bit = 4*8;
|
||||
int i, r, g, b;
|
||||
int c0, c1;
|
||||
unsigned char decode_colors[4*3];
|
||||
// find the 2 primary colors
|
||||
c0 = compressed[0] + (compressed[1] << 8);
|
||||
c1 = compressed[2] + (compressed[3] << 8);
|
||||
stbi_rgb_888_from_565( c0, &r, &g, &b );
|
||||
decode_colors[0] = r;
|
||||
decode_colors[1] = g;
|
||||
decode_colors[2] = b;
|
||||
stbi_rgb_888_from_565( c1, &r, &g, &b );
|
||||
decode_colors[3] = r;
|
||||
decode_colors[4] = g;
|
||||
decode_colors[5] = b;
|
||||
// Like DXT1, but no choicees:
|
||||
// no alpha, 2 interpolated colors
|
||||
decode_colors[6] = (2*decode_colors[0] + decode_colors[3]) / 3;
|
||||
decode_colors[7] = (2*decode_colors[1] + decode_colors[4]) / 3;
|
||||
decode_colors[8] = (2*decode_colors[2] + decode_colors[5]) / 3;
|
||||
decode_colors[9] = (decode_colors[0] + 2*decode_colors[3]) / 3;
|
||||
decode_colors[10] = (decode_colors[1] + 2*decode_colors[4]) / 3;
|
||||
decode_colors[11] = (decode_colors[2] + 2*decode_colors[5]) / 3;
|
||||
// decode the block
|
||||
for( i = 0; i < 16*4; i += 4 )
|
||||
{
|
||||
int idx = ((compressed[next_bit>>3] >> (next_bit & 7)) & 3) * 3;
|
||||
next_bit += 2;
|
||||
uncompressed[i+0] = decode_colors[idx+0];
|
||||
uncompressed[i+1] = decode_colors[idx+1];
|
||||
uncompressed[i+2] = decode_colors[idx+2];
|
||||
}
|
||||
// done
|
||||
}
|
||||
static stbi_uc *dds_load(stbi *s, int *x, int *y, int *comp, int req_comp)
|
||||
{
|
||||
// all variables go up front
|
||||
stbi_uc *dds_data = NULL;
|
||||
stbi_uc block[16*4];
|
||||
stbi_uc compressed[8];
|
||||
int flags, DXT_family;
|
||||
int has_alpha, has_mipmap;
|
||||
int is_compressed, cubemap_faces;
|
||||
int block_pitch, num_blocks;
|
||||
DDS_header header;
|
||||
int i, sz, cf;
|
||||
// load the header
|
||||
if( sizeof( DDS_header ) != 128 )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
getn( s, (stbi_uc*)(&header), 128 );
|
||||
// and do some checking
|
||||
if( header.dwMagic != (('D' << 0) | ('D' << 8) | ('S' << 16) | (' ' << 24)) ) return NULL;
|
||||
if( header.dwSize != 124 ) return NULL;
|
||||
flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
|
||||
if( (header.dwFlags & flags) != flags ) return NULL;
|
||||
/* According to the MSDN spec, the dwFlags should contain
|
||||
DDSD_LINEARSIZE if it's compressed, or DDSD_PITCH if
|
||||
uncompressed. Some DDS writers do not conform to the
|
||||
spec, so I need to make my reader more tolerant */
|
||||
if( header.sPixelFormat.dwSize != 32 ) return NULL;
|
||||
flags = DDPF_FOURCC | DDPF_RGB;
|
||||
if( (header.sPixelFormat.dwFlags & flags) == 0 ) return NULL;
|
||||
if( (header.sCaps.dwCaps1 & DDSCAPS_TEXTURE) == 0 ) return NULL;
|
||||
// get the image data
|
||||
s->img_x = header.dwWidth;
|
||||
s->img_y = header.dwHeight;
|
||||
s->img_n = 4;
|
||||
is_compressed = (header.sPixelFormat.dwFlags & DDPF_FOURCC) / DDPF_FOURCC;
|
||||
has_alpha = (header.sPixelFormat.dwFlags & DDPF_ALPHAPIXELS) / DDPF_ALPHAPIXELS;
|
||||
has_mipmap = (header.sCaps.dwCaps1 & DDSCAPS_MIPMAP) && (header.dwMipMapCount > 1);
|
||||
cubemap_faces = (header.sCaps.dwCaps2 & DDSCAPS2_CUBEMAP) / DDSCAPS2_CUBEMAP;
|
||||
/* I need cubemaps to have square faces */
|
||||
cubemap_faces &= (s->img_x == s->img_y);
|
||||
cubemap_faces *= 5;
|
||||
cubemap_faces += 1;
|
||||
block_pitch = (s->img_x+3) >> 2;
|
||||
num_blocks = block_pitch * ((s->img_y+3) >> 2);
|
||||
/* let the user know what's going on */
|
||||
*x = s->img_x;
|
||||
*y = s->img_y;
|
||||
*comp = s->img_n;
|
||||
/* is this uncompressed? */
|
||||
if( is_compressed )
|
||||
{
|
||||
/* compressed */
|
||||
// note: header.sPixelFormat.dwFourCC is something like (('D'<<0)|('X'<<8)|('T'<<16)|('1'<<24))
|
||||
DXT_family = 1 + (header.sPixelFormat.dwFourCC >> 24) - '1';
|
||||
if( (DXT_family < 1) || (DXT_family > 5) ) return NULL;
|
||||
/* check the expected size...oops, nevermind...
|
||||
those non-compliant writers leave
|
||||
dwPitchOrLinearSize == 0 */
|
||||
// passed all the tests, get the RAM for decoding
|
||||
sz = (s->img_x)*(s->img_y)*4*cubemap_faces;
|
||||
dds_data = (unsigned char*)malloc( sz );
|
||||
/* do this once for each face */
|
||||
for( cf = 0; cf < cubemap_faces; ++ cf )
|
||||
{
|
||||
// now read and decode all the blocks
|
||||
for( i = 0; i < num_blocks; ++i )
|
||||
{
|
||||
// where are we?
|
||||
int bx, by, bw=4, bh=4;
|
||||
int ref_x = 4 * (i % block_pitch);
|
||||
int ref_y = 4 * (i / block_pitch);
|
||||
// get the next block's worth of compressed data, and decompress it
|
||||
if( DXT_family == 1 )
|
||||
{
|
||||
// DXT1
|
||||
getn( s, compressed, 8 );
|
||||
stbi_decode_DXT1_block( block, compressed );
|
||||
} else if( DXT_family < 4 )
|
||||
{
|
||||
// DXT2/3
|
||||
getn( s, compressed, 8 );
|
||||
stbi_decode_DXT23_alpha_block ( block, compressed );
|
||||
getn( s, compressed, 8 );
|
||||
stbi_decode_DXT_color_block ( block, compressed );
|
||||
} else
|
||||
{
|
||||
// DXT4/5
|
||||
getn( s, compressed, 8 );
|
||||
stbi_decode_DXT45_alpha_block ( block, compressed );
|
||||
getn( s, compressed, 8 );
|
||||
stbi_decode_DXT_color_block ( block, compressed );
|
||||
}
|
||||
// is this a partial block?
|
||||
if( ref_x + 4 > s->img_x )
|
||||
{
|
||||
bw = s->img_x - ref_x;
|
||||
}
|
||||
if( ref_y + 4 > s->img_y )
|
||||
{
|
||||
bh = s->img_y - ref_y;
|
||||
}
|
||||
// now drop our decompressed data into the buffer
|
||||
for( by = 0; by < bh; ++by )
|
||||
{
|
||||
int idx = 4*((ref_y+by+cf*s->img_x)*s->img_x + ref_x);
|
||||
for( bx = 0; bx < bw*4; ++bx )
|
||||
{
|
||||
|
||||
dds_data[idx+bx] = block[by*16+bx];
|
||||
}
|
||||
}
|
||||
}
|
||||
/* done reading and decoding the main image...
|
||||
skip MIPmaps if present */
|
||||
if( has_mipmap )
|
||||
{
|
||||
int block_size = 16;
|
||||
if( DXT_family == 1 )
|
||||
{
|
||||
block_size = 8;
|
||||
}
|
||||
for( i = 1; i < header.dwMipMapCount; ++i )
|
||||
{
|
||||
int mx = s->img_x >> (i + 2);
|
||||
int my = s->img_y >> (i + 2);
|
||||
if( mx < 1 )
|
||||
{
|
||||
mx = 1;
|
||||
}
|
||||
if( my < 1 )
|
||||
{
|
||||
my = 1;
|
||||
}
|
||||
skip( s, mx*my*block_size );
|
||||
}
|
||||
}
|
||||
}/* per cubemap face */
|
||||
} else
|
||||
{
|
||||
/* uncompressed */
|
||||
DXT_family = 0;
|
||||
s->img_n = 3;
|
||||
if( has_alpha )
|
||||
{
|
||||
s->img_n = 4;
|
||||
}
|
||||
*comp = s->img_n;
|
||||
sz = s->img_x*s->img_y*s->img_n*cubemap_faces;
|
||||
dds_data = (unsigned char*)malloc( sz );
|
||||
/* do this once for each face */
|
||||
for( cf = 0; cf < cubemap_faces; ++ cf )
|
||||
{
|
||||
/* read the main image for this face */
|
||||
getn( s, &dds_data[cf*s->img_x*s->img_y*s->img_n], s->img_x*s->img_y*s->img_n );
|
||||
/* done reading and decoding the main image...
|
||||
skip MIPmaps if present */
|
||||
if( has_mipmap )
|
||||
{
|
||||
for( i = 1; i < header.dwMipMapCount; ++i )
|
||||
{
|
||||
int mx = s->img_x >> i;
|
||||
int my = s->img_y >> i;
|
||||
if( mx < 1 )
|
||||
{
|
||||
mx = 1;
|
||||
}
|
||||
if( my < 1 )
|
||||
{
|
||||
my = 1;
|
||||
}
|
||||
skip( s, mx*my*s->img_n );
|
||||
}
|
||||
}
|
||||
}
|
||||
/* data was BGR, I need it RGB */
|
||||
for( i = 0; i < sz; i += s->img_n )
|
||||
{
|
||||
unsigned char temp = dds_data[i];
|
||||
dds_data[i] = dds_data[i+2];
|
||||
dds_data[i+2] = temp;
|
||||
}
|
||||
}
|
||||
/* finished decompressing into RGBA,
|
||||
adjust the y size if we have a cubemap
|
||||
note: sz is already up to date */
|
||||
s->img_y *= cubemap_faces;
|
||||
*y = s->img_y;
|
||||
// did the user want something else, or
|
||||
// see if all the alpha values are 255 (i.e. no transparency)
|
||||
has_alpha = 0;
|
||||
if( s->img_n == 4)
|
||||
{
|
||||
for( i = 3; (i < sz) && (has_alpha == 0); i += 4 )
|
||||
{
|
||||
has_alpha |= (dds_data[i] < 255);
|
||||
}
|
||||
}
|
||||
if( (req_comp <= 4) && (req_comp >= 1) )
|
||||
{
|
||||
// user has some requirements, meet them
|
||||
if( req_comp != s->img_n )
|
||||
{
|
||||
dds_data = convert_format( dds_data, s->img_n, req_comp, s->img_x, s->img_y );
|
||||
*comp = s->img_n;
|
||||
}
|
||||
} else
|
||||
{
|
||||
// user had no requirements, only drop to RGB is no alpha
|
||||
if( (has_alpha == 0) && (s->img_n == 4) )
|
||||
{
|
||||
dds_data = convert_format( dds_data, 4, 3, s->img_x, s->img_y );
|
||||
*comp = 3;
|
||||
}
|
||||
}
|
||||
// OK, done
|
||||
return dds_data;
|
||||
}
|
||||
|
||||
#ifndef STBI_NO_STDIO
|
||||
stbi_uc *stbi_dds_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp)
|
||||
{
|
||||
stbi s;
|
||||
start_file(&s,f);
|
||||
return dds_load(&s,x,y,comp,req_comp);
|
||||
}
|
||||
|
||||
stbi_uc *stbi_dds_load (char *filename, int *x, int *y, int *comp, int req_comp)
|
||||
{
|
||||
stbi_uc *data;
|
||||
FILE *f = fopen(filename, "rb");
|
||||
if (!f) return NULL;
|
||||
data = stbi_dds_load_from_file(f,x,y,comp,req_comp);
|
||||
fclose(f);
|
||||
return data;
|
||||
}
|
||||
#endif
|
||||
|
||||
stbi_uc *stbi_dds_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
|
||||
{
|
||||
stbi s;
|
||||
start_mem(&s,buffer, len);
|
||||
return dds_load(&s,x,y,comp,req_comp);
|
||||
}
|
102
cw 8/src/Shader_Loader.cpp
Normal file
102
cw 8/src/Shader_Loader.cpp
Normal file
@ -0,0 +1,102 @@
|
||||
#include "Shader_Loader.h"
|
||||
#include<iostream>
|
||||
#include<fstream>
|
||||
#include<vector>
|
||||
|
||||
using namespace Core;
|
||||
|
||||
Shader_Loader::Shader_Loader(void){}
|
||||
Shader_Loader::~Shader_Loader(void){}
|
||||
|
||||
std::string Shader_Loader::ReadShader(char *filename)
|
||||
{
|
||||
|
||||
std::string shaderCode;
|
||||
std::ifstream file(filename, std::ios::in);
|
||||
|
||||
if (!file.good())
|
||||
{
|
||||
std::cout << "Can't read file " << filename << std::endl;
|
||||
std::terminate();
|
||||
}
|
||||
|
||||
file.seekg(0, std::ios::end);
|
||||
shaderCode.resize((unsigned int)file.tellg());
|
||||
file.seekg(0, std::ios::beg);
|
||||
file.read(&shaderCode[0], shaderCode.size());
|
||||
file.close();
|
||||
return shaderCode;
|
||||
}
|
||||
|
||||
GLuint Shader_Loader::CreateShader(GLenum shaderType, std::string
|
||||
source, char* shaderName)
|
||||
{
|
||||
|
||||
int compile_result = 0;
|
||||
|
||||
GLuint shader = glCreateShader(shaderType);
|
||||
const char *shader_code_ptr = source.c_str();
|
||||
const int shader_code_size = source.size();
|
||||
|
||||
glShaderSource(shader, 1, &shader_code_ptr, &shader_code_size);
|
||||
glCompileShader(shader);
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_result);
|
||||
|
||||
//sprawdz bledy
|
||||
if (compile_result == GL_FALSE)
|
||||
{
|
||||
|
||||
int info_log_length = 0;
|
||||
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_log_length);
|
||||
std::vector<char> shader_log(info_log_length);
|
||||
glGetShaderInfoLog(shader, info_log_length, NULL, &shader_log[0]);
|
||||
std::cout << "ERROR compiling shader: " << shaderName << std::endl << &shader_log[0] << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return shader;
|
||||
}
|
||||
|
||||
GLuint Shader_Loader::CreateProgram(char* vertexShaderFilename,
|
||||
char* fragmentShaderFilename)
|
||||
{
|
||||
|
||||
//wczytaj shadery
|
||||
std::string vertex_shader_code = ReadShader(vertexShaderFilename);
|
||||
std::string fragment_shader_code = ReadShader(fragmentShaderFilename);
|
||||
|
||||
GLuint vertex_shader = CreateShader(GL_VERTEX_SHADER, vertex_shader_code, "vertex shader");
|
||||
GLuint fragment_shader = CreateShader(GL_FRAGMENT_SHADER, fragment_shader_code, "fragment shader");
|
||||
|
||||
int link_result = 0;
|
||||
//stworz shader
|
||||
GLuint program = glCreateProgram();
|
||||
glAttachShader(program, vertex_shader);
|
||||
glAttachShader(program, fragment_shader);
|
||||
|
||||
glLinkProgram(program);
|
||||
glGetProgramiv(program, GL_LINK_STATUS, &link_result);
|
||||
//sprawdz bledy w linkerze
|
||||
if (link_result == GL_FALSE)
|
||||
{
|
||||
|
||||
int info_log_length = 0;
|
||||
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_log_length);
|
||||
std::vector<char> program_log(info_log_length);
|
||||
glGetProgramInfoLog(program, info_log_length, NULL, &program_log[0]);
|
||||
std::cout << "Shader Loader : LINK ERROR" << std::endl << &program_log[0] << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
glDetachShader(program, vertex_shader);
|
||||
glDetachShader(program, fragment_shader);
|
||||
glDeleteShader(vertex_shader);
|
||||
glDeleteShader(fragment_shader);
|
||||
|
||||
return program;
|
||||
}
|
||||
|
||||
void Shader_Loader::DeleteProgram( GLuint program )
|
||||
{
|
||||
glDeleteProgram(program);
|
||||
}
|
29
cw 8/src/Shader_Loader.h
Normal file
29
cw 8/src/Shader_Loader.h
Normal file
@ -0,0 +1,29 @@
|
||||
#pragma once
|
||||
|
||||
#include "glew.h"
|
||||
#include "freeglut.h"
|
||||
#include <iostream>
|
||||
|
||||
namespace Core
|
||||
{
|
||||
|
||||
class Shader_Loader
|
||||
{
|
||||
private:
|
||||
|
||||
std::string ReadShader(char *filename);
|
||||
GLuint CreateShader(GLenum shaderType,
|
||||
std::string source,
|
||||
char* shaderName);
|
||||
|
||||
public:
|
||||
|
||||
Shader_Loader(void);
|
||||
~Shader_Loader(void);
|
||||
GLuint CreateProgram(char* VertexShaderFilename,
|
||||
char* FragmentShaderFilename);
|
||||
|
||||
void DeleteProgram(GLuint program);
|
||||
|
||||
};
|
||||
}
|
36
cw 8/src/Texture.cpp
Normal file
36
cw 8/src/Texture.cpp
Normal file
@ -0,0 +1,36 @@
|
||||
#include "Texture.h"
|
||||
|
||||
#include <fstream>
|
||||
#include <iterator>
|
||||
#include <vector>
|
||||
#include "SOIL/SOIL.h"
|
||||
|
||||
typedef unsigned char byte;
|
||||
|
||||
GLuint Core::LoadTexture( const char * filepath )
|
||||
{
|
||||
GLuint id;
|
||||
glGenTextures(1, &id);
|
||||
glBindTexture(GL_TEXTURE_2D, id);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
|
||||
int w, h;
|
||||
unsigned char* image = SOIL_load_image(filepath, &w, &h, 0, SOIL_LOAD_RGBA);
|
||||
|
||||
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
|
||||
glGenerateMipmap(GL_TEXTURE_2D);
|
||||
SOIL_free_image_data(image);
|
||||
|
||||
return id;
|
||||
}
|
||||
|
||||
void Core::SetActiveTexture(GLuint textureID, const char * shaderVariableName, GLuint programID, int textureUnit)
|
||||
{
|
||||
glUniform1i(glGetUniformLocation(programID, shaderVariableName), textureUnit);
|
||||
glActiveTexture(GL_TEXTURE0 + textureUnit);
|
||||
glBindTexture(GL_TEXTURE_2D, textureID);
|
||||
}
|
15
cw 8/src/Texture.h
Normal file
15
cw 8/src/Texture.h
Normal file
@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
|
||||
#include "glew.h"
|
||||
#include "freeglut.h"
|
||||
|
||||
namespace Core
|
||||
{
|
||||
GLuint LoadTexture(const char * filepath);
|
||||
|
||||
// textureID - identyfikator tekstury otrzymany z funkcji LoadTexture
|
||||
// shaderVariableName - nazwa zmiennej typu 'sampler2D' w shaderze, z ktora ma zostac powiazana tekstura
|
||||
// programID - identyfikator aktualnego programu karty graficznej
|
||||
// textureUnit - indeks jednostki teksturujacej - liczba od 0 do 7. Jezeli uzywa sie wielu tekstur w jednym shaderze, to kazda z nich nalezy powiazac z inna jednostka.
|
||||
void SetActiveTexture(GLuint textureID, const char * shaderVariableName, GLuint programID, int textureUnit);
|
||||
}
|
363
cw 8/src/main_8_1.cpp
Normal file
363
cw 8/src/main_8_1.cpp
Normal file
@ -0,0 +1,363 @@
|
||||
#include "glew.h"
|
||||
#include "freeglut.h"
|
||||
#include "glm.hpp"
|
||||
#include "ext.hpp"
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
|
||||
#include "Shader_Loader.h"
|
||||
#include "Render_Utils.h"
|
||||
#include "Camera.h"
|
||||
#include "Texture.h"
|
||||
#include "Physics.h"
|
||||
|
||||
Core::Shader_Loader shaderLoader;
|
||||
GLuint programColor;
|
||||
GLuint programTexture;
|
||||
|
||||
obj::Model planeModel;
|
||||
obj::Model boxModel;
|
||||
glm::mat4 boxModelMatrix;
|
||||
GLuint boxTexture, groundTexture;
|
||||
Core::RenderContext planeContext, boxContext;
|
||||
|
||||
glm::vec3 cameraPos = glm::vec3(0, 5, 20);
|
||||
glm::vec3 cameraDir;
|
||||
glm::vec3 cameraSide;
|
||||
float cameraAngle = 0;
|
||||
glm::mat4 cameraMatrix, perspectiveMatrix;
|
||||
|
||||
glm::vec3 lightDir = glm::normalize(glm::vec3(0.5, -1, -0.5));
|
||||
|
||||
|
||||
// Initalization of physical scene (PhysX)
|
||||
Physics pxScene(9.8 /* gravity (m/s^2) */);
|
||||
|
||||
// fixed timestep for stable and deterministic simulation
|
||||
const double physicsStepTime = 1.f / 60.f;
|
||||
double physicsTimeToProcess = 0;
|
||||
|
||||
// physical objects
|
||||
PxRigidStatic *planeBody = nullptr;
|
||||
PxMaterial *planeMaterial = nullptr;
|
||||
PxRigidDynamic *boxBody = nullptr;
|
||||
PxMaterial *boxMaterial = nullptr;
|
||||
|
||||
|
||||
void initRenderables()
|
||||
{
|
||||
// load models
|
||||
planeModel = obj::loadModelFromFile("models/plane.obj");
|
||||
boxModel = obj::loadModelFromFile("models/box.obj");
|
||||
|
||||
// load textures
|
||||
groundTexture = Core::LoadTexture("textures/sand.jpg");
|
||||
boxTexture = Core::LoadTexture("textures/a.jpg");
|
||||
|
||||
planeContext.initFromOBJ(planeModel);
|
||||
boxContext.initFromOBJ(boxModel);
|
||||
}
|
||||
|
||||
void initPhysicsScene()
|
||||
{
|
||||
//-----------------------------------------------------------
|
||||
// DOCS
|
||||
//-----------------------------------------------------------
|
||||
//https://gameworksdocs.nvidia.com/PhysX/4.1/documentation/physxguide/Manual/Index.html
|
||||
//https://gameworksdocs.nvidia.com/PhysX/4.1/documentation/physxapi/files/index.html
|
||||
|
||||
|
||||
//-----------------------------------------------------------
|
||||
// TASKS
|
||||
//-----------------------------------------------------------
|
||||
// IMPORTANT:
|
||||
// * to create objects use: pxScene.physics
|
||||
// * to manage the scene use: pxScene.scene
|
||||
//
|
||||
// Your task is to create two physical objects: one static body
|
||||
// and one dynamic body.
|
||||
// These will be a planar ground and a box.
|
||||
// If everything is set up correctly, the box should fall down,
|
||||
// bounce a few times and finally rest on the ground.
|
||||
//
|
||||
// You should provide the physics initialization code below.
|
||||
// The required global variables have already been declared.
|
||||
// Note, that most of the variables are pointers, so remember
|
||||
// to use -> instead of . to access member methods/variables
|
||||
|
||||
|
||||
//**************************
|
||||
// I. Create plane:
|
||||
// 1. Create plane body.
|
||||
// Use method: createRigidStatic( transform )
|
||||
// As the argument provide the transform created from the plane equation (n=[0,1,0], d=0):
|
||||
// PxTransformFromPlaneEquation(PxPlane(0, 1, 0, 0))
|
||||
// Save the created body in global variable: planeBody
|
||||
planeBody = pxScene.physics->createRigidStatic(PxTransformFromPlaneEquation(PxPlane(0, 1, 0, 0)));
|
||||
// 2. Create material.
|
||||
// Use method: createMaterial( staticFriction, dynamicFriction, restitution )
|
||||
// Use parameters e.g. 0.5, 0.5, 0.6
|
||||
// Save the material in global variable: planeMaterial
|
||||
planeMaterial = pxScene.physics->createMaterial(0.5, 0.5, 0.6);
|
||||
|
||||
// 3. Create plane shape.
|
||||
// Use method: createShape( geometry, material )
|
||||
// As the first argument use plane geometry: simply PxPlaneGeometry()
|
||||
// As the second argument use the just created plane material.
|
||||
// Save the shape in local variable: PxShape* planeShape
|
||||
PxShape *planeShape = pxScene.physics->createShape(PxPlaneGeometry(), *planeMaterial);
|
||||
// 4. Attach shape to the body.
|
||||
// Use method attachShape( shape ) on planeBody.
|
||||
// As the argument provide the just created plane shape.
|
||||
planeBody->attachShape(*planeShape);
|
||||
|
||||
// 5. Now the shape is attached, it's no longer needed, so release it.
|
||||
// Use method release on planeShape.
|
||||
planeShape->release();
|
||||
|
||||
// 6. You can also provide a custom data for the body
|
||||
// It will be useful for the box, to bind the physical body
|
||||
// with its graphical representation. As far as the plane is concerned,
|
||||
// just set the user data to null, since the plane is static anyway.
|
||||
// Set the member variable userData of planeBody to nullptr.
|
||||
planeBody->userData = nullptr;
|
||||
|
||||
// 7. Finally, add the body to the scene.
|
||||
// Use method: addActor( body )
|
||||
// As the argument provide the plane body.
|
||||
pxScene.scene->addActor(*planeBody);
|
||||
|
||||
//**************************
|
||||
// II. Create box:
|
||||
|
||||
// 1. Create box body.
|
||||
// Use method: createRigidDynamic( transform )
|
||||
// Set the initial transform of the box to 5 meters above the ground.
|
||||
// Use: PxTransform(x, y, z)
|
||||
// Save the created body in global variable: boxBody
|
||||
boxBody = pxScene.physics->createRigidDynamic(PxTransform(0, 5, 0));
|
||||
|
||||
// 2. Create material.
|
||||
// Use method: createMaterial( staticFriction, dynamicFriction, restitution )
|
||||
// Use parameters e.g. 0.5, 0.5, 0.6
|
||||
// Save the material in global variable: boxMaterial
|
||||
boxMaterial = pxScene.physics->createMaterial(0.5, 0.5, 0.6);
|
||||
|
||||
// 3. Create box shape.
|
||||
// Use method: createShape( geometry, material )
|
||||
// As the first argument provide box geometry.
|
||||
// Use: PxBoxGeometry(hx, hy, hz), where the arguments define
|
||||
// half extents of the box (use hx=hy=hz=1).
|
||||
// As the second argument use the just created box material.
|
||||
// Save the shape in local variable: PxShape* boxShape
|
||||
PxShape* boxShape = pxScene.physics->createShape(PxBoxGeometry(1, 1, 1), *boxMaterial);
|
||||
|
||||
// 4. Attach shape to the body.
|
||||
// Use method attachShape( shape ) on boxBody.
|
||||
// As the argument provide the just created box shape.
|
||||
boxBody->attachShape(*boxShape);
|
||||
|
||||
// 5. Now the shape is attached, it's no longer needed, so release it.
|
||||
// Use method release on boxShape.
|
||||
boxShape->release();
|
||||
|
||||
// 6. In order to render the box corresponding to its physical state,
|
||||
// we need to bind the model matrix used for drawing to the transform
|
||||
// of the body in the physics simulation.
|
||||
// Set the member variable userData of boxBody to the pointer of boxModelMatrix.
|
||||
// (userData is of universal type void*, so be careful when
|
||||
// accessing it later - remember to cast it back to the correct type)
|
||||
boxBody->userData = &boxModelMatrix;
|
||||
|
||||
// 7. Finally, add the body to the scene.
|
||||
// Use method: addActor( body )
|
||||
// As the argument provide the box body.
|
||||
pxScene.scene->addActor(*boxBody);
|
||||
|
||||
//**************************
|
||||
// III. Now read the function updateTransforms()
|
||||
// See how we use the userData of the bodies to properly update
|
||||
// the transforms of their visualizations.
|
||||
|
||||
//**************************
|
||||
// IV. See also the function renderScene()
|
||||
// Notice how the physics simulation is updated and the objects are rendered.
|
||||
}
|
||||
|
||||
void updateTransforms()
|
||||
{
|
||||
// Here we retrieve the current transforms of the objects from the physical simulation.
|
||||
auto actorFlags = PxActorTypeFlag::eRIGID_DYNAMIC | PxActorTypeFlag::eRIGID_STATIC;
|
||||
PxU32 nbActors = pxScene.scene->getNbActors(actorFlags);
|
||||
if (nbActors)
|
||||
{
|
||||
std::vector<PxRigidActor*> actors(nbActors);
|
||||
pxScene.scene->getActors(actorFlags, (PxActor**)&actors[0], nbActors);
|
||||
for (auto actor : actors)
|
||||
{
|
||||
// We use the userData of the objects to set up the proper model matrices.
|
||||
if (!actor->userData) continue;
|
||||
glm::mat4 *modelMatrix = (glm::mat4*)actor->userData;
|
||||
|
||||
// get world matrix of the object (actor)
|
||||
PxMat44 transform = actor->getGlobalPose();
|
||||
auto &c0 = transform.column0;
|
||||
auto &c1 = transform.column1;
|
||||
auto &c2 = transform.column2;
|
||||
auto &c3 = transform.column3;
|
||||
|
||||
// set up the model matrix used for the rendering
|
||||
*modelMatrix = glm::mat4(
|
||||
c0.x, c0.y, c0.z, c0.w,
|
||||
c1.x, c1.y, c1.z, c1.w,
|
||||
c2.x, c2.y, c2.z, c2.w,
|
||||
c3.x, c3.y, c3.z, c3.w);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void keyboard(unsigned char key, int x, int y)
|
||||
{
|
||||
float angleSpeed = 0.1f;
|
||||
float moveSpeed = 0.1f;
|
||||
switch (key)
|
||||
{
|
||||
case 'z': cameraAngle -= angleSpeed; break;
|
||||
case 'x': cameraAngle += angleSpeed; break;
|
||||
case 'w': cameraPos += cameraDir * moveSpeed; break;
|
||||
case 's': cameraPos -= cameraDir * moveSpeed; break;
|
||||
case 'd': cameraPos += cameraSide * moveSpeed; break;
|
||||
case 'a': cameraPos -= cameraSide * moveSpeed; break;
|
||||
}
|
||||
}
|
||||
|
||||
void mouse(int x, int y)
|
||||
{
|
||||
}
|
||||
|
||||
glm::mat4 createCameraMatrix()
|
||||
{
|
||||
cameraDir = glm::normalize(glm::vec3(cosf(cameraAngle - glm::radians(90.0f)), 0, sinf(cameraAngle - glm::radians(90.0f))));
|
||||
glm::vec3 up = glm::vec3(0, 1, 0);
|
||||
cameraSide = glm::cross(cameraDir, up);
|
||||
|
||||
return Core::createViewMatrix(cameraPos, cameraDir, up);
|
||||
}
|
||||
|
||||
void drawObjectColor(Core::RenderContext context, glm::mat4 modelMatrix, glm::vec3 color)
|
||||
{
|
||||
GLuint program = programColor;
|
||||
|
||||
glUseProgram(program);
|
||||
|
||||
glUniform3f(glGetUniformLocation(program, "objectColor"), color.x, color.y, color.z);
|
||||
glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
|
||||
|
||||
glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
|
||||
|
||||
Core::DrawContext(context);
|
||||
|
||||
glUseProgram(0);
|
||||
}
|
||||
|
||||
void drawObjectTexture(Core::RenderContext context, glm::mat4 modelMatrix, GLuint textureId)
|
||||
{
|
||||
GLuint program = programTexture;
|
||||
|
||||
glUseProgram(program);
|
||||
|
||||
glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
|
||||
Core::SetActiveTexture(textureId, "textureSampler", program, 0);
|
||||
|
||||
glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
|
||||
|
||||
Core::DrawContext(context);
|
||||
|
||||
glUseProgram(0);
|
||||
}
|
||||
|
||||
void renderScene()
|
||||
{
|
||||
double time = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
|
||||
static double prevTime = time;
|
||||
double dtime = time - prevTime;
|
||||
prevTime = time;
|
||||
|
||||
// Update physics
|
||||
if (dtime < 1.f) {
|
||||
physicsTimeToProcess += dtime;
|
||||
while (physicsTimeToProcess > 0) {
|
||||
// here we perform the physics simulation step
|
||||
pxScene.step(physicsStepTime);
|
||||
physicsTimeToProcess -= physicsStepTime;
|
||||
}
|
||||
}
|
||||
|
||||
// Update of camera and perspective matrices
|
||||
cameraMatrix = createCameraMatrix();
|
||||
perspectiveMatrix = Core::createPerspectiveMatrix();
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
|
||||
|
||||
// update transforms from physics simulation
|
||||
updateTransforms();
|
||||
|
||||
// render models
|
||||
drawObjectTexture(planeContext, glm::rotate(glm::radians(90.f), glm::vec3(0.f, 0.f, 1.f)), groundTexture);
|
||||
drawObjectTexture(boxContext, boxModelMatrix, boxTexture); // boxModelMatrix was updated in updateTransforms()
|
||||
|
||||
glutSwapBuffers();
|
||||
}
|
||||
|
||||
void init()
|
||||
{
|
||||
srand(time(0));
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
programColor = shaderLoader.CreateProgram("shaders/shader_color.vert", "shaders/shader_color.frag");
|
||||
programTexture = shaderLoader.CreateProgram("shaders/shader_tex.vert", "shaders/shader_tex.frag");
|
||||
|
||||
initRenderables();
|
||||
initPhysicsScene();
|
||||
}
|
||||
|
||||
void shutdown()
|
||||
{
|
||||
shaderLoader.DeleteProgram(programColor);
|
||||
shaderLoader.DeleteProgram(programTexture);
|
||||
|
||||
planeContext.initFromOBJ(planeModel);
|
||||
boxContext.initFromOBJ(boxModel);
|
||||
}
|
||||
|
||||
void idle()
|
||||
{
|
||||
glutPostRedisplay();
|
||||
}
|
||||
|
||||
int main(int argc, char ** argv)
|
||||
{
|
||||
glutInit(&argc, argv);
|
||||
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
|
||||
glutInitWindowPosition(200, 200);
|
||||
glutInitWindowSize(600, 600);
|
||||
glutCreateWindow("OpenGL + PhysX");
|
||||
glewInit();
|
||||
|
||||
init();
|
||||
glutKeyboardFunc(keyboard);
|
||||
glutPassiveMotionFunc(mouse);
|
||||
glutDisplayFunc(renderScene);
|
||||
glutIdleFunc(idle);
|
||||
|
||||
glutMainLoop();
|
||||
|
||||
shutdown();
|
||||
|
||||
return 0;
|
||||
}
|
370
cw 8/src/main_8_2.cpp
Normal file
370
cw 8/src/main_8_2.cpp
Normal file
@ -0,0 +1,370 @@
|
||||
#include "glew.h"
|
||||
#include "freeglut.h"
|
||||
#include "glm.hpp"
|
||||
#include "ext.hpp"
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
|
||||
#include "Shader_Loader.h"
|
||||
#include "Render_Utils.h"
|
||||
#include "Camera.h"
|
||||
#include "Texture.h"
|
||||
#include "Physics.h"
|
||||
|
||||
Core::Shader_Loader shaderLoader;
|
||||
GLuint programColor;
|
||||
GLuint programTexture;
|
||||
|
||||
obj::Model planeModel, boxModel, sphereModel;
|
||||
Core::RenderContext planeContext, boxContext, sphereContext;
|
||||
GLuint boxTexture, groundTexture;
|
||||
|
||||
glm::vec3 cameraPos = glm::vec3(0, 5, 20);
|
||||
glm::vec3 cameraDir;
|
||||
glm::vec3 cameraSide;
|
||||
float cameraAngle = 0;
|
||||
glm::mat4 cameraMatrix, perspectiveMatrix;
|
||||
|
||||
glm::vec3 lightDir = glm::normalize(glm::vec3(0.5, -1, -0.5));
|
||||
|
||||
|
||||
// Initalization of physical scene (PhysX)
|
||||
Physics pxScene(9.8 /* gravity (m/s^2) */);
|
||||
|
||||
|
||||
// fixed timestep for stable and deterministic simulation
|
||||
const double physicsStepTime = 1.f / 60.f;
|
||||
double physicsTimeToProcess = 0;
|
||||
|
||||
// physical objects
|
||||
PxRigidStatic *planeBody = nullptr;
|
||||
PxMaterial *planeMaterial = nullptr;
|
||||
std::vector<PxRigidDynamic*> boxBodies;
|
||||
PxMaterial *boxMaterial = nullptr;
|
||||
PxRigidDynamic *sphereBody = nullptr;
|
||||
PxMaterial *sphereMaterial = nullptr;
|
||||
|
||||
// renderable objects (description of a single renderable instance)
|
||||
struct Renderable {
|
||||
Core::RenderContext* context;
|
||||
glm::mat4 modelMatrix;
|
||||
GLuint textureId;
|
||||
};
|
||||
std::vector<Renderable*> renderables;
|
||||
std::vector<PxRigidDynamic*> boxes;
|
||||
|
||||
// number of rows and columns of boxes the wall consists of
|
||||
const int wallRows = 5;
|
||||
const int wallCols = 5;
|
||||
|
||||
void initRenderables()
|
||||
{
|
||||
// load models
|
||||
planeModel = obj::loadModelFromFile("models/plane.obj");
|
||||
boxModel = obj::loadModelFromFile("models/box.obj");
|
||||
sphereModel = obj::loadModelFromFile("models/sphere.obj");
|
||||
|
||||
planeContext.initFromOBJ(planeModel);
|
||||
boxContext.initFromOBJ(boxModel);
|
||||
sphereContext.initFromOBJ(sphereModel);
|
||||
|
||||
// load textures
|
||||
groundTexture = Core::LoadTexture("textures/sand.jpg");
|
||||
boxTexture = Core::LoadTexture("textures/a.jpg");
|
||||
|
||||
// This time we organize all the renderables in a list
|
||||
// of basic properties (model, transform, texture),
|
||||
// to unify their rendering and simplify their managament
|
||||
// in connection to the physics simulation
|
||||
|
||||
// create ground
|
||||
Renderable *ground = new Renderable();
|
||||
ground->context = &planeContext;
|
||||
ground->textureId = groundTexture;
|
||||
renderables.emplace_back(ground);
|
||||
|
||||
for (int i = 0; i < wallCols; i++)
|
||||
for (int j = 0; j < wallRows; j++) {
|
||||
// create box
|
||||
Renderable *box = new Renderable();
|
||||
box->context = &boxContext;
|
||||
box->textureId = boxTexture;
|
||||
renderables.emplace_back(box);
|
||||
}
|
||||
|
||||
//**********************************
|
||||
// UNCOMMENT FOR THE LAST TASK !!!
|
||||
/*Renderable *sphere = new Renderable();
|
||||
sphere->model = &sphereModel;
|
||||
sphere->textureId = boxTexture;
|
||||
renderables.emplace_back(sphere);*/
|
||||
}
|
||||
|
||||
void initPhysicsScene()
|
||||
{
|
||||
//-----------------------------------------------------------
|
||||
// TASKS
|
||||
//-----------------------------------------------------------
|
||||
// IMPORTANT:
|
||||
// * to create objects use: pxScene.physics
|
||||
// * to manage the scene use: pxScene.scene
|
||||
//
|
||||
// Create a wall of boxes (use global constants wallRows and
|
||||
// wallCols). Create wallCols columns of stacked boxes, each
|
||||
// consisting of wallRows boxes. Finally, destroy the wall
|
||||
// with a ball.
|
||||
//
|
||||
// You should provide the physics initialization code below.
|
||||
// The required global variables have already been declared.
|
||||
// Note, that most of the variables are pointers, so remember
|
||||
// to use -> instead of . to access member methods/variables
|
||||
|
||||
//**************************
|
||||
// I. Create plane
|
||||
|
||||
// 1. Create the plane similarly as in main_8_1.cpp
|
||||
// with one difference:
|
||||
//
|
||||
// 1.1 This time remember to set userData of the body to the pointer
|
||||
// of the corresponding renderable: renderables[0]
|
||||
// The plane still remains static, but we want to use the unified
|
||||
// organization of renderables.
|
||||
planeBody = pxScene.physics->createRigidStatic(PxTransformFromPlaneEquation(PxPlane(0, 1, 0, 0)));
|
||||
planeMaterial = pxScene.physics->createMaterial(0.5, 0.5, 0.6);
|
||||
PxShape* planeShape = pxScene.physics->createShape(PxPlaneGeometry(), *planeMaterial);
|
||||
planeBody->attachShape(*planeShape);
|
||||
planeShape->release();
|
||||
planeBody->userData = renderables[0];
|
||||
pxScene.scene->addActor(*planeBody);
|
||||
|
||||
//**************************
|
||||
// II. Create wall:
|
||||
|
||||
// 1. Create box material (can be reused for all the boxes).
|
||||
boxMaterial = pxScene.physics->createMaterial(0.5, 0.5, 0.6);
|
||||
// 2. Create wallRows x wallCols boxes.
|
||||
// You need two nested for loops. Create each box similarly as in main_8_1.cpp
|
||||
// Pay attention to the following differences (we assume the indices
|
||||
// of for loops are i,j):
|
||||
//
|
||||
// 2.1 Save the created box bodies in a list (vector):
|
||||
// Use the global variable boxBodies
|
||||
//
|
||||
// 2.2. Set up the box transforms to the proper position within the wall
|
||||
// (i.e. calculate position x,y depending on i,j).
|
||||
// You can offset the boxes by several centimeters, so that the wall has
|
||||
// some space to settle down (you can observe how it falls down and stabilizes).
|
||||
//
|
||||
// 2.3 Set userData of the bodies to the pointers of corresponding renderables:
|
||||
// renderables[i*wallRows + j + 1]
|
||||
for (int i = 0; i < wallRows; i++) {
|
||||
for (int j = 0; j < wallCols; j++) {
|
||||
// create box
|
||||
PxRigidDynamic* box = pxScene.physics->createRigidDynamic(PxTransform(0, 5, 0));
|
||||
//box->context = &boxContext;
|
||||
//box->textureId = boxTexture;
|
||||
//renderables.emplace_back(box);
|
||||
}
|
||||
}
|
||||
|
||||
//**************************
|
||||
// III. See the function updateTransforms()
|
||||
// Now in userData we store pointers to renderables instead of matrices.
|
||||
// Notice the differences to main_8_1.cpp
|
||||
|
||||
//**************************
|
||||
// IV. See also the function renderScene()
|
||||
// Notice how we render all the renderables in a single for loop.
|
||||
|
||||
//**************************
|
||||
// V. Throw a ball towards the wall
|
||||
|
||||
// 1. Uncomment the code creating the renderable for the sphere in initRenderables()
|
||||
// 2. Create a rigid body, similarly to boxes.
|
||||
// Use the global variables sphereBody and sphereMaterial.
|
||||
// 3. Use PxSphereGeometry( radius ) for the geometry instead of box geometry.
|
||||
// 4. Set the initial transform of the sphere to the position of camera.
|
||||
// 5. Set the linear velocity of the body to e.g. PxVec3(0,0,-30)
|
||||
// Use the method: setLinearVelocity ( velocity )
|
||||
// 6. Set userData properly (sphere is the last element in renderables).
|
||||
|
||||
// VI.* Modify controls, use them to control the sphere. Attatch camera to the sphere.
|
||||
}
|
||||
|
||||
void updateTransforms()
|
||||
{
|
||||
// Here we retrieve the current transforms of the objects from the physical simulation.
|
||||
auto actorFlags = PxActorTypeFlag::eRIGID_DYNAMIC | PxActorTypeFlag::eRIGID_STATIC;
|
||||
PxU32 nbActors = pxScene.scene->getNbActors(actorFlags);
|
||||
if (nbActors)
|
||||
{
|
||||
std::vector<PxRigidActor*> actors(nbActors);
|
||||
pxScene.scene->getActors(actorFlags, (PxActor**)&actors[0], nbActors);
|
||||
for (auto actor : actors)
|
||||
{
|
||||
// We use the userData of the objects to set up the model matrices
|
||||
// of proper renderables.
|
||||
if (!actor->userData) continue;
|
||||
Renderable *renderable = (Renderable*)actor->userData;
|
||||
|
||||
// get world matrix of the object (actor)
|
||||
PxMat44 transform = actor->getGlobalPose();
|
||||
auto &c0 = transform.column0;
|
||||
auto &c1 = transform.column1;
|
||||
auto &c2 = transform.column2;
|
||||
auto &c3 = transform.column3;
|
||||
|
||||
// set up the model matrix used for the rendering
|
||||
renderable->modelMatrix = glm::mat4(
|
||||
c0.x, c0.y, c0.z, c0.w,
|
||||
c1.x, c1.y, c1.z, c1.w,
|
||||
c2.x, c2.y, c2.z, c2.w,
|
||||
c3.x, c3.y, c3.z, c3.w);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void keyboard(unsigned char key, int x, int y)
|
||||
{
|
||||
float angleSpeed = 0.1f;
|
||||
float moveSpeed = 0.1f;
|
||||
switch (key)
|
||||
{
|
||||
case 'z': cameraAngle -= angleSpeed; break;
|
||||
case 'x': cameraAngle += angleSpeed; break;
|
||||
case 'w': cameraPos += cameraDir * moveSpeed; break;
|
||||
case 's': cameraPos -= cameraDir * moveSpeed; break;
|
||||
case 'd': cameraPos += cameraSide * moveSpeed; break;
|
||||
case 'a': cameraPos -= cameraSide * moveSpeed; break;
|
||||
}
|
||||
}
|
||||
|
||||
void mouse(int x, int y)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
glm::mat4 createCameraMatrix()
|
||||
{
|
||||
cameraDir = glm::normalize(glm::vec3(cosf(cameraAngle - glm::radians(90.0f)), 0, sinf(cameraAngle - glm::radians(90.0f))));
|
||||
glm::vec3 up = glm::vec3(0, 1, 0);
|
||||
cameraSide = glm::cross(cameraDir, up);
|
||||
|
||||
return Core::createViewMatrix(cameraPos, cameraDir, up);
|
||||
}
|
||||
|
||||
void drawObjectColor(Core::RenderContext* context, glm::mat4 modelMatrix, glm::vec3 color)
|
||||
{
|
||||
GLuint program = programColor;
|
||||
|
||||
glUseProgram(program);
|
||||
|
||||
glUniform3f(glGetUniformLocation(program, "objectColor"), color.x, color.y, color.z);
|
||||
glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
|
||||
|
||||
glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
|
||||
|
||||
Core::DrawContext(*context);
|
||||
|
||||
glUseProgram(0);
|
||||
}
|
||||
|
||||
void drawObjectTexture(Core::RenderContext * context, glm::mat4 modelMatrix, GLuint textureId)
|
||||
{
|
||||
GLuint program = programTexture;
|
||||
|
||||
glUseProgram(program);
|
||||
|
||||
glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
|
||||
Core::SetActiveTexture(textureId, "textureSampler", program, 0);
|
||||
|
||||
glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
|
||||
|
||||
Core::DrawContext(*context);
|
||||
|
||||
glUseProgram(0);
|
||||
}
|
||||
|
||||
void renderScene()
|
||||
{
|
||||
double time = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
|
||||
static double prevTime = time;
|
||||
double dtime = time - prevTime;
|
||||
prevTime = time;
|
||||
|
||||
// Update physics
|
||||
if (dtime < 1.f) {
|
||||
physicsTimeToProcess += dtime;
|
||||
while (physicsTimeToProcess > 0) {
|
||||
// here we perform the physics simulation step
|
||||
pxScene.step(physicsStepTime);
|
||||
physicsTimeToProcess -= physicsStepTime;
|
||||
}
|
||||
}
|
||||
|
||||
// Update of camera and perspective matrices
|
||||
cameraMatrix = createCameraMatrix();
|
||||
perspectiveMatrix = Core::createPerspectiveMatrix();
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
|
||||
|
||||
// update transforms from physics simulation
|
||||
updateTransforms();
|
||||
|
||||
// render models
|
||||
for (Renderable* renderable : renderables) {
|
||||
drawObjectTexture(renderable->context, renderable->modelMatrix, renderable->textureId);
|
||||
}
|
||||
|
||||
glutSwapBuffers();
|
||||
}
|
||||
|
||||
void init()
|
||||
{
|
||||
srand(time(0));
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
programColor = shaderLoader.CreateProgram("shaders/shader_color.vert", "shaders/shader_color.frag");
|
||||
programTexture = shaderLoader.CreateProgram("shaders/shader_tex.vert", "shaders/shader_tex.frag");
|
||||
|
||||
initRenderables();
|
||||
initPhysicsScene();
|
||||
}
|
||||
|
||||
void shutdown()
|
||||
{
|
||||
shaderLoader.DeleteProgram(programColor);
|
||||
shaderLoader.DeleteProgram(programTexture);
|
||||
}
|
||||
|
||||
void idle()
|
||||
{
|
||||
glutPostRedisplay();
|
||||
}
|
||||
|
||||
int main(int argc, char ** argv)
|
||||
{
|
||||
glutInit(&argc, argv);
|
||||
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
|
||||
glutInitWindowPosition(200, 200);
|
||||
glutInitWindowSize(600, 600);
|
||||
glutCreateWindow("OpenGL + PhysX");
|
||||
glewInit();
|
||||
|
||||
init();
|
||||
glutKeyboardFunc(keyboard);
|
||||
glutPassiveMotionFunc(mouse);
|
||||
glutDisplayFunc(renderScene);
|
||||
glutIdleFunc(idle);
|
||||
|
||||
glutMainLoop();
|
||||
|
||||
shutdown();
|
||||
|
||||
return 0;
|
||||
}
|
301
cw 8/src/main_8_3.cpp
Normal file
301
cw 8/src/main_8_3.cpp
Normal file
@ -0,0 +1,301 @@
|
||||
#include "glew.h"
|
||||
#include "freeglut.h"
|
||||
#include "glm.hpp"
|
||||
#include "ext.hpp"
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
|
||||
#include "Shader_Loader.h"
|
||||
#include "Render_Utils.h"
|
||||
#include "Camera.h"
|
||||
#include "Texture.h"
|
||||
#include "Physics.h"
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// TASKS
|
||||
//------------------------------------------------------------------
|
||||
//
|
||||
// In this exercise you will learn how to get notifications
|
||||
// about collisions (called contacts), along with the contact data.
|
||||
//
|
||||
// For this purpose we will use the following things provided
|
||||
// by PhysX:
|
||||
// * PxSimulationFilterShader
|
||||
// * PxSimulationEventCallback
|
||||
//
|
||||
// First, we implement a function compatible with the declaration
|
||||
// of PxSimulationFilterShader. This function filters the
|
||||
// collision pairs and tells the PhysX how to process them.
|
||||
// Do not be misleaded by the term "shader". It should not be
|
||||
// confused with shaders in the rendering pipeline.
|
||||
//
|
||||
// See simulationFilterShader for more details.
|
||||
//
|
||||
// Then, we implement a class derived from PxSimulationEventCallback.
|
||||
// This class will process various callbacks fired by the
|
||||
// physics simulation. Among the possible callbacks, there is
|
||||
// onContact method, which we are currently interested in.
|
||||
// Using onContact method, we can examine all the contact pairs
|
||||
// and access the details about the contact.
|
||||
//
|
||||
// See SimulationEventCallback for more details.
|
||||
//
|
||||
// Now, copy the neccessary parts of the code from the exercise 8_1,
|
||||
// so that we get working simulation of box falling onto the plane.
|
||||
//
|
||||
// In SimulationEventCallback::onContact implement
|
||||
// the following features:
|
||||
// * print the number of contact pairs
|
||||
// * for each contact pair print the number of contact points
|
||||
// between the given pair
|
||||
// * for each point print the x,y,z coordinates of its position
|
||||
//
|
||||
// As the result, a number of points should be printed each time
|
||||
// the box touches the ground. When it finally rests on the ground,
|
||||
// the points are no longer reported.
|
||||
// In order to get the points even if the box rests, add the flag
|
||||
// PxPairFlag::eNOTIFY_TOUCH_PERSISTS to pairFlags
|
||||
// in simulationFilterShader.
|
||||
//
|
||||
// Now, copy the neccessary parts of the code from the exercise 8_2,
|
||||
// so that we get working simulation of a wall of boxes and a ball
|
||||
// destroying the wall.
|
||||
//
|
||||
// Modify the SimulationEventCallback::onContact method,
|
||||
// so that we print only the contacts for which one actor is the ball.
|
||||
// (We don't want to print all the contacts between the boxes,
|
||||
// and between the boxes and the ground).
|
||||
//
|
||||
//------------------------------------------------------------------
|
||||
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// contact pairs filtering function
|
||||
static PxFilterFlags simulationFilterShader(PxFilterObjectAttributes attributes0,
|
||||
PxFilterData filterData0, PxFilterObjectAttributes attributes1, PxFilterData filterData1,
|
||||
PxPairFlags& pairFlags, const void* constantBlock, PxU32 constantBlockSize)
|
||||
{
|
||||
pairFlags =
|
||||
PxPairFlag::eCONTACT_DEFAULT | // default contact processing
|
||||
PxPairFlag::eNOTIFY_CONTACT_POINTS | // contact points will be available in onContact callback
|
||||
PxPairFlag::eNOTIFY_TOUCH_FOUND; // onContact callback will be called for this pair
|
||||
|
||||
return physx::PxFilterFlag::eDEFAULT;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// simulation events processor
|
||||
class SimulationEventCallback : public PxSimulationEventCallback
|
||||
{
|
||||
public:
|
||||
void onContact(const PxContactPairHeader& pairHeader,
|
||||
const PxContactPair* pairs, PxU32 nbPairs)
|
||||
{
|
||||
// HINT: You can check which actors are in contact
|
||||
// using pairHeader.actors[0] and pairHeader.actors[1]
|
||||
|
||||
for (PxU32 i = 0; i < nbPairs; i++)
|
||||
{
|
||||
const PxContactPair& cp = pairs[i];
|
||||
|
||||
// HINT: two get the contact points, use
|
||||
// PxContactPair::extractContacts
|
||||
|
||||
// You need to provide the function with a buffer
|
||||
// in which the contact points will be stored.
|
||||
// Create an array (vector) of type PxContactPairPoint
|
||||
// The number of elements in array should be at least
|
||||
// cp.contactCount (which is the number of contact points)
|
||||
// You also need to provide the function with the
|
||||
// size of the buffer (it should equal the size of the
|
||||
// array in bytes)
|
||||
// Finally, for every extracted point, you can access
|
||||
// its details, such as position
|
||||
}
|
||||
}
|
||||
|
||||
// The functions below are not used in this exercise.
|
||||
// However, they need to be defined for the class to compile.
|
||||
virtual void onConstraintBreak(PxConstraintInfo* constraints, PxU32 count) {}
|
||||
virtual void onWake(PxActor** actors, PxU32 count) {}
|
||||
virtual void onSleep(PxActor** actors, PxU32 count) {}
|
||||
virtual void onTrigger(PxTriggerPair* pairs, PxU32 count) {}
|
||||
virtual void onAdvance(const PxRigidBody*const* bodyBuffer, const PxTransform* poseBuffer, const PxU32 count) {}
|
||||
};
|
||||
|
||||
// Initalization of physical scene (PhysX)
|
||||
SimulationEventCallback simulationEventCallback;
|
||||
Physics pxScene(9.8 /* gravity (m/s^2) */, simulationFilterShader,
|
||||
&simulationEventCallback);
|
||||
|
||||
// fixed timestep for stable and deterministic simulation
|
||||
const double physicsStepTime = 1.f / 60.f;
|
||||
double physicsTimeToProcess = 0;
|
||||
|
||||
//----------------------------------------------
|
||||
Core::Shader_Loader shaderLoader;
|
||||
GLuint programColor;
|
||||
GLuint programTexture;
|
||||
|
||||
glm::vec3 cameraPos = glm::vec3(0, 5, 20);
|
||||
glm::vec3 cameraDir;
|
||||
glm::vec3 cameraSide;
|
||||
float cameraAngle = 0;
|
||||
glm::mat4 cameraMatrix, perspectiveMatrix;
|
||||
|
||||
glm::vec3 lightDir = glm::normalize(glm::vec3(0.5, -1, -0.5));
|
||||
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
//----------------------------------------------------------
|
||||
// Here paste the necessary code for rendering and physics
|
||||
//----------------------------------------------------------
|
||||
//----------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
void keyboard(unsigned char key, int x, int y)
|
||||
{
|
||||
float angleSpeed = 0.1f;
|
||||
float moveSpeed = 0.1f;
|
||||
switch (key)
|
||||
{
|
||||
case 'z': cameraAngle -= angleSpeed; break;
|
||||
case 'x': cameraAngle += angleSpeed; break;
|
||||
case 'w': cameraPos += cameraDir * moveSpeed; break;
|
||||
case 's': cameraPos -= cameraDir * moveSpeed; break;
|
||||
case 'd': cameraPos += cameraSide * moveSpeed; break;
|
||||
case 'a': cameraPos -= cameraSide * moveSpeed; break;
|
||||
}
|
||||
}
|
||||
|
||||
void mouse(int x, int y)
|
||||
{
|
||||
}
|
||||
|
||||
glm::mat4 createCameraMatrix()
|
||||
{
|
||||
cameraDir = glm::normalize(glm::vec3(cosf(cameraAngle - glm::radians(90.0f)), 0, sinf(cameraAngle - glm::radians(90.0f))));
|
||||
glm::vec3 up = glm::vec3(0, 1, 0);
|
||||
cameraSide = glm::cross(cameraDir, up);
|
||||
|
||||
return Core::createViewMatrix(cameraPos, cameraDir, up);
|
||||
}
|
||||
|
||||
void drawObjectColor(Core::RenderContext context, glm::mat4 modelMatrix, glm::vec3 color)
|
||||
{
|
||||
GLuint program = programColor;
|
||||
|
||||
glUseProgram(program);
|
||||
|
||||
glUniform3f(glGetUniformLocation(program, "objectColor"), color.x, color.y, color.z);
|
||||
glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
|
||||
|
||||
glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
|
||||
|
||||
Core::DrawContext(context);
|
||||
|
||||
glUseProgram(0);
|
||||
}
|
||||
|
||||
void drawObjectTexture(Core::RenderContext context, glm::mat4 modelMatrix, GLuint textureId)
|
||||
{
|
||||
GLuint program = programTexture;
|
||||
|
||||
glUseProgram(program);
|
||||
|
||||
glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
|
||||
Core::SetActiveTexture(textureId, "textureSampler", program, 0);
|
||||
|
||||
glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
|
||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
|
||||
|
||||
Core::DrawContext(context);
|
||||
|
||||
glUseProgram(0);
|
||||
}
|
||||
|
||||
void renderScene()
|
||||
{
|
||||
double time = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
|
||||
static double prevTime = time;
|
||||
double dtime = time - prevTime;
|
||||
prevTime = time;
|
||||
|
||||
// Update physics
|
||||
if (dtime < 1.f) {
|
||||
physicsTimeToProcess += dtime;
|
||||
while (physicsTimeToProcess > 0) {
|
||||
// here we perform the physics simulation step
|
||||
pxScene.step(physicsStepTime);
|
||||
physicsTimeToProcess -= physicsStepTime;
|
||||
}
|
||||
}
|
||||
|
||||
// Update of camera and perspective matrices
|
||||
cameraMatrix = createCameraMatrix();
|
||||
perspectiveMatrix = Core::createPerspectiveMatrix();
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
|
||||
|
||||
//----------------------------------------------------------
|
||||
//----------------------------------------------------------
|
||||
// Here paste the necessary code for rendering and physics
|
||||
//----------------------------------------------------------
|
||||
//----------------------------------------------------------
|
||||
|
||||
glutSwapBuffers();
|
||||
}
|
||||
|
||||
void init()
|
||||
{
|
||||
srand(time(0));
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
programColor = shaderLoader.CreateProgram("shaders/shader_color.vert", "shaders/shader_color.frag");
|
||||
programTexture = shaderLoader.CreateProgram("shaders/shader_tex.vert", "shaders/shader_tex.frag");
|
||||
|
||||
//----------------------------------------------------------
|
||||
//----------------------------------------------------------
|
||||
// Here paste the necessary code for rendering and physics
|
||||
//----------------------------------------------------------
|
||||
//----------------------------------------------------------
|
||||
}
|
||||
|
||||
void shutdown()
|
||||
{
|
||||
shaderLoader.DeleteProgram(programColor);
|
||||
shaderLoader.DeleteProgram(programTexture);
|
||||
}
|
||||
|
||||
void idle()
|
||||
{
|
||||
glutPostRedisplay();
|
||||
}
|
||||
|
||||
int main(int argc, char ** argv)
|
||||
{
|
||||
glutInit(&argc, argv);
|
||||
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
|
||||
glutInitWindowPosition(200, 200);
|
||||
glutInitWindowSize(600, 600);
|
||||
glutCreateWindow("OpenGL + PhysX");
|
||||
glewInit();
|
||||
|
||||
init();
|
||||
glutKeyboardFunc(keyboard);
|
||||
glutPassiveMotionFunc(mouse);
|
||||
glutDisplayFunc(renderScene);
|
||||
glutIdleFunc(idle);
|
||||
|
||||
glutMainLoop();
|
||||
|
||||
shutdown();
|
||||
|
||||
return 0;
|
||||
}
|
291
cw 8/src/objload.h
Normal file
291
cw 8/src/objload.h
Normal file
@ -0,0 +1,291 @@
|
||||
/* Copyright (c) 2012, Gerhard Reitmayr
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
|
||||
|
||||
#ifndef OBJLOAD_H_
|
||||
#define OBJLOAD_H_
|
||||
|
||||
#include <algorithm>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
|
||||
namespace obj {
|
||||
|
||||
struct Model {
|
||||
std::vector<float> vertex; //< 3 * N entries
|
||||
std::vector<float> texCoord; //< 2 * N entries
|
||||
std::vector<float> normal; //< 3 * N entries
|
||||
|
||||
std::map<std::string, std::vector<unsigned short> > faces; //< assume triangels and uniform indexing
|
||||
};
|
||||
|
||||
struct ObjModel {
|
||||
struct FaceVertex {
|
||||
FaceVertex() : v(-1), t(-1), n(-1) {}
|
||||
int v, t, n;
|
||||
|
||||
bool operator<( const FaceVertex & other ) const;
|
||||
bool operator==( const FaceVertex & other ) const;
|
||||
};
|
||||
|
||||
typedef std::pair<std::vector<FaceVertex>, std::vector<unsigned> > FaceList;
|
||||
|
||||
std::vector<float> vertex; //< 3 * N entries
|
||||
std::vector<float> texCoord; //< 2 * N entries
|
||||
std::vector<float> normal; //< 3 * N entries
|
||||
|
||||
std::map<std::string, FaceList > faces;
|
||||
};
|
||||
|
||||
inline ObjModel parseObjModel( std::istream & in);
|
||||
inline void tesselateObjModel( ObjModel & obj);
|
||||
inline ObjModel tesselateObjModel( const ObjModel & obj );
|
||||
inline Model convertToModel( const ObjModel & obj );
|
||||
|
||||
inline Model loadModel( std::istream & in );
|
||||
inline Model loadModelFromString( const std::string & in );
|
||||
inline Model loadModelFromFile( const std::string & in );
|
||||
|
||||
inline std::ostream & operator<<( std::ostream & out, const Model & m );
|
||||
inline std::ostream & operator<<( std::ostream & out, const ObjModel::FaceVertex & f);
|
||||
|
||||
// ---------------------------- Implementation starts here -----------------------
|
||||
|
||||
inline bool ObjModel::FaceVertex::operator<( const ObjModel::FaceVertex & other ) const {
|
||||
return (v < other.v) || (v == other.v && t < other.t ) || (v == other.v && t == other.t && n < other.n);
|
||||
}
|
||||
|
||||
inline bool ObjModel::FaceVertex::operator==( const ObjModel::FaceVertex & other ) const {
|
||||
return (v == other.v && t == other.t && n == other.n);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline std::istream & operator>>(std::istream & in, std::vector<T> & vec ){
|
||||
T temp;
|
||||
if(in >> temp)
|
||||
vec.push_back(temp);
|
||||
return in;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline std::istream & operator>>(std::istream & in, std::set<T> & vec ){
|
||||
T temp;
|
||||
if(in >> temp)
|
||||
vec.insert(temp);
|
||||
return in;
|
||||
}
|
||||
|
||||
inline std::istream & operator>>( std::istream & in, ObjModel::FaceVertex & f){
|
||||
if(in >> f.v){
|
||||
if(in.peek() == '/'){
|
||||
in.get();
|
||||
in >> f.t;
|
||||
in.clear();
|
||||
if(in.peek() == '/'){
|
||||
in.get();
|
||||
in >> f.n;
|
||||
in.clear();
|
||||
}
|
||||
}
|
||||
in.clear();
|
||||
--f.v;
|
||||
--f.t;
|
||||
--f.n;
|
||||
}
|
||||
// std::cout << f << std::endl;
|
||||
return in;
|
||||
}
|
||||
|
||||
ObjModel parseObjModel( std::istream & in ){
|
||||
char line[1024];
|
||||
std::string op;
|
||||
std::istringstream line_in;
|
||||
std::set<std::string> groups;
|
||||
groups.insert("default");
|
||||
|
||||
ObjModel data;
|
||||
|
||||
while(in.good()){
|
||||
in.getline(line, 1023);
|
||||
line_in.clear();
|
||||
line_in.str(line);
|
||||
|
||||
if(!(line_in >> op))
|
||||
continue;
|
||||
if(op == "v")
|
||||
line_in >> data.vertex >> data.vertex >> data.vertex;
|
||||
else if(op == "vt")
|
||||
line_in >> data.texCoord >> data.texCoord >> data.texCoord;
|
||||
else if(op == "vn")
|
||||
line_in >> data.normal >> data.normal >> data.normal;
|
||||
else if(op == "g"){
|
||||
groups.clear();
|
||||
while(line_in >> groups) ;
|
||||
groups.insert("default");
|
||||
}
|
||||
else if(op == "f") {
|
||||
std::vector<ObjModel::FaceVertex> list;
|
||||
while(line_in >> list) ;
|
||||
|
||||
for(std::set<std::string>::const_iterator g = groups.begin(); g != groups.end(); ++g){
|
||||
ObjModel::FaceList & fl = data.faces[*g];
|
||||
fl.second.push_back(fl.first.size());
|
||||
fl.first.insert(fl.first.end(), list.begin(), list.end());
|
||||
}
|
||||
}
|
||||
}
|
||||
for(std::map<std::string, ObjModel::FaceList>::iterator g = data.faces.begin(); g != data.faces.end(); ++g){
|
||||
ObjModel::FaceList & fl = g->second;
|
||||
fl.second.push_back(fl.first.size());
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
inline void tesselateObjModel( std::vector<ObjModel::FaceVertex> & input, std::vector<unsigned> & input_start){
|
||||
std::vector<ObjModel::FaceVertex> output;
|
||||
std::vector<unsigned> output_start;
|
||||
output.reserve(input.size());
|
||||
output_start.reserve(input_start.size());
|
||||
|
||||
for(std::vector<unsigned>::const_iterator s = input_start.begin(); s != input_start.end() - 1; ++s){
|
||||
const unsigned size = *(s+1) - *s;
|
||||
if(size > 3){
|
||||
const ObjModel::FaceVertex & start_vertex = input[*s];
|
||||
for( int i = 1; i < (int)size-1; ++i){
|
||||
output_start.push_back(output.size());
|
||||
output.push_back(start_vertex);
|
||||
output.push_back(input[*s+i]);
|
||||
output.push_back(input[*s+i+1]);
|
||||
}
|
||||
} else {
|
||||
output_start.push_back(output.size());
|
||||
output.insert(output.end(), input.begin() + *s, input.begin() + *(s+1));
|
||||
}
|
||||
}
|
||||
output_start.push_back(output.size());
|
||||
input.swap(output);
|
||||
input_start.swap(output_start);
|
||||
}
|
||||
|
||||
void tesselateObjModel( ObjModel & obj){
|
||||
for(std::map<std::string, ObjModel::FaceList>::iterator g = obj.faces.begin(); g != obj.faces.end(); ++g){
|
||||
ObjModel::FaceList & fl = g->second;
|
||||
tesselateObjModel(fl.first, fl.second);
|
||||
}
|
||||
}
|
||||
|
||||
Model convertToModel( const ObjModel & obj ) {
|
||||
// insert all face vertices into a vector and make unique
|
||||
std::vector<ObjModel::FaceVertex> unique(obj.faces.find("default")->second.first);
|
||||
std::sort(unique.begin(), unique.end());
|
||||
unique.erase( std::unique(unique.begin(), unique.end()), unique.end());
|
||||
|
||||
// build a new model with repeated vertices/texcoords/normals to have single indexing
|
||||
Model model;
|
||||
for(std::vector<ObjModel::FaceVertex>::const_iterator f = unique.begin(); f != unique.end(); ++f){
|
||||
model.vertex.insert(model.vertex.end(), obj.vertex.begin() + 3*f->v, obj.vertex.begin() + 3*f->v + 3);
|
||||
if(!obj.texCoord.empty()){
|
||||
const int index = (f->t > -1) ? f->t : f->v;
|
||||
model.texCoord.insert(model.texCoord.end(), obj.texCoord.begin() + 2*index, obj.texCoord.begin() + 2*index + 2);
|
||||
}
|
||||
if(!obj.normal.empty()){
|
||||
const int index = (f->n > -1) ? f->n : f->v;
|
||||
model.normal.insert(model.normal.end(), obj.normal.begin() + 3*index, obj.normal.begin() + 3*index + 3);
|
||||
}
|
||||
}
|
||||
// look up unique index and transform face descriptions
|
||||
for(std::map<std::string, ObjModel::FaceList>::const_iterator g = obj.faces.begin(); g != obj.faces.end(); ++g){
|
||||
const std::string & name = g->first;
|
||||
const ObjModel::FaceList & fl = g->second;
|
||||
std::vector<unsigned short> & v = model.faces[g->first];
|
||||
v.reserve(fl.first.size());
|
||||
for(std::vector<ObjModel::FaceVertex>::const_iterator f = fl.first.begin(); f != fl.first.end(); ++f){
|
||||
const unsigned short index = std::distance(unique.begin(), std::lower_bound(unique.begin(), unique.end(), *f));
|
||||
v.push_back(index);
|
||||
}
|
||||
}
|
||||
return model;
|
||||
}
|
||||
|
||||
ObjModel tesselateObjModel( const ObjModel & obj ){
|
||||
ObjModel result = obj;
|
||||
tesselateObjModel(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
Model loadModel( std::istream & in ){
|
||||
ObjModel model = parseObjModel(in);
|
||||
tesselateObjModel(model);
|
||||
return convertToModel(model);
|
||||
}
|
||||
|
||||
Model loadModelFromString( const std::string & str ){
|
||||
std::istringstream in(str);
|
||||
return loadModel(in);
|
||||
}
|
||||
|
||||
Model loadModelFromFile( const std::string & str) {
|
||||
std::ifstream in(str.c_str());
|
||||
return loadModel(in);
|
||||
}
|
||||
|
||||
inline std::ostream & operator<<( std::ostream & out, const ObjModel::FaceVertex & f){
|
||||
out << f.v << "\t" << f.t << "\t" << f.n;
|
||||
return out;
|
||||
}
|
||||
|
||||
std::ostream & operator<<( std::ostream & out, const Model & m ){
|
||||
if(!m.vertex.empty()){
|
||||
out << "vertex\n";
|
||||
for(int i = 0; i < (int)m.vertex.size(); ++i)
|
||||
out << m.vertex[i] << (((i % 3) == 2)?"\n":"\t");
|
||||
}
|
||||
if(!m.texCoord.empty()){
|
||||
out << "texCoord\n";
|
||||
for(int i = 0; i < (int)m.texCoord.size(); ++i)
|
||||
out << m.texCoord[i] << (((i % 2) == 1)?"\n":"\t");
|
||||
}
|
||||
if(!m.normal.empty()){
|
||||
out << "normal\n";
|
||||
for(int i = 0; i < (int)m.normal.size(); ++i)
|
||||
out << m.normal[i] << (((i % 3) == 2)?"\n":"\t");
|
||||
}
|
||||
if(!m.faces.empty()){
|
||||
out << "faces\t";
|
||||
for(std::map<std::string, std::vector<unsigned short> >::const_iterator g = m.faces.begin(); g != m.faces.end(); ++g){
|
||||
out << g->first << " ";
|
||||
}
|
||||
out << "\n";
|
||||
// for(int i = 0; i < m.face.size(); ++i)
|
||||
// out << m.face[i] << (((i % 3) == 2)?"\n":"\t");
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
} // namespace obj
|
||||
|
||||
#endif // OBJLOAD_H_
|
BIN
cw 8/textures/a.jpg
Normal file
BIN
cw 8/textures/a.jpg
Normal file
Binary file not shown.
After Width: | Height: | Size: 3.0 MiB |
BIN
cw 8/textures/sand.jpg
Normal file
BIN
cw 8/textures/sand.jpg
Normal file
Binary file not shown.
After Width: | Height: | Size: 441 KiB |
832
cw 8/zadania 8.html
Normal file
832
cw 8/zadania 8.html
Normal file
File diff suppressed because one or more lines are too long
134
cw 8/zadania 8.md
Normal file
134
cw 8/zadania 8.md
Normal file
@ -0,0 +1,134 @@
|
||||
# Obsługa PhysX
|
||||
|
||||
PhysX jest silnikiem fizyki. Zadaniem silnika fizyki jest przeprowadzenie obliczeń związanych z symulacją zjawisk fizycznych jak dynamika brył sztywnych, płynów lub *soft body dynamics*. Wyręcza on twórcę gry w samodzielnej implementacji fizyki.
|
||||
|
||||
Innymi popularnymi silnikami fizyki są:
|
||||
|
||||
* Havok
|
||||
* Bullet
|
||||
* Advanced Simulation Librar
|
||||
|
||||
My wykorzystamy PhysXa do symulacji dynamiki brył sztywnych. Dokumentację można znaleźć w poniższych linkach
|
||||
|
||||
https://gameworksdocs.nvidia.com/PhysX/4.1/documentation/physxguide/Manual/Index.html
|
||||
https://gameworksdocs.nvidia.com/PhysX/4.1/documentation/physxapi/files/index.html
|
||||
|
||||
## Inicjalizacja PhysX
|
||||
|
||||
W tej części przejdziemy po istniejącym kodzie i omówimy jego działanie.
|
||||
|
||||
Zaczniemy od klasy `Physics`, która zawiera atrybut `scene`, (która zawiera naszą scenę, czyli obiekty *aktorów*, które mają ze sobą fizycznie reagować i ich własności.) oraz atrybut `physics`, który służy do tworzenia tych obiektów.
|
||||
|
||||
Jej konstruktor wygląda następująco:
|
||||
|
||||
```C++
|
||||
Physics::Physics(float gravity)
|
||||
{
|
||||
foundation = PxCreateFoundation(PX_PHYSICS_VERSION, allocator, errorCallback);
|
||||
physics = PxCreatePhysics(PX_PHYSICS_VERSION, *foundation, PxTolerancesScale(), true);
|
||||
|
||||
PxSceneDesc sceneDesc(physics->getTolerancesScale());
|
||||
// określa siłę i kierunek grawitacji
|
||||
sceneDesc.gravity = PxVec3(0.0f, -gravity, 0.0f);
|
||||
// definicja dispatchera, który rozdziela zadania do wykonania, tutaj korzystamy z domyślnego dispatchera, któy będzie działał na 2 wątkach
|
||||
dispatcher = PxDefaultCpuDispatcherCreate(2);
|
||||
sceneDesc.cpuDispatcher = dispatcher;
|
||||
// definicja filtra, filtr decyduje między jakimi obiektami
|
||||
sceneDesc.filterShader = PxDefaultSimulationFilterShader;
|
||||
scene = physics->createScene(sceneDesc);
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
Następnie mamy funkcję `step`, która wykonuje symulację, składa się ona z 2 kroków; najpierw wykonywana jest symulacja, następnie pobierane wyniki.
|
||||
|
||||
Położenie w scenie physXa musimy przenieść do naszej sceny macierze transformacji odpowiadające ich położeniu są pobierane w funkcji
|
||||
|
||||
```C++
|
||||
void updateTransforms()
|
||||
{
|
||||
// Definiujemy flagę jakie obiekty chcemy pobrać, w tym wypadku statyczne i dynamiczne.
|
||||
auto actorFlags = PxActorTypeFlag::eRIGID_DYNAMIC | PxActorTypeFlag::eRIGID_STATIC;
|
||||
PxU32 nbActors = pxScene.scene->getNbActors(actorFlags);
|
||||
if (nbActors)
|
||||
{
|
||||
//pobieramy obiekty
|
||||
std::vector<PxRigidActor*> actors(nbActors);
|
||||
pxScene.scene->getActors(actorFlags, (PxActor**)&actors[0], nbActors);
|
||||
for (auto actor : actors)
|
||||
{
|
||||
// Userdata jest atrybutem, któy przechowuje wskaźnik do obiektu zdefiniowanego przez nas, służy do powiądania aktora ze sceny z naszym obiektem. My będziemy tu przechowywać macierz transformacji
|
||||
if (!actor->userData) continue;
|
||||
glm::mat4 *modelMatrix = (glm::mat4*)actor->userData;
|
||||
|
||||
// pobiera położenie aktora
|
||||
PxMat44 transform = actor->getGlobalPose();
|
||||
auto &c0 = transform.column0;
|
||||
auto &c1 = transform.column1;
|
||||
auto &c2 = transform.column2;
|
||||
auto &c3 = transform.column3;
|
||||
|
||||
// ustawia wartości macierzy z userData
|
||||
*modelMatrix = glm::mat4(
|
||||
c0.x, c0.y, c0.z, c0.w,
|
||||
c1.x, c1.y, c1.z, c1.w,
|
||||
c2.x, c2.y, c2.z, c2.w,
|
||||
c3.x, c3.y, c3.z, c3.w);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Tworzenie aktora
|
||||
|
||||
Aktora tworzy się za pomocą metod klasy `PxPhysics`, jest ona dostępna u nas po `pxScene.physics` (pamiętaj, że jest to wskaźnik i trzeba używać strzałki zamiast kropki do wywołania metod).
|
||||
|
||||
Aby stworzyć aktora należy użyć metody `createRigidStatic` lub `createRigidDynamic`, które tworzą odpowiednio statycznego i dynamicznego aktora (o aktorze statycznym można pomyśleć jak o obiekcie z nieskończoną masą, na którego nie działają żadne siły). Funkcja przyjmuje argument `transform`, który jest początkową pozycją.
|
||||
|
||||
Następnie musimy określić kształt obiektu za pomocą za pomocą metody `createShape` ona z kolei przyjmuje 2 argumenty: geometrię i materiał. Geometria odpowiada za kształt obiektu (przykładowo `PxPlaneGeometry()` daje nam płaszczyznę a `PxBoxGeometry(hx, hy, hz)` daje prostopadłościan o wymiarach 2hx na 2hy na 2hz). Kształt dodaje się do aktora za pomocą metody `attachShape`. Dodany kształt należy usunąć używając jego metody `release`
|
||||
|
||||
Dodatkowo do aktora można dodać dodatkowe dane poprzez atrybut `userData`, który jest wskaźnikiem typu `void*`. Wykorzystywany jest by powiązać scenę silnika fizycznego z reprezentacją graficzną, która będzie na ekranie
|
||||
|
||||
### Zadanie
|
||||
|
||||
Wykonaj zadania opisane w komentarzach pliku **main_8_1** i **main_8_2**
|
||||
|
||||
|
||||
|
||||
## Rejestrowanie zdarzeń
|
||||
|
||||
W tej części skupimy się na rejestrowaniu i obsłudze zderzeń pomiędzy obiektami. Jest to przydatna funkcjonalność przy tworzeniu gier lub ogólnie aplikacji wykorzystującej fizykę. Z ich pomocą można zaimplementować szereg mechanik, jak zadanie obrażeń w wyniku trafienia pociskiem/bronią białą, wywołanie animacji czy przytwierdzenie haka do ściany.
|
||||
|
||||
Implementacja wymaga najpierw zdefiniowania swojego *filter shadera*, w którym należy zdefiniować jak mają być obsłużone zdarzenia w scenie physx. W poniższej definicji definiujemy, że punkty zderzenia będą obsługiwane przez `OnContact`.
|
||||
|
||||
```C++
|
||||
static PxFilterFlags simulationFilterShader(PxFilterObjectAttributes attributes0,
|
||||
PxFilterData filterData0, PxFilterObjectAttributes attributes1, PxFilterData filterData1,
|
||||
PxPairFlags& pairFlags, const void* constantBlock, PxU32 constantBlockSize)
|
||||
{
|
||||
pairFlags =
|
||||
PxPairFlag::eCONTACT_DEFAULT | // default contact processing
|
||||
PxPairFlag::eNOTIFY_CONTACT_POINTS | // contact points will be available in onContact callback
|
||||
PxPairFlag::eNOTIFY_TOUCH_FOUND; // onContact callback will be called for this pair
|
||||
|
||||
return physx::PxFilterFlag::eDEFAULT;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
Samą obsługę zdarzeń definiujemy za pomocą wywołań zwrotnych - *callbacków*.
|
||||
|
||||
> Wywołanie zwrotne można rozumieć jako odwrotność wywołania funkcji. Zwykle programista wykorzystuje biblioteki poprzez wywoływanie zawartych w niej funkcji. W tym przypadku jest odwrotnie: programista pisze funkcję i przekazuje ją bibliotece, która odpowiada za jej użycie w odpowiednim momencie.
|
||||
|
||||
*Callback* ustala się poprzez ustawienie odpowiedeniego atrybutu:
|
||||
|
||||
`sceneDesc.simulationEventCallback = simulationEventCallback;`
|
||||
|
||||
Klasa obiektu `simulationEventCallback` musi dziedziczyć po klasie `PxSimulationEventCallback`, która zawiera szereg metod będących różnymi `callbackami` odpowiadającymi za różne zdarzenia. Nas będzie interesować metoda `onContact`, która jest wywoływana dla każdego zetknięcia się dwóch obiektów w scenie.
|
||||
|
||||
### Zadania
|
||||
|
||||
Wykonaj zadania opisane w **main8_3.cpp**.
|
||||
|
||||
Jak zrobisz raportowanie na konsoli zderzeń pomiędzy kulą a kostkami zmodyfikuj kod tak, żeby kostki, które zetkną się z kulą znikały
|
38
grk-cw.sln
38
grk-cw.sln
@ -9,36 +9,64 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw3", "cw 3\grk-cw3.vcx
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw4", "cw 4\grk-cw4.vcxproj", "{C9BB5347-723E-4274-B60A-4A69989E9DC3}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw5", "cw 5\grk-cw5.vcxproj", "{3A5EA2E9-4B50-4E36-B2AA-7DC086FCD066}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw6", "cw 6\grk-cw6.vcxproj", "{10701B86-9B0B-46A1-85DA-6238CBCC507B}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw5", "cw 5\grk-cw5.vcxproj", "{3A5EA2E9-4B50-4E36-B2AA-7DC086FCD066}"
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw7", "cw 7\grk-cw7.vcxproj", "{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw8", "cw 8\grk-cw8.vcxproj", "{4EE187F6-DEE7-4917-86D9-08C36D54920F}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Win32 = Debug|Win32
|
||||
Debug|x64 = Debug|x64
|
||||
Release|Win32 = Release|Win32
|
||||
Release|x64 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{B4031E08-6274-4FFD-B41C-F8EA29E977FB}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{B4031E08-6274-4FFD-B41C-F8EA29E977FB}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{B4031E08-6274-4FFD-B41C-F8EA29E977FB}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{B4031E08-6274-4FFD-B41C-F8EA29E977FB}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{B4031E08-6274-4FFD-B41C-F8EA29E977FB}.Release|Win32.Build.0 = Release|Win32
|
||||
{B4031E08-6274-4FFD-B41C-F8EA29E977FB}.Release|x64.ActiveCfg = Release|Win32
|
||||
{F201D210-49F1-4EFF-B8A0-56D56880D14B}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{F201D210-49F1-4EFF-B8A0-56D56880D14B}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{F201D210-49F1-4EFF-B8A0-56D56880D14B}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{F201D210-49F1-4EFF-B8A0-56D56880D14B}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{F201D210-49F1-4EFF-B8A0-56D56880D14B}.Release|Win32.Build.0 = Release|Win32
|
||||
{F201D210-49F1-4EFF-B8A0-56D56880D14B}.Release|x64.ActiveCfg = Release|Win32
|
||||
{C9BB5347-723E-4274-B60A-4A69989E9DC3}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{C9BB5347-723E-4274-B60A-4A69989E9DC3}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{C9BB5347-723E-4274-B60A-4A69989E9DC3}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{C9BB5347-723E-4274-B60A-4A69989E9DC3}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{C9BB5347-723E-4274-B60A-4A69989E9DC3}.Release|Win32.Build.0 = Release|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|Win32.Build.0 = Release|Win32
|
||||
{C9BB5347-723E-4274-B60A-4A69989E9DC3}.Release|x64.ActiveCfg = Release|Win32
|
||||
{3A5EA2E9-4B50-4E36-B2AA-7DC086FCD066}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{3A5EA2E9-4B50-4E36-B2AA-7DC086FCD066}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{3A5EA2E9-4B50-4E36-B2AA-7DC086FCD066}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{3A5EA2E9-4B50-4E36-B2AA-7DC086FCD066}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{3A5EA2E9-4B50-4E36-B2AA-7DC086FCD066}.Release|Win32.Build.0 = Release|Win32
|
||||
{3A5EA2E9-4B50-4E36-B2AA-7DC086FCD066}.Release|x64.ActiveCfg = Release|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|Win32.Build.0 = Release|Win32
|
||||
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|x64.ActiveCfg = Release|Win32
|
||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Release|Win32.Build.0 = Release|Win32
|
||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Release|x64.ActiveCfg = Release|Win32
|
||||
{4EE187F6-DEE7-4917-86D9-08C36D54920F}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{4EE187F6-DEE7-4917-86D9-08C36D54920F}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{4EE187F6-DEE7-4917-86D9-08C36D54920F}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{4EE187F6-DEE7-4917-86D9-08C36D54920F}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{4EE187F6-DEE7-4917-86D9-08C36D54920F}.Release|Win32.Build.0 = Release|Win32
|
||||
{4EE187F6-DEE7-4917-86D9-08C36D54920F}.Release|x64.ActiveCfg = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
|
Loading…
Reference in New Issue
Block a user