add camera movement
@ -11,49 +11,41 @@
|
|||||||
</ProjectConfiguration>
|
</ProjectConfiguration>
|
||||||
</ItemGroup>
|
</ItemGroup>
|
||||||
<ItemGroup>
|
<ItemGroup>
|
||||||
<ClInclude Include="src\Camera.h" />
|
|
||||||
<ClInclude Include="src\mesh.h" />
|
|
||||||
<ClInclude Include="src\model.h" />
|
|
||||||
<ClInclude Include="src\objload.h" />
|
|
||||||
<ClInclude Include="src\Physics.h" />
|
|
||||||
<ClInclude Include="src\picopng.h" />
|
|
||||||
<ClInclude Include="src\Render_Utils.h" />
|
|
||||||
<ClInclude Include="src\Shader_Loader.h" />
|
|
||||||
<ClInclude Include="src\stb_image.h" />
|
|
||||||
<ClInclude Include="src\Texture.h" />
|
|
||||||
</ItemGroup>
|
|
||||||
<ItemGroup>
|
|
||||||
<ClCompile Include="src\Box.cpp" />
|
|
||||||
<ClCompile Include="src\Camera.cpp" />
|
<ClCompile Include="src\Camera.cpp" />
|
||||||
<ClCompile Include="src\main.cpp" />
|
<ClCompile Include="src\main.cpp" />
|
||||||
<ClCompile Include="src\Physics.cpp" />
|
|
||||||
<ClCompile Include="src\picopng.cpp" />
|
|
||||||
<ClCompile Include="src\Render_Utils.cpp" />
|
<ClCompile Include="src\Render_Utils.cpp" />
|
||||||
<ClCompile Include="src\Shader_Loader.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" />
|
<ClCompile Include="src\Texture.cpp" />
|
||||||
</ItemGroup>
|
</ItemGroup>
|
||||||
<ItemGroup>
|
<ItemGroup>
|
||||||
<None Include="shaders\shader_4_1.frag" />
|
<ClInclude Include="src\Camera.h" />
|
||||||
<None Include="shaders\shader_4_1.vert" />
|
<ClInclude Include="src\objload.h" />
|
||||||
<None Include="shaders\shader_4_sun.frag" />
|
<ClInclude Include="src\Render_Utils.h" />
|
||||||
<None Include="shaders\shader_4_sun.vert" />
|
<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.frag" />
|
||||||
<None Include="shaders\shader_color.vert" />
|
<None Include="shaders\shader_color.vert" />
|
||||||
<None Include="shaders\shader_red.frag" />
|
|
||||||
<None Include="shaders\shader_red.vert" />
|
|
||||||
<None Include="shaders\shader_spec_tex.frag" />
|
|
||||||
<None Include="shaders\shader_spec_tex.vert" />
|
|
||||||
<None Include="shaders\shader_tex.frag" />
|
<None Include="shaders\shader_tex.frag" />
|
||||||
<None Include="shaders\shader_tex.vert" />
|
<None Include="shaders\shader_tex.vert" />
|
||||||
<None Include="shaders\shader_tex_2.frag" />
|
|
||||||
<None Include="shaders\shader_tex_2.vert" />
|
|
||||||
</ItemGroup>
|
</ItemGroup>
|
||||||
<PropertyGroup Label="Globals">
|
<PropertyGroup Label="Globals">
|
||||||
<ProjectGuid>{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}</ProjectGuid>
|
<ProjectGuid>{10701B86-9B0B-46A1-85DA-6238CBCC507B}</ProjectGuid>
|
||||||
<Keyword>Win32Proj</Keyword>
|
<Keyword>Win32Proj</Keyword>
|
||||||
<RootNamespace>scenaPodwodna</RootNamespace>
|
<RootNamespace>grk-cw6</RootNamespace>
|
||||||
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
|
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
|
||||||
<ProjectName>scena_podwodna</ProjectName>
|
<ProjectName>grk-cw6</ProjectName>
|
||||||
</PropertyGroup>
|
</PropertyGroup>
|
||||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||||
|
@ -14,67 +14,76 @@
|
|||||||
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
|
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
|
||||||
</Filter>
|
</Filter>
|
||||||
<Filter Include="Shader Files">
|
<Filter Include="Shader Files">
|
||||||
<UniqueIdentifier>{e9364a22-c274-41c1-9f8e-146ccf27d19a}</UniqueIdentifier>
|
<UniqueIdentifier>{0a247bb8-2e8e-4a90-b0ef-17415b0941ba}</UniqueIdentifier>
|
||||||
|
</Filter>
|
||||||
|
<Filter Include="Source Files\SOIL">
|
||||||
|
<UniqueIdentifier>{1e762b0e-a07f-4d7a-aedf-9503776529c7}</UniqueIdentifier>
|
||||||
</Filter>
|
</Filter>
|
||||||
</ItemGroup>
|
</ItemGroup>
|
||||||
<ItemGroup>
|
<ItemGroup>
|
||||||
<ClInclude Include="src\Camera.h">
|
<ClCompile Include="src\Render_Utils.cpp">
|
||||||
<Filter>Source Files</Filter>
|
<Filter>Source Files</Filter>
|
||||||
</ClInclude>
|
</ClCompile>
|
||||||
<ClInclude Include="src\mesh.h">
|
<ClCompile Include="src\Shader_Loader.cpp">
|
||||||
<Filter>Source Files</Filter>
|
<Filter>Source Files</Filter>
|
||||||
</ClInclude>
|
</ClCompile>
|
||||||
<ClInclude Include="src\model.h">
|
<ClCompile Include="src\Camera.cpp">
|
||||||
<Filter>Source Files</Filter>
|
<Filter>Source Files</Filter>
|
||||||
</ClInclude>
|
</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\SOIL\image_DXT.c">
|
||||||
|
<Filter>Source Files\SOIL</Filter>
|
||||||
|
</ClCompile>
|
||||||
|
<ClCompile Include="src\Texture.cpp">
|
||||||
|
<Filter>Source Files</Filter>
|
||||||
|
</ClCompile>
|
||||||
|
<ClCompile Include="src\main.cpp">
|
||||||
|
<Filter>Source Files</Filter>
|
||||||
|
</ClCompile>
|
||||||
|
</ItemGroup>
|
||||||
|
<ItemGroup>
|
||||||
<ClInclude Include="src\objload.h">
|
<ClInclude Include="src\objload.h">
|
||||||
<Filter>Source Files</Filter>
|
<Filter>Source Files</Filter>
|
||||||
</ClInclude>
|
</ClInclude>
|
||||||
<ClInclude Include="src\Physics.h">
|
|
||||||
<Filter>Source Files</Filter>
|
|
||||||
</ClInclude>
|
|
||||||
<ClInclude Include="src\picopng.h">
|
|
||||||
<Filter>Source Files</Filter>
|
|
||||||
</ClInclude>
|
|
||||||
<ClInclude Include="src\Render_Utils.h">
|
<ClInclude Include="src\Render_Utils.h">
|
||||||
<Filter>Source Files</Filter>
|
<Filter>Source Files</Filter>
|
||||||
</ClInclude>
|
</ClInclude>
|
||||||
<ClInclude Include="src\Shader_Loader.h">
|
<ClInclude Include="src\Shader_Loader.h">
|
||||||
<Filter>Source Files</Filter>
|
<Filter>Source Files</Filter>
|
||||||
</ClInclude>
|
</ClInclude>
|
||||||
<ClInclude Include="src\stb_image.h">
|
<ClInclude Include="src\Camera.h">
|
||||||
<Filter>Source Files</Filter>
|
<Filter>Source Files</Filter>
|
||||||
</ClInclude>
|
</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\Texture.h">
|
<ClInclude Include="src\Texture.h">
|
||||||
<Filter>Source Files</Filter>
|
<Filter>Source Files</Filter>
|
||||||
</ClInclude>
|
</ClInclude>
|
||||||
</ItemGroup>
|
</ItemGroup>
|
||||||
<ItemGroup>
|
|
||||||
<ClCompile Include="src\main.cpp">
|
|
||||||
<Filter>Source Files</Filter>
|
|
||||||
</ClCompile>
|
|
||||||
<ClCompile Include="src\Physics.cpp">
|
|
||||||
<Filter>Source Files</Filter>
|
|
||||||
</ClCompile>
|
|
||||||
<ClCompile Include="src\picopng.cpp">
|
|
||||||
<Filter>Source Files</Filter>
|
|
||||||
</ClCompile>
|
|
||||||
<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\Texture.cpp">
|
|
||||||
<Filter>Source Files</Filter>
|
|
||||||
</ClCompile>
|
|
||||||
<ClCompile Include="src\Box.cpp">
|
|
||||||
<Filter>Source Files</Filter>
|
|
||||||
</ClCompile>
|
|
||||||
<ClCompile Include="src\Camera.cpp">
|
|
||||||
<Filter>Source Files</Filter>
|
|
||||||
</ClCompile>
|
|
||||||
</ItemGroup>
|
|
||||||
<ItemGroup>
|
<ItemGroup>
|
||||||
<None Include="shaders\shader_color.frag">
|
<None Include="shaders\shader_color.frag">
|
||||||
<Filter>Shader Files</Filter>
|
<Filter>Shader Files</Filter>
|
||||||
@ -82,41 +91,11 @@
|
|||||||
<None Include="shaders\shader_color.vert">
|
<None Include="shaders\shader_color.vert">
|
||||||
<Filter>Shader Files</Filter>
|
<Filter>Shader Files</Filter>
|
||||||
</None>
|
</None>
|
||||||
<None Include="shaders\shader_red.frag">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_red.vert">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_spec_tex.frag">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_spec_tex.vert">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_tex.frag">
|
<None Include="shaders\shader_tex.frag">
|
||||||
<Filter>Shader Files</Filter>
|
<Filter>Shader Files</Filter>
|
||||||
</None>
|
</None>
|
||||||
<None Include="shaders\shader_tex.vert">
|
<None Include="shaders\shader_tex.vert">
|
||||||
<Filter>Shader Files</Filter>
|
<Filter>Shader Files</Filter>
|
||||||
</None>
|
</None>
|
||||||
<None Include="shaders\shader_tex_2.frag">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_tex_2.vert">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_4_1.frag">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_4_1.vert">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_4_sun.frag">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
<None Include="shaders\shader_4_sun.vert">
|
|
||||||
<Filter>Shader Files</Filter>
|
|
||||||
</None>
|
|
||||||
</ItemGroup>
|
</ItemGroup>
|
||||||
</Project>
|
</Project>
|
@ -1,7 +0,0 @@
|
|||||||
|
|
||||||
import os
|
|
||||||
rootdir = './'
|
|
||||||
for filename in os.listdir(rootdir):
|
|
||||||
if filename.endswith(".md"):
|
|
||||||
name = filename[:-3]
|
|
||||||
os.system(f'pandoc -s -o {name}.html {name}.md --css style.css')
|
|
@ -1,21 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
uniform vec3 objectColor;
|
|
||||||
//uniform vec3 lightDir;
|
|
||||||
uniform vec3 lightPos;
|
|
||||||
uniform vec3 cameraPos;
|
|
||||||
|
|
||||||
in vec3 interpNormal;
|
|
||||||
in vec3 fragPos;
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
vec3 lightDir = normalize(lightPos-fragPos);
|
|
||||||
vec3 V = normalize(cameraPos-fragPos);
|
|
||||||
vec3 normal = normalize(interpNormal);
|
|
||||||
vec3 R = reflect(-normalize(lightDir),normal);
|
|
||||||
|
|
||||||
float specular = pow(max(0,dot(R,V)),10);
|
|
||||||
float diffuse = max(0,dot(normal,normalize(lightDir)));
|
|
||||||
gl_FragColor = vec4(mix(objectColor,objectColor*diffuse+vec3(1)*specular,0.9), 1.0);
|
|
||||||
}
|
|
@ -1,17 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
layout(location = 0) in vec3 vertexPosition;
|
|
||||||
layout(location = 1) in vec2 vertexTexCoord;
|
|
||||||
layout(location = 2) in vec3 vertexNormal;
|
|
||||||
|
|
||||||
uniform mat4 transformation;
|
|
||||||
uniform mat4 modelMatrix;
|
|
||||||
out vec3 interpNormal;
|
|
||||||
out vec3 fragPos;
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
gl_Position = transformation * vec4(vertexPosition, 1.0);
|
|
||||||
interpNormal = (modelMatrix*vec4(vertexNormal,0)).xyz;
|
|
||||||
fragPos = (modelMatrix*vec4(vertexPosition,1)).xyz;
|
|
||||||
}
|
|
@ -1,17 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
uniform vec3 objectColor;
|
|
||||||
//uniform vec3 lightDir;
|
|
||||||
uniform vec3 lightPos;
|
|
||||||
uniform vec3 cameraPos;
|
|
||||||
|
|
||||||
in vec3 interpNormal;
|
|
||||||
in vec3 fragPos;
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
vec3 normal = normalize(interpNormal);
|
|
||||||
vec3 V = normalize(cameraPos-fragPos);
|
|
||||||
float coef = max(0,dot(V,normal));
|
|
||||||
gl_FragColor = vec4(mix(objectColor,vec3(1,0.5,0.1),1-coef), 1.0);
|
|
||||||
}
|
|
@ -1,17 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
layout(location = 0) in vec3 vertexPosition;
|
|
||||||
layout(location = 1) in vec2 vertexTexCoord;
|
|
||||||
layout(location = 2) in vec3 vertexNormal;
|
|
||||||
|
|
||||||
uniform mat4 transformation;
|
|
||||||
uniform mat4 modelMatrix;
|
|
||||||
out vec3 interpNormal;
|
|
||||||
out vec3 fragPos;
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
gl_Position = transformation * vec4(vertexPosition, 1.0);
|
|
||||||
interpNormal = (modelMatrix*vec4(vertexNormal,0)).xyz;
|
|
||||||
fragPos = (modelMatrix*vec4(vertexPosition,1)).xyz;
|
|
||||||
}
|
|
@ -8,7 +8,6 @@ in vec3 interpNormal;
|
|||||||
void main()
|
void main()
|
||||||
{
|
{
|
||||||
vec3 normal = normalize(interpNormal);
|
vec3 normal = normalize(interpNormal);
|
||||||
float ambient = 0.2;
|
|
||||||
float diffuse = max(dot(normal, -lightDir), 0.0);
|
float diffuse = max(dot(normal, -lightDir), 0.0);
|
||||||
gl_FragColor = vec4(objectColor * (ambient + (1-ambient) * diffuse), 1.0);
|
gl_FragColor = vec4(objectColor * diffuse, 1.0);
|
||||||
}
|
}
|
||||||
|
@ -1,8 +1,8 @@
|
|||||||
#version 410 core
|
#version 410 core
|
||||||
|
|
||||||
layout(location = 0) in vec3 vertexPosition;
|
layout(location = 0) in vec3 vertexPosition;
|
||||||
layout(location = 1) in vec2 vertexTexCoord;
|
layout(location = 1) in vec3 vertexNormal;
|
||||||
layout(location = 2) in vec3 vertexNormal;
|
layout(location = 2) in vec2 vertexTexCoord;
|
||||||
|
|
||||||
uniform mat4 modelViewProjectionMatrix;
|
uniform mat4 modelViewProjectionMatrix;
|
||||||
uniform mat4 modelMatrix;
|
uniform mat4 modelMatrix;
|
||||||
|
@ -1,6 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
gl_FragColor = vec4(1.0,0.0,0.0, 1.0);
|
|
||||||
}
|
|
@ -1,10 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
layout(location = 0) in vec3 vertexPosition;
|
|
||||||
uniform mat4 modelViewProjectionMatrix;
|
|
||||||
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
gl_Position = modelViewProjectionMatrix * vec4(vertexPosition, 1.0);
|
|
||||||
}
|
|
@ -1,29 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
//uniform vec3 objectColor;
|
|
||||||
uniform vec3 lightDir;
|
|
||||||
//uniform vec3 lightPos;
|
|
||||||
uniform vec3 cameraPos;
|
|
||||||
uniform sampler2D color_texture;
|
|
||||||
uniform sampler2D specular_texture;
|
|
||||||
|
|
||||||
|
|
||||||
in vec3 interpNormal;
|
|
||||||
in vec3 fragPos;
|
|
||||||
in vec2 uvCoord;
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
//float falloff = pow(length(cameraPos-fragPos),2)*0.01;
|
|
||||||
vec3 color = texture(color_texture,uvCoord).rgb;
|
|
||||||
vec3 spec = texture(specular_texture,uvCoord).rgb;
|
|
||||||
//vec3 lightDir = normalize(lightPos-fragPos);
|
|
||||||
vec3 V = normalize(cameraPos-fragPos);
|
|
||||||
vec3 normal = normalize(interpNormal);
|
|
||||||
vec3 R = reflect(-normalize(lightDir),normal);
|
|
||||||
|
|
||||||
float specular = pow(max(0,dot(R,V)),10);
|
|
||||||
float diffuse = max(0,dot(normal,normalize(lightDir)));
|
|
||||||
gl_FragColor = vec4(mix(color,color*diffuse+spec*specular,0.7), 1.0);
|
|
||||||
//gl_FragColor = vec4(mix(vec3(0.1,0.1,0.1),mix(color,color*diffuse+spec*specular,0.7),min(1,1/falloff)), 1.0);
|
|
||||||
}
|
|
@ -1,19 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
layout(location = 0) in vec3 vertexPosition;
|
|
||||||
layout(location = 1) in vec3 vertexNormal;
|
|
||||||
layout(location = 2) in vec2 vertexTexCoord;
|
|
||||||
|
|
||||||
uniform mat4 transformation;
|
|
||||||
uniform mat4 modelMatrix;
|
|
||||||
out vec3 interpNormal;
|
|
||||||
out vec3 fragPos;
|
|
||||||
out vec2 uvCoord;
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
uvCoord = vertexTexCoord;
|
|
||||||
gl_Position = transformation * vec4(vertexPosition, 1.0);
|
|
||||||
interpNormal = (modelMatrix*vec4(vertexNormal,0)).xyz;
|
|
||||||
fragPos = (modelMatrix*vec4(vertexPosition,1)).xyz;
|
|
||||||
}
|
|
@ -11,7 +11,6 @@ void main()
|
|||||||
vec2 modifiedTexCoord = vec2(interpTexCoord.x, 1.0 - interpTexCoord.y); // Poprawka dla tekstur Ziemi, ktore bez tego wyswietlaja sie 'do gory nogami'
|
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 color = texture2D(textureSampler, modifiedTexCoord).rgb;
|
||||||
vec3 normal = normalize(interpNormal);
|
vec3 normal = normalize(interpNormal);
|
||||||
float ambient = 0.2;
|
|
||||||
float diffuse = max(dot(normal, -lightDir), 0.0);
|
float diffuse = max(dot(normal, -lightDir), 0.0);
|
||||||
gl_FragColor = vec4(color * (ambient + (1-ambient) * diffuse), 1.0);
|
gl_FragColor = vec4(color * diffuse, 1.0);
|
||||||
}
|
}
|
||||||
|
@ -1,9 +1,9 @@
|
|||||||
#version 410 core
|
#version 410 core
|
||||||
|
|
||||||
layout(location = 0) in vec3 vertexPosition;
|
layout(location = 0) in vec3 vertexPosition;
|
||||||
layout(location = 1) in vec2 vertexTexCoord;
|
layout(location = 1) in vec3 vertexNormal;
|
||||||
layout(location = 2) in vec3 vertexNormal;
|
|
||||||
|
|
||||||
|
layout(location = 2) in vec2 vertexTexCoord;
|
||||||
uniform mat4 modelViewProjectionMatrix;
|
uniform mat4 modelViewProjectionMatrix;
|
||||||
uniform mat4 modelMatrix;
|
uniform mat4 modelMatrix;
|
||||||
|
|
||||||
|
@ -1,28 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
//uniform vec3 objectColor;
|
|
||||||
uniform vec3 lightDir;
|
|
||||||
//uniform vec3 lightPos;
|
|
||||||
uniform vec3 cameraPos;
|
|
||||||
uniform sampler2D color_texture;
|
|
||||||
|
|
||||||
|
|
||||||
in vec3 interpNormal;
|
|
||||||
in vec3 fragPos;
|
|
||||||
in vec2 uvCoord;
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
//float falloff = pow(length(cameraPos-fragPos),2)*0.01;
|
|
||||||
vec3 color = texture(color_texture,uvCoord).rgb;
|
|
||||||
vec3 spec = vec3(0.7);
|
|
||||||
//vec3 lightDir = normalize(lightPos-fragPos);
|
|
||||||
vec3 V = normalize(cameraPos-fragPos);
|
|
||||||
vec3 normal = normalize(interpNormal);
|
|
||||||
vec3 R = reflect(-normalize(lightDir),normal);
|
|
||||||
|
|
||||||
float specular = pow(max(0,dot(R,V)),10);
|
|
||||||
float diffuse = max(0,dot(normal,normalize(lightDir)));
|
|
||||||
gl_FragColor = vec4(mix(color,color*diffuse+spec*specular,0.7), 1.0);
|
|
||||||
//gl_FragColor = vec4(mix(vec3(0.1,0.1,0.1),mix(color,color*diffuse+spec*specular,0.7),min(1,1/falloff)), 1.0);
|
|
||||||
}
|
|
@ -1,19 +0,0 @@
|
|||||||
#version 410 core
|
|
||||||
|
|
||||||
layout(location = 0) in vec3 vertexPosition;
|
|
||||||
layout(location = 1) in vec3 vertexNormal;
|
|
||||||
layout(location = 2) in vec2 vertexTexCoord;
|
|
||||||
|
|
||||||
uniform mat4 transformation;
|
|
||||||
uniform mat4 modelMatrix;
|
|
||||||
out vec3 interpNormal;
|
|
||||||
out vec3 fragPos;
|
|
||||||
out vec2 uvCoord;
|
|
||||||
|
|
||||||
void main()
|
|
||||||
{
|
|
||||||
uvCoord = vertexTexCoord;
|
|
||||||
gl_Position = transformation * vec4(vertexPosition, 1.0);
|
|
||||||
interpNormal = (modelMatrix*vec4(vertexNormal,0)).xyz;
|
|
||||||
fragPos = (modelMatrix*vec4(vertexPosition,1)).xyz;
|
|
||||||
}
|
|
@ -1,104 +0,0 @@
|
|||||||
|
|
||||||
|
|
||||||
// dane 36 wierzcholkow i kolorow opisujace model pudelka
|
|
||||||
const float boxPositions[] = {
|
|
||||||
0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
0.25f, -0.25f, 0.75f, 1.0f,
|
|
||||||
-0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, -0.25f, 0.75f, 1.0f,
|
|
||||||
-0.25f, -0.25f, 0.75f, 1.0f,
|
|
||||||
-0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, 0.25f, -0.75f, 1.0f,
|
|
||||||
-0.25f, 0.25f, -0.75f, 1.0f,
|
|
||||||
0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
-0.25f, 0.25f, -0.75f, 1.0f,
|
|
||||||
-0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
|
|
||||||
-0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
-0.25f, -0.25f, 0.75f, 1.0f,
|
|
||||||
-0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
|
|
||||||
-0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
-0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
-0.25f, 0.25f, -0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
0.25f, -0.25f, 0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
0.25f, 0.25f, -0.75f, 1.0f,
|
|
||||||
0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, 0.25f, -0.75f, 1.0f,
|
|
||||||
0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
-0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, 0.25f, -0.75f, 1.0f,
|
|
||||||
-0.25f, 0.25f, 0.75f, 1.0f,
|
|
||||||
-0.25f, 0.25f, -0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
-0.25f, -0.25f, 0.75f, 1.0f,
|
|
||||||
0.25f, -0.25f, 0.75f, 1.0f,
|
|
||||||
|
|
||||||
0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
-0.25f, -0.25f, -0.75f, 1.0f,
|
|
||||||
-0.25f, -0.25f, 0.75f, 1.0f,
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
const float boxColors[] = {
|
|
||||||
0.0f, 0.0f, 1.0f, 1.0f,
|
|
||||||
0.0f, 0.0f, 1.0f, 1.0f,
|
|
||||||
0.0f, 0.0f, 1.0f, 1.0f,
|
|
||||||
|
|
||||||
0.0f, 0.0f, 1.0f, 1.0f,
|
|
||||||
0.0f, 0.0f, 1.0f, 1.0f,
|
|
||||||
0.0f, 0.0f, 1.0f, 1.0f,
|
|
||||||
|
|
||||||
0.8f, 0.8f, 0.8f, 1.0f,
|
|
||||||
0.8f, 0.8f, 0.8f, 1.0f,
|
|
||||||
0.8f, 0.8f, 0.8f, 1.0f,
|
|
||||||
|
|
||||||
0.8f, 0.8f, 0.8f, 1.0f,
|
|
||||||
0.8f, 0.8f, 0.8f, 1.0f,
|
|
||||||
0.8f, 0.8f, 0.8f, 1.0f,
|
|
||||||
|
|
||||||
0.0f, 1.0f, 0.0f, 1.0f,
|
|
||||||
0.0f, 1.0f, 0.0f, 1.0f,
|
|
||||||
0.0f, 1.0f, 0.0f, 1.0f,
|
|
||||||
|
|
||||||
0.0f, 1.0f, 0.0f, 1.0f,
|
|
||||||
0.0f, 1.0f, 0.0f, 1.0f,
|
|
||||||
0.0f, 1.0f, 0.0f, 1.0f,
|
|
||||||
|
|
||||||
0.5f, 0.5f, 0.0f, 1.0f,
|
|
||||||
0.5f, 0.5f, 0.0f, 1.0f,
|
|
||||||
0.5f, 0.5f, 0.0f, 1.0f,
|
|
||||||
|
|
||||||
0.5f, 0.5f, 0.0f, 1.0f,
|
|
||||||
0.5f, 0.5f, 0.0f, 1.0f,
|
|
||||||
0.5f, 0.5f, 0.0f, 1.0f,
|
|
||||||
|
|
||||||
1.0f, 0.0f, 0.0f, 1.0f,
|
|
||||||
1.0f, 0.0f, 0.0f, 1.0f,
|
|
||||||
1.0f, 0.0f, 0.0f, 1.0f,
|
|
||||||
|
|
||||||
1.0f, 0.0f, 0.0f, 1.0f,
|
|
||||||
1.0f, 0.0f, 0.0f, 1.0f,
|
|
||||||
1.0f, 0.0f, 0.0f, 1.0f,
|
|
||||||
|
|
||||||
0.0f, 1.0f, 1.0f, 1.0f,
|
|
||||||
0.0f, 1.0f, 1.0f, 1.0f,
|
|
||||||
0.0f, 1.0f, 1.0f, 1.0f,
|
|
||||||
|
|
||||||
0.0f, 1.0f, 1.0f, 1.0f,
|
|
||||||
0.0f, 1.0f, 1.0f, 1.0f,
|
|
||||||
0.0f, 1.0f, 1.0f, 1.0f,
|
|
||||||
|
|
||||||
};
|
|
@ -30,3 +30,11 @@ glm::mat4 Core::createViewMatrix( glm::vec3 position, glm::vec3 forward, glm::ve
|
|||||||
|
|
||||||
return cameraRotation * cameraTranslation;
|
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;
|
||||||
|
}
|
||||||
|
@ -1,6 +1,7 @@
|
|||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include "glm.hpp"
|
#include "glm.hpp"
|
||||||
|
#include "ext.hpp"
|
||||||
|
|
||||||
namespace Core
|
namespace Core
|
||||||
{
|
{
|
||||||
@ -11,4 +12,6 @@ namespace Core
|
|||||||
// up - wektor "w gore" kamery (jednostkowy)
|
// up - wektor "w gore" kamery (jednostkowy)
|
||||||
// up i forward musza byc ortogonalne!
|
// up i forward musza byc ortogonalne!
|
||||||
glm::mat4 createViewMatrix(glm::vec3 position, glm::vec3 forward, glm::vec3 up);
|
glm::mat4 createViewMatrix(glm::vec3 position, glm::vec3 forward, glm::vec3 up);
|
||||||
|
|
||||||
|
glm::mat4 createViewMatrixQuat(glm::vec3 position, glm::quat rotation);
|
||||||
}
|
}
|
@ -1,31 +0,0 @@
|
|||||||
#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()
|
|
||||||
{
|
|
||||||
PX_RELEASE(scene);
|
|
||||||
PX_RELEASE(dispatcher);
|
|
||||||
PX_RELEASE(physics);
|
|
||||||
PX_RELEASE(foundation);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Physics::step(float dt)
|
|
||||||
{
|
|
||||||
scene->simulate(dt);
|
|
||||||
scene->fetchResults(true);
|
|
||||||
}
|
|
@ -1,21 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include "PxPhysicsAPI.h"
|
|
||||||
using namespace physx;
|
|
||||||
|
|
||||||
class Physics
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
Physics(float gravity);
|
|
||||||
virtual ~Physics();
|
|
||||||
PxPhysics* physics = nullptr;
|
|
||||||
PxScene* scene = nullptr;
|
|
||||||
|
|
||||||
void step(float dt);
|
|
||||||
|
|
||||||
private:
|
|
||||||
PxDefaultAllocator allocator;
|
|
||||||
PxDefaultErrorCallback errorCallback;
|
|
||||||
PxFoundation* foundation = nullptr;
|
|
||||||
PxDefaultCpuDispatcher* dispatcher = nullptr;
|
|
||||||
};
|
|
@ -4,8 +4,9 @@
|
|||||||
|
|
||||||
#include "glew.h"
|
#include "glew.h"
|
||||||
#include "freeglut.h"
|
#include "freeglut.h"
|
||||||
|
#include <assimp/Importer.hpp>
|
||||||
|
#include <assimp/scene.h>
|
||||||
|
#include <assimp/postprocess.h>
|
||||||
|
|
||||||
|
|
||||||
void Core::RenderContext::initFromOBJ(obj::Model& model)
|
void Core::RenderContext::initFromOBJ(obj::Model& model)
|
||||||
@ -18,13 +19,8 @@ void Core::RenderContext::initFromOBJ(obj::Model& model)
|
|||||||
unsigned int vertexTexBufferSize = sizeof(float) * model.texCoord.size();
|
unsigned int vertexTexBufferSize = sizeof(float) * model.texCoord.size();
|
||||||
|
|
||||||
size = model.faces["default"].size();
|
size = model.faces["default"].size();
|
||||||
unsigned int vertexElementBufferSize = sizeof(unsigned int) * size;
|
unsigned int vertexElementBufferSize = sizeof(unsigned short) * size;
|
||||||
|
|
||||||
|
|
||||||
std::vector<unsigned int> indices;
|
|
||||||
for (unsigned short index : model.faces["default"]) {
|
|
||||||
indices.push_back(index);
|
|
||||||
}
|
|
||||||
|
|
||||||
glGenVertexArrays(1, &vertexArray);
|
glGenVertexArrays(1, &vertexArray);
|
||||||
glBindVertexArray(vertexArray);
|
glBindVertexArray(vertexArray);
|
||||||
@ -32,7 +28,7 @@ void Core::RenderContext::initFromOBJ(obj::Model& model)
|
|||||||
|
|
||||||
glGenBuffers(1, &vertexIndexBuffer);
|
glGenBuffers(1, &vertexIndexBuffer);
|
||||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexIndexBuffer);
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexIndexBuffer);
|
||||||
glBufferData(GL_ELEMENT_ARRAY_BUFFER, vertexElementBufferSize, &indices[0], GL_STATIC_DRAW);
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, vertexElementBufferSize, &model.faces["default"][0], GL_STATIC_DRAW);
|
||||||
|
|
||||||
glGenBuffers(1, &vertexBuffer);
|
glGenBuffers(1, &vertexBuffer);
|
||||||
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
|
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
|
||||||
@ -40,7 +36,7 @@ void Core::RenderContext::initFromOBJ(obj::Model& model)
|
|||||||
glEnableVertexAttribArray(0);
|
glEnableVertexAttribArray(0);
|
||||||
glEnableVertexAttribArray(1);
|
glEnableVertexAttribArray(1);
|
||||||
glEnableVertexAttribArray(2);
|
glEnableVertexAttribArray(2);
|
||||||
|
|
||||||
glBufferData(GL_ARRAY_BUFFER, vertexDataBufferSize + vertexNormalBufferSize + vertexTexBufferSize, NULL, GL_STATIC_DRAW);
|
glBufferData(GL_ARRAY_BUFFER, vertexDataBufferSize + vertexNormalBufferSize + vertexTexBufferSize, NULL, GL_STATIC_DRAW);
|
||||||
|
|
||||||
glBufferSubData(GL_ARRAY_BUFFER, 0, vertexDataBufferSize, &model.vertex[0]);
|
glBufferSubData(GL_ARRAY_BUFFER, 0, vertexDataBufferSize, &model.vertex[0]);
|
||||||
@ -54,7 +50,8 @@ void Core::RenderContext::initFromOBJ(obj::Model& model)
|
|||||||
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)(vertexNormalBufferSize + vertexDataBufferSize));
|
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)(vertexNormalBufferSize + vertexDataBufferSize));
|
||||||
}
|
}
|
||||||
|
|
||||||
void Core::RenderContext::initFromAssimpMesh(aiMesh* mesh){
|
|
||||||
|
void Core::RenderContext::initFromAssimpMesh(aiMesh* mesh) {
|
||||||
vertexArray = 0;
|
vertexArray = 0;
|
||||||
vertexBuffer = 0;
|
vertexBuffer = 0;
|
||||||
vertexIndexBuffer = 0;
|
vertexIndexBuffer = 0;
|
||||||
@ -64,7 +61,7 @@ void Core::RenderContext::initFromAssimpMesh(aiMesh* mesh){
|
|||||||
//tex coord must be converted to 2d vecs
|
//tex coord must be converted to 2d vecs
|
||||||
for (unsigned int i = 0; i < mesh->mNumVertices; i++)
|
for (unsigned int i = 0; i < mesh->mNumVertices; i++)
|
||||||
{
|
{
|
||||||
if (mesh->mTextureCoords[0]!=nullptr) {
|
if (mesh->mTextureCoords[0] != nullptr) {
|
||||||
textureCoord.push_back(mesh->mTextureCoords[0][i].x);
|
textureCoord.push_back(mesh->mTextureCoords[0][i].x);
|
||||||
textureCoord.push_back(mesh->mTextureCoords[0][i].y);
|
textureCoord.push_back(mesh->mTextureCoords[0][i].y);
|
||||||
}
|
}
|
||||||
@ -130,20 +127,6 @@ void Core::RenderContext::initFromAssimpMesh(aiMesh* mesh){
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Core::RenderContext::render()
|
|
||||||
{
|
|
||||||
|
|
||||||
glBindVertexArray(this->vertexArray);
|
|
||||||
glDrawElements(
|
|
||||||
GL_TRIANGLES, // mode
|
|
||||||
this->size, // count
|
|
||||||
GL_UNSIGNED_INT, // type
|
|
||||||
(void*)0 // element array buffer offset
|
|
||||||
);
|
|
||||||
glBindVertexArray(0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void Core::DrawVertexArray(const float * vertexArray, int numVertices, int elementSize )
|
void Core::DrawVertexArray(const float * vertexArray, int numVertices, int elementSize )
|
||||||
{
|
{
|
||||||
glVertexAttribPointer(0, elementSize, GL_FLOAT, false, 0, vertexArray);
|
glVertexAttribPointer(0, elementSize, GL_FLOAT, false, 0, vertexArray);
|
||||||
@ -172,69 +155,15 @@ void Core::DrawVertexArray( const VertexData & data )
|
|||||||
glDrawArrays(GL_TRIANGLES, 0, data.NumVertices);
|
glDrawArrays(GL_TRIANGLES, 0, data.NumVertices);
|
||||||
}
|
}
|
||||||
|
|
||||||
void Core::DiffuseMaterial::init_data() {
|
void Core::DrawContext(Core::RenderContext& context)
|
||||||
glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
|
|
||||||
Core::SetActiveTexture(texture, "color_texture", program, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Core::DiffuseSpecularMaterial::init_data() {
|
|
||||||
glUniform3f(glGetUniformLocation(program, "lightDir"), lightDir.x, lightDir.y, lightDir.z);
|
|
||||||
Core::SetActiveTexture(texture, "color_texture", program, 0);
|
|
||||||
Core::SetActiveTexture(textureSpecular, "specular_texture", program, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
void Core::RayContext::render()
|
|
||||||
{
|
{
|
||||||
|
|
||||||
glBindVertexArray(vertexArray);
|
glBindVertexArray(context.vertexArray);
|
||||||
glDrawArrays(
|
glDrawElements(
|
||||||
GL_LINES,// mode
|
GL_TRIANGLES, // mode
|
||||||
0, //start
|
context.size, // count
|
||||||
3 * 7 * 2 // count
|
GL_UNSIGNED_INT, // type
|
||||||
);
|
(void*)0 // element array buffer offset
|
||||||
glBindVertexArray(0);
|
);
|
||||||
|
glBindVertexArray(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void Core::initRay(RayContext& rayContext) {
|
|
||||||
rayContext.size = 2;
|
|
||||||
glGenVertexArrays(1, &rayContext.vertexArray);
|
|
||||||
glBindVertexArray(rayContext.vertexArray);
|
|
||||||
|
|
||||||
glGenBuffers(1, &rayContext.vertexBuffer);
|
|
||||||
glBindBuffer(GL_ARRAY_BUFFER, rayContext.vertexBuffer);
|
|
||||||
|
|
||||||
glBufferData(GL_ARRAY_BUFFER, 3 * 7 * 2 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
|
|
||||||
|
|
||||||
glEnableVertexAttribArray(0);
|
|
||||||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)(0));
|
|
||||||
glBindVertexArray(0);
|
|
||||||
}
|
|
||||||
void Core::updateRayPos(RayContext& rayContext,std::vector<glm::vec3> ray) {
|
|
||||||
glBindVertexArray(rayContext.vertexArray);
|
|
||||||
std::vector<glm::vec3> keyPoints;
|
|
||||||
float offset = 4.f;
|
|
||||||
float scale = 0.2f;
|
|
||||||
float rayEnd = 50.f;
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset);
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * rayEnd);
|
|
||||||
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset + scale * glm::vec3(1.f, 1.f, 0.f));
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset - scale * glm::vec3(1.f, 1.f, 0.f));
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset + scale * glm::vec3(1.f, -1.f, 0.f));
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset - scale * glm::vec3(1.f, -1.f, 0.f));
|
|
||||||
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset + scale * glm::vec3(1.f, 1.f, 0.f));
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * rayEnd * scale);
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset - scale * glm::vec3(1.f, 1.f, 0.f));
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * rayEnd * scale);
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset + scale * glm::vec3(1.f, -1.f, 0.f));
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * rayEnd * scale);
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * offset - scale * glm::vec3(1.f, -1.f, 0.f));
|
|
||||||
keyPoints.push_back(ray[0] + ray[1] * rayEnd * scale);
|
|
||||||
glBindBuffer(GL_ARRAY_BUFFER, rayContext.vertexBuffer);
|
|
||||||
glBufferSubData(GL_ARRAY_BUFFER, 0, keyPoints.size()*3 * sizeof(float), &keyPoints[0]);
|
|
||||||
glBindVertexArray(0);
|
|
||||||
}
|
|
@ -1,63 +1,25 @@
|
|||||||
#pragma once
|
#pragma once
|
||||||
#include "glm.hpp"
|
#include "glm.hpp"
|
||||||
#include "ext.hpp"
|
|
||||||
#include "glew.h"
|
#include "glew.h"
|
||||||
#include "objload.h"
|
#include "objload.h"
|
||||||
#include <assimp/Importer.hpp>
|
#include <assimp/Importer.hpp>
|
||||||
#include <assimp/scene.h>
|
#include <assimp/scene.h>
|
||||||
#include <assimp/postprocess.h>
|
#include <assimp/postprocess.h>
|
||||||
#include "Texture.h"
|
|
||||||
|
|
||||||
#define BUFFER_OFFSET(i) ((char *)NULL + (i))
|
#define BUFFER_OFFSET(i) ((char *)NULL + (i))
|
||||||
|
|
||||||
namespace Core
|
namespace Core
|
||||||
{
|
{
|
||||||
static inline glm::mat4 mat4_cast(const aiMatrix4x4& m) { return glm::transpose(glm::make_mat4(&m.a1)); }
|
|
||||||
|
|
||||||
struct Material {
|
|
||||||
GLuint program;
|
|
||||||
virtual void init_data() = 0;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct DiffuseMaterial : Core::Material {
|
|
||||||
GLuint texture;
|
|
||||||
glm::vec3 lightDir;
|
|
||||||
void init_data();
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
struct DiffuseSpecularMaterial : Core::Material {
|
|
||||||
GLuint texture;
|
|
||||||
GLuint textureSpecular;
|
|
||||||
glm::vec3 lightDir;
|
|
||||||
void init_data();
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
struct RenderContext
|
struct RenderContext
|
||||||
{
|
{
|
||||||
|
|
||||||
GLuint vertexArray;
|
GLuint vertexArray;
|
||||||
GLuint vertexBuffer;
|
GLuint vertexBuffer;
|
||||||
GLuint vertexIndexBuffer;
|
GLuint vertexIndexBuffer;
|
||||||
Material* material;
|
|
||||||
int size = 0;
|
int size = 0;
|
||||||
|
|
||||||
void initFromOBJ(obj::Model& model);
|
void initFromOBJ(obj::Model& model);
|
||||||
|
|
||||||
void initFromAssimpMesh(aiMesh* mesh);
|
void initFromAssimpMesh(aiMesh* mesh);
|
||||||
|
|
||||||
void render();
|
|
||||||
};
|
|
||||||
struct RayContext : RenderContext {
|
|
||||||
|
|
||||||
void render();
|
|
||||||
};
|
|
||||||
|
|
||||||
struct Node {
|
|
||||||
std::vector<RenderContext> renderContexts;
|
|
||||||
glm::mat4 matrix;
|
|
||||||
int parent;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
// vertexArray - jednowymiarowa tablica zawierajaca wartosci opisujace pozycje kolejnych wierzcholkow w jednym ciagu (x1, y1, z1, w1, x2, y2, z2, w2, ...)
|
// vertexArray - jednowymiarowa tablica zawierajaca wartosci opisujace pozycje kolejnych wierzcholkow w jednym ciagu (x1, y1, z1, w1, x2, y2, z2, w2, ...)
|
||||||
@ -106,12 +68,5 @@ namespace Core
|
|||||||
*/
|
*/
|
||||||
void DrawVertexArray(const VertexData & data);
|
void DrawVertexArray(const VertexData & data);
|
||||||
|
|
||||||
|
void DrawContext(RenderContext& context);
|
||||||
|
|
||||||
void initRay(RayContext& rayContext);
|
|
||||||
|
|
||||||
void updateRayPos(RayContext& rayContext, std::vector<glm::vec3> keyPoints);
|
|
||||||
|
|
||||||
//void DrawContext(Core::RayContext& rayContext);
|
|
||||||
|
|
||||||
}
|
}
|
2024
GrafikaProjekt/pliki/src/SOIL/SOIL.c
Normal file
433
GrafikaProjekt/pliki/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
GrafikaProjekt/pliki/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
GrafikaProjekt/pliki/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
GrafikaProjekt/pliki/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
GrafikaProjekt/pliki/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
GrafikaProjekt/pliki/src/SOIL/stb_image_aug.c
Normal file
354
GrafikaProjekt/pliki/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
GrafikaProjekt/pliki/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
GrafikaProjekt/pliki/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);
|
||||||
|
}
|
@ -1,52 +1,31 @@
|
|||||||
#include "Texture.h"
|
#include "Texture.h"
|
||||||
|
|
||||||
#include <fstream>
|
#include <fstream>
|
||||||
#include <iterator>
|
#include <iterator>
|
||||||
#include <vector>
|
#include <vector>
|
||||||
#include "picopng.h"
|
#include "SOIL/SOIL.h"
|
||||||
#include "stb_image.h"
|
|
||||||
|
|
||||||
typedef unsigned char byte;
|
typedef unsigned char byte;
|
||||||
|
|
||||||
|
GLuint Core::LoadTexture( const char * filepath )
|
||||||
GLuint Core::LoadTexture(const char* filename)
|
|
||||||
{
|
{
|
||||||
//std::string path = std::string(filename);
|
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);
|
||||||
|
|
||||||
unsigned int textureID;
|
int w, h;
|
||||||
glGenTextures(1, &textureID);
|
unsigned char* image = SOIL_load_image(filepath, &w, &h, 0, SOIL_LOAD_RGBA);
|
||||||
|
|
||||||
|
|
||||||
int width, height, nrComponents;
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
|
||||||
stbi_set_flip_vertically_on_load(true);
|
glGenerateMipmap(GL_TEXTURE_2D);
|
||||||
unsigned char* data = stbi_load(filename, &width, &height, &nrComponents, 0);
|
SOIL_free_image_data(image);
|
||||||
if (data)
|
|
||||||
{
|
|
||||||
GLenum format;
|
|
||||||
if (nrComponents == 1)
|
|
||||||
format = GL_RED;
|
|
||||||
else if (nrComponents == 3)
|
|
||||||
format = GL_RGB;
|
|
||||||
else if (nrComponents == 4)
|
|
||||||
format = GL_RGBA;
|
|
||||||
|
|
||||||
glBindTexture(GL_TEXTURE_2D, textureID);
|
return id;
|
||||||
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
|
|
||||||
glGenerateMipmap(GL_TEXTURE_2D);
|
|
||||||
|
|
||||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
||||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
||||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
||||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
||||||
|
|
||||||
stbi_image_free(data);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
std::cout << "Texture failed to load at path: " << filename << std::endl;
|
|
||||||
stbi_image_free(data);
|
|
||||||
}
|
|
||||||
|
|
||||||
return textureID;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Core::SetActiveTexture(GLuint textureID, const char * shaderVariableName, GLuint programID, int textureUnit)
|
void Core::SetActiveTexture(GLuint textureID, const char * shaderVariableName, GLuint programID, int textureUnit)
|
||||||
|
@ -1,9 +1,7 @@
|
|||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include "glew.h"
|
#include "glew.h"
|
||||||
#include "freeglut.h"
|
#include "freeglut.h"
|
||||||
#include <string>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
namespace Core
|
namespace Core
|
||||||
{
|
{
|
||||||
|
@ -1,100 +1,45 @@
|
|||||||
#define STB_IMAGE_IMPLEMENTATION
|
|
||||||
|
|
||||||
#include "glew.h"
|
#include "glew.h"
|
||||||
#include "freeglut.h"
|
#include "freeglut.h"
|
||||||
#include "glm.hpp"
|
#include "glm.hpp"
|
||||||
#include "gtx/matrix_decompose.hpp"
|
|
||||||
#include "ext.hpp"
|
#include "ext.hpp"
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
#include <cmath>
|
#include <cmath>
|
||||||
#include <ctime>
|
#include <vector>
|
||||||
|
|
||||||
#include "Shader_Loader.h"
|
#include "Shader_Loader.h"
|
||||||
#include "Render_Utils.h"
|
#include "Render_Utils.h"
|
||||||
#include "Camera.h"
|
#include "Camera.h"
|
||||||
|
|
||||||
|
|
||||||
#include "Box.cpp"
|
|
||||||
#include <assimp/Importer.hpp>
|
|
||||||
#include <assimp/scene.h>
|
|
||||||
#include <assimp/postprocess.h>
|
|
||||||
//#include <assimp/pbrmaterial.h>
|
|
||||||
|
|
||||||
#include "stb_image.h"
|
|
||||||
#include "Texture.h"
|
#include "Texture.h"
|
||||||
|
|
||||||
//obliczyc kwateriony nastepnie interpolowac.
|
GLuint programColor;
|
||||||
|
|
||||||
|
|
||||||
std::vector<glm::vec3> keyPoints({
|
|
||||||
glm::vec3(-711.745f, 89.9272f, -626.537f),
|
|
||||||
//glm::vec3(-711.745f, 91.9272f, -606.537f),
|
|
||||||
glm::vec3(-687.635f, 100.428f, -503.943f),
|
|
||||||
//glm::vec3(-721.365f, 103.613f, -598.223f),
|
|
||||||
glm::vec3(-667.635f, 128.428f, -433.943f),
|
|
||||||
glm::vec3(-547.654f, 180.445f, -401.846f),
|
|
||||||
glm::vec3(-365.357f, 261.268f, -304.93f),
|
|
||||||
glm::vec3(-346.51f, 146.605f, -85.3702f),
|
|
||||||
glm::vec3(-461.105f, 120.275f, 115.596f),
|
|
||||||
glm::vec3(-507.395f, 76.497f, 338.408f),
|
|
||||||
glm::vec3(-181.343f, 58.7994f, 403.918f),
|
|
||||||
glm::vec3(-148.073f, 72.7797f, 522.283f),
|
|
||||||
glm::vec3(-76.8437f, 85.1488f, 524.396f),
|
|
||||||
glm::vec3(-30.0008f, 81.3007f, 367.907f),
|
|
||||||
glm::vec3(20.808f, 117.73f, 109.607f),
|
|
||||||
glm::vec3(8.72873f, 135.983f, -130.435f),
|
|
||||||
glm::vec3(8.72873f, 115.983f, -132.435f),
|
|
||||||
glm::vec3(8.72873f, 104.983f, -132.435f),
|
|
||||||
glm::vec3(8.72873f, 100.983f, -132.435f),
|
|
||||||
});
|
|
||||||
|
|
||||||
std::vector<glm::quat> keyRotation;
|
|
||||||
|
|
||||||
int index = 0;
|
|
||||||
bool FOLLOW_CAR = false;
|
|
||||||
|
|
||||||
GLuint program;
|
|
||||||
GLuint programTextureSpecular;
|
|
||||||
GLuint programTexture;
|
GLuint programTexture;
|
||||||
GLuint programSun;
|
|
||||||
Core::Shader_Loader shaderLoader;
|
Core::Shader_Loader shaderLoader;
|
||||||
|
|
||||||
|
Core::RenderContext shipContext;
|
||||||
|
Core::RenderContext sphereContext;
|
||||||
|
|
||||||
|
glm::vec3 cameraPos = glm::vec3(0, 0, 5);
|
||||||
Core::RenderContext armContext;
|
glm::vec3 cameraDir; // Wektor "do przodu" kamery
|
||||||
|
glm::vec3 cameraSide; // Wektor "w bok" kamery
|
||||||
|
|
||||||
std::vector<Core::RenderContext> armContexts;
|
|
||||||
|
|
||||||
std::vector<Core::Node> city;
|
|
||||||
|
|
||||||
std::vector<Core::Node> car;
|
|
||||||
|
|
||||||
|
|
||||||
float cameraAngle = 0;
|
float cameraAngle = 0;
|
||||||
glm::vec3 cameraSide;
|
|
||||||
glm::vec3 cameraDir;
|
int lastMouseX, lastMouseY, mouseX, mouseY;
|
||||||
glm::vec3 cameraPos = keyPoints[0] + glm::vec3(0, 10, -5);
|
|
||||||
|
|
||||||
glm::mat4 cameraMatrix, perspectiveMatrix;
|
glm::mat4 cameraMatrix, perspectiveMatrix;
|
||||||
|
|
||||||
|
glm::vec3 lightDir = glm::normalize(glm::vec3(1.0f, -0.9f, -1.0f));
|
||||||
|
|
||||||
|
glm::quat rotation = glm::quat(1, 0, 0, 0);
|
||||||
|
|
||||||
float old_x, old_y = -1;
|
GLuint textureAsteroid;
|
||||||
float delta_x, delta_y = 0;
|
|
||||||
glm::quat rotationCamera = glm::quat(1, 0, 0, 0);
|
|
||||||
//glm::quat rotation_y;
|
|
||||||
//glm::quat rotation_x;// = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 1, 0));
|
|
||||||
glm::quat rotation_y = glm::normalize(glm::angleAxis(209 * 0.03f, glm::vec3(1, 0, 0)));
|
|
||||||
glm::quat rotation_x = glm::normalize(glm::angleAxis(307 * 0.03f, glm::vec3(0, 1, 0)));
|
|
||||||
float dy = 0;
|
|
||||||
float dx = 0;
|
|
||||||
|
|
||||||
void keyboard(unsigned char key, int x, int y)
|
void keyboard(unsigned char key, int x, int y)
|
||||||
{
|
{
|
||||||
float angleSpeed = 0.5f;
|
|
||||||
float moveSpeed = 2.f;
|
float angleSpeed = 0.1f;
|
||||||
switch (key)
|
float moveSpeed = 0.1f;
|
||||||
|
switch(key)
|
||||||
{
|
{
|
||||||
case 'z': cameraAngle -= angleSpeed; break;
|
case 'z': cameraAngle -= angleSpeed; break;
|
||||||
case 'x': cameraAngle += angleSpeed; break;
|
case 'x': cameraAngle += angleSpeed; break;
|
||||||
@ -102,306 +47,107 @@ void keyboard(unsigned char key, int x, int y)
|
|||||||
case 's': cameraPos -= cameraDir * moveSpeed; break;
|
case 's': cameraPos -= cameraDir * moveSpeed; break;
|
||||||
case 'd': cameraPos += cameraSide * moveSpeed; break;
|
case 'd': cameraPos += cameraSide * moveSpeed; break;
|
||||||
case 'a': cameraPos -= cameraSide * moveSpeed; break;
|
case 'a': cameraPos -= cameraSide * moveSpeed; break;
|
||||||
case '0': cameraPos = keyPoints[0] + glm::vec3(0, 3, 0); index = 0; break;
|
|
||||||
case 'e': index = (index + 1) % keyPoints.size(); cameraPos = keyPoints[index] + glm::vec3(-3, 20, -3); break;
|
|
||||||
case 'q': index = (keyPoints.size() + index - 1) % keyPoints.size(); cameraPos = keyPoints[index] + glm::vec3(-3, 20, -3); break;
|
|
||||||
case '1': FOLLOW_CAR = !FOLLOW_CAR; break;
|
|
||||||
case 'r': cameraPos = glm::vec3(0,0,1); break;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
glm::vec3 lightDir = glm::normalize(glm::vec3(1, 1, 1));
|
|
||||||
|
|
||||||
|
|
||||||
void mouse(int x, int y)
|
void mouse(int x, int y)
|
||||||
{
|
{
|
||||||
if (old_x >= 0) {
|
mouseX = lastMouseX - x;
|
||||||
delta_x = x - old_x;
|
mouseY = lastMouseY - y;
|
||||||
delta_y = y - old_y;
|
lastMouseX = x;
|
||||||
}
|
lastMouseY = y;
|
||||||
old_x = x;
|
|
||||||
old_y = y;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
glm::mat4 createCameraMatrix()
|
glm::mat4 createCameraMatrix()
|
||||||
{
|
{
|
||||||
auto rot_y = glm::angleAxis(delta_y * 0.03f, glm::vec3(1, 0, 0));
|
rotation = glm::normalize(rotation * glm::angleAxis((float)(mouseX * 0.01), cameraDir) * glm::angleAxis((float)(mouseY * 0.01), cameraSide));
|
||||||
auto rot_x = glm::angleAxis(delta_x * 0.03f, glm::vec3(0, 1, 0));
|
mouseX = mouseY = 0;
|
||||||
|
cameraDir = glm::inverse(rotation) * glm::vec3(0, 0, -1);
|
||||||
dy += delta_y;
|
cameraSide = glm::inverse(rotation) * glm::vec3(-1, 0, 0);
|
||||||
dx += delta_x;
|
return Core::createViewMatrixQuat(cameraPos, rotation);
|
||||||
delta_x = 0;
|
|
||||||
delta_y = 0;
|
|
||||||
|
|
||||||
rotation_x = glm::normalize(rot_x * rotation_x);
|
|
||||||
rotation_y = glm::normalize(rot_y * rotation_y);
|
|
||||||
|
|
||||||
rotationCamera = glm::normalize(rotation_y * rotation_x);
|
|
||||||
|
|
||||||
auto inverse_rot = glm::inverse(rotationCamera);
|
|
||||||
|
|
||||||
cameraDir = inverse_rot * glm::vec3(0, 0, -1);
|
|
||||||
glm::vec3 up = glm::vec3(0, 1, 0);
|
|
||||||
cameraSide = inverse_rot * glm::vec3(1, 0, 0);
|
|
||||||
|
|
||||||
glm::mat4 cameraTranslation;
|
|
||||||
cameraTranslation[3] = glm::vec4(-cameraPos, 1.0f);
|
|
||||||
|
|
||||||
return glm::mat4_cast(rotationCamera) * cameraTranslation;
|
|
||||||
}
|
|
||||||
glm::mat4 animationMatrix(float time) {
|
|
||||||
float speed = 1.;
|
|
||||||
time = time * speed;
|
|
||||||
std::vector<float> distances;
|
|
||||||
float timeStep = 0;
|
|
||||||
for (int i = 0; i < keyPoints.size() - 1; i++) {
|
|
||||||
timeStep += (keyPoints[i] - keyPoints[i + 1]).length();
|
|
||||||
distances.push_back((keyPoints[i] - keyPoints[i + 1]).length());
|
|
||||||
}
|
|
||||||
time = fmod(time, timeStep);
|
|
||||||
|
|
||||||
//index of first keyPoint
|
|
||||||
int index = 0;
|
|
||||||
|
|
||||||
while (distances[index] <= time) {
|
|
||||||
time = time - distances[index];
|
|
||||||
index += 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
//t coefitient between 0 and 1 for interpolation
|
|
||||||
float t = time / distances[index];
|
|
||||||
|
|
||||||
int size = keyPoints.size()-1;
|
|
||||||
//replace with catmul rom
|
|
||||||
glm::vec3 pos = (keyPoints[std::max(0, index)] * t + keyPoints[std::min(size, index + 1)] * (1 - t));
|
|
||||||
|
|
||||||
|
|
||||||
//implement corect animation
|
|
||||||
auto animationRotation = glm::quat(1,0,0,0);
|
|
||||||
|
|
||||||
glm::mat4 result = glm::translate(pos) * glm::mat4_cast(animationRotation);
|
|
||||||
|
|
||||||
|
|
||||||
return result;
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void drawObjectColor(Core::RenderContext context, glm::mat4 modelMatrix, glm::vec3 color)
|
||||||
void drawObject(GLuint program, Core::RenderContext context, glm::mat4 modelMatrix)
|
|
||||||
{
|
{
|
||||||
|
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;
|
glm::mat4 transformation = perspectiveMatrix * cameraMatrix * modelMatrix;
|
||||||
|
glUniformMatrix4fv(glGetUniformLocation(program, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
|
||||||
|
|
||||||
glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
|
glUniformMatrix4fv(glGetUniformLocation(program, "modelMatrix"), 1, GL_FALSE, (float*)&modelMatrix);
|
||||||
glUniformMatrix4fv(glGetUniformLocation(program, "transformation"), 1, GL_FALSE, (float*)&transformation);
|
|
||||||
context.render();
|
Core::DrawContext(context);
|
||||||
|
|
||||||
|
glUseProgram(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
void renderRecursive(std::vector<Core::Node>& nodes) {
|
void drawObjectTexture(Core::RenderContext context, glm::mat4 modelMatrix, GLuint textureId)
|
||||||
for (auto node : nodes) {
|
{
|
||||||
if (node.renderContexts.size() == 0) {
|
GLuint program = programTexture;
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
glm::mat4 transformation = node.matrix;//glm::mat4();
|
glUseProgram(program);
|
||||||
auto currentNode = node;
|
|
||||||
while (currentNode.parent != -1) {
|
|
||||||
transformation *= currentNode.matrix;
|
|
||||||
currentNode = nodes[currentNode.parent];
|
|
||||||
}
|
|
||||||
// dodaj odwolania do nadrzednych zmiennych
|
|
||||||
for (auto context : node.renderContexts) {
|
|
||||||
auto program = context.material->program;
|
|
||||||
glUseProgram(program);
|
|
||||||
glUniform3f(glGetUniformLocation(program, "cameraPos"), cameraPos.x, cameraPos.y, cameraPos.z);
|
|
||||||
context.material->init_data();
|
|
||||||
drawObject(program, context, transformation);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
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);
|
||||||
}
|
}
|
||||||
|
|
||||||
glm::mat4 followCarCamera(float time) {
|
|
||||||
glm::quat rotation_y = glm::normalize(glm::angleAxis(209 * 0.03f, glm::vec3(1, 0, 0)));
|
|
||||||
glm::quat rotation_x = glm::normalize(glm::angleAxis(3.14f, glm::vec3(0, 1, 0)));
|
|
||||||
auto pos = glm::vec3(2, 3, 8);
|
|
||||||
cameraPos = animationMatrix(time) * glm::vec4(pos, 1);
|
|
||||||
auto transformation = animationMatrix(time);
|
|
||||||
glm::vec3 scale;
|
|
||||||
glm::quat rrotation;
|
|
||||||
glm::vec3 translation;
|
|
||||||
glm::vec3 skew;
|
|
||||||
glm::vec4 perspective;
|
|
||||||
glm::decompose(transformation, scale, rrotation, translation, skew, perspective);
|
|
||||||
|
|
||||||
return glm::translate(-pos) * glm::mat4_cast(rotation_y * rotation_x) * glm::inverse(transformation);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void renderScene()
|
void renderScene()
|
||||||
{
|
{
|
||||||
// Aktualizacja macierzy widoku i rzutowania. Macierze sa przechowywane w zmiennych globalnych, bo uzywa ich funkcja drawObject.
|
// Aktualizacja macierzy widoku i rzutowania
|
||||||
// (Bardziej elegancko byloby przekazac je jako argumenty do funkcji, ale robimy tak dla uproszczenia kodu.
|
|
||||||
// Jest to mozliwe dzieki temu, ze macierze widoku i rzutowania sa takie same dla wszystkich obiektow!)
|
|
||||||
cameraMatrix = createCameraMatrix();
|
cameraMatrix = createCameraMatrix();
|
||||||
perspectiveMatrix = Core::createPerspectiveMatrix(0.1, 2000);
|
perspectiveMatrix = Core::createPerspectiveMatrix();
|
||||||
float time = glutGet(GLUT_ELAPSED_TIME) / 1000.f;
|
|
||||||
|
|
||||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||||
glClearColor(0.0f, 0.03f, 0.1f, 1.0f);
|
glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
|
||||||
|
|
||||||
|
glm::mat4 shipInitialTransformation = glm::translate(glm::vec3(0,-0.25f,0)) * glm::rotate(glm::radians(180.0f), glm::vec3(0,1,0)) * glm::scale(glm::vec3(0.25f));
|
||||||
|
glm::mat4 shipModelMatrix = glm::translate(cameraPos + cameraDir * 0.5f) * glm::mat4_cast(glm::inverse(rotation)) * shipInitialTransformation;
|
||||||
|
drawObjectColor(shipContext, shipModelMatrix, glm::vec3(0.6f));
|
||||||
|
|
||||||
|
drawObjectTexture(sphereContext, glm::translate(glm::vec3(0,0,0)), textureAsteroid);
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
if (FOLLOW_CAR) {
|
|
||||||
cameraMatrix = followCarCamera(time);
|
|
||||||
}
|
|
||||||
|
|
||||||
renderRecursive(city);
|
|
||||||
for (int i = 0; i < 30; i++) {
|
|
||||||
if (time > -10) {
|
|
||||||
car[0].matrix = animationMatrix(time + 15);;
|
|
||||||
renderRecursive(car);
|
|
||||||
time -= 3;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
glUseProgram(0);
|
|
||||||
glutSwapBuffers();
|
glutSwapBuffers();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void loadModelToContext(std::string path, Core::RenderContext& context)
|
||||||
|
{
|
||||||
|
Assimp::Importer import;
|
||||||
|
const aiScene* scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_CalcTangentSpace);
|
||||||
|
|
||||||
|
if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
|
||||||
|
|
||||||
Core::Material* loadDiffuseMaterial(aiMaterial* material) {
|
|
||||||
aiString colorPath;
|
|
||||||
// use for loading textures
|
|
||||||
|
|
||||||
material->Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0), colorPath);
|
|
||||||
if (colorPath == aiString("")) {
|
|
||||||
return nullptr;
|
|
||||||
}
|
|
||||||
Core::DiffuseMaterial* result = new Core::DiffuseMaterial();
|
|
||||||
result->texture = Core::LoadTexture(colorPath.C_Str());
|
|
||||||
result->program = programTexture;
|
|
||||||
result->lightDir = lightDir;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
Core::Material* loadDiffuseSpecularMaterial(aiMaterial* material) {
|
|
||||||
aiString colorPath;
|
|
||||||
// use for loading textures
|
|
||||||
|
|
||||||
material->Get(AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0), colorPath);
|
|
||||||
Core::DiffuseSpecularMaterial* result = new Core::DiffuseSpecularMaterial();
|
|
||||||
result->texture = Core::LoadTexture(colorPath.C_Str());
|
|
||||||
|
|
||||||
|
|
||||||
aiString specularPath;
|
|
||||||
material->Get(AI_MATKEY_TEXTURE(aiTextureType_SPECULAR, 0), specularPath);
|
|
||||||
result->textureSpecular = Core::LoadTexture(specularPath.C_Str());
|
|
||||||
result->lightDir = lightDir;
|
|
||||||
result->program = programTextureSpecular;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void loadRecusive(const aiScene* scene, aiNode* node, std::vector<Core::Node>& nodes, std::vector<Core::Material*> materialsVector, int parentIndex) {
|
|
||||||
int index = nodes.size();
|
|
||||||
nodes.push_back(Core::Node());
|
|
||||||
nodes[index].parent = parentIndex;
|
|
||||||
nodes[index].matrix = Core::mat4_cast(node->mTransformation);
|
|
||||||
for (int i = 0; i < node->mNumMeshes; i++) {
|
|
||||||
Core::RenderContext context;
|
|
||||||
context.initFromAssimpMesh(scene->mMeshes[node->mMeshes[i]]);
|
|
||||||
context.material = materialsVector[scene->mMeshes[node->mMeshes[i]]->mMaterialIndex];
|
|
||||||
nodes[index].renderContexts.push_back(context);
|
|
||||||
}
|
|
||||||
for (int i = 0; i < node->mNumChildren; i++) {
|
|
||||||
loadRecusive(scene, node->mChildren[i], nodes, materialsVector, index);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
void loadRecusive(const aiScene* scene, std::vector<Core::Node>& nodes, std::vector<Core::Material*> materialsVector) {
|
|
||||||
|
|
||||||
loadRecusive(scene, scene->mRootNode, nodes, materialsVector, -1);
|
|
||||||
}
|
|
||||||
|
|
||||||
void initModels() {
|
|
||||||
Assimp::Importer importer;
|
|
||||||
//replace to get more buildings, unrecomdnded
|
|
||||||
//const aiScene* scene = importer.ReadFile("models/blade-runner-style-cityscapes.fbx", aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
|
|
||||||
const aiScene* scene = importer.ReadFile("models/city_small.fbx", aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
|
|
||||||
// check for errors
|
|
||||||
if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero
|
|
||||||
{
|
{
|
||||||
std::cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << std::endl;
|
std::cout << "ERROR::ASSIMP::" << import.GetErrorString() << std::endl;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
context.initFromAssimpMesh(scene->mMeshes[0]);
|
||||||
|
|
||||||
|
|
||||||
std::vector<Core::Material*> materialsVector;
|
|
||||||
|
|
||||||
for (int i = 0; i < scene->mNumMaterials; i++) {
|
|
||||||
materialsVector.push_back(loadDiffuseSpecularMaterial(scene->mMaterials[i]));
|
|
||||||
}
|
|
||||||
loadRecusive(scene, city, materialsVector);
|
|
||||||
|
|
||||||
|
|
||||||
scene = importer.ReadFile("models/flying_car.fbx", aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
|
|
||||||
|
|
||||||
|
|
||||||
// check for errors
|
|
||||||
if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero
|
|
||||||
{
|
|
||||||
std::cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << std::endl;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
materialsVector.clear();
|
|
||||||
|
|
||||||
for (int i = 0; i < scene->mNumMaterials; i++) {
|
|
||||||
materialsVector.push_back(loadDiffuseMaterial(scene->mMaterials[i]));
|
|
||||||
}
|
|
||||||
loadRecusive(scene, car, materialsVector);
|
|
||||||
|
|
||||||
|
|
||||||
//Recovering points from fbx
|
|
||||||
//const aiScene* points = importer.ReadFile("models/path.fbx", aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
|
|
||||||
|
|
||||||
//auto root = points->mRootNode;
|
|
||||||
|
|
||||||
//for (int i = 0; i < root->mNumChildren; i++) {
|
|
||||||
// auto node = root->mChildren[i];
|
|
||||||
// std::cout << "glm::vec3(" << node->mTransformation.a4 << "f, " << node->mTransformation.b4 << "f, " << node->mTransformation.c4 << "f), " << std::endl;
|
|
||||||
// //std::cout << node->mName.C_Str() << std::endl;
|
|
||||||
//}
|
|
||||||
}
|
|
||||||
|
|
||||||
void initKeyRoation() {
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void init()
|
void init()
|
||||||
{
|
{
|
||||||
|
srand(time(0));
|
||||||
glEnable(GL_DEPTH_TEST);
|
glEnable(GL_DEPTH_TEST);
|
||||||
program = shaderLoader.CreateProgram("shaders/shader_4_1.vert", "shaders/shader_4_1.frag");
|
programColor = shaderLoader.CreateProgram("shaders/shader_color.vert", "shaders/shader_color.frag");
|
||||||
programTextureSpecular = shaderLoader.CreateProgram("shaders/shader_spec_tex.vert", "shaders/shader_spec_tex.frag");
|
programTexture = shaderLoader.CreateProgram("shaders/shader_tex.vert", "shaders/shader_tex.frag");
|
||||||
programTexture = shaderLoader.CreateProgram("shaders/shader_tex_2.vert", "shaders/shader_tex_2.frag");
|
loadModelToContext("models/spaceship.obj", shipContext);
|
||||||
programSun = shaderLoader.CreateProgram("shaders/shader_4_sun.vert", "shaders/shader_4_sun.frag");
|
loadModelToContext("models/sphere.obj", sphereContext);
|
||||||
|
textureAsteroid = Core::LoadTexture("textures/asteroid.png");
|
||||||
initModels();
|
|
||||||
|
|
||||||
initKeyRoation();
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void shutdown()
|
void shutdown()
|
||||||
{
|
{
|
||||||
shaderLoader.DeleteProgram(program);
|
shaderLoader.DeleteProgram(programColor);
|
||||||
|
shaderLoader.DeleteProgram(programTexture);
|
||||||
}
|
}
|
||||||
|
|
||||||
void idle()
|
void idle()
|
||||||
@ -409,19 +155,18 @@ void idle()
|
|||||||
glutPostRedisplay();
|
glutPostRedisplay();
|
||||||
}
|
}
|
||||||
|
|
||||||
int main(int argc, char** argv)
|
int main(int argc, char ** argv)
|
||||||
{
|
{
|
||||||
glutInit(&argc, argv);
|
glutInit(&argc, argv);
|
||||||
glutSetOption(GLUT_MULTISAMPLE, 4);
|
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
|
||||||
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA | GLUT_MULTISAMPLE);
|
glutInitWindowPosition(200, 200);
|
||||||
glutInitWindowPosition(200, 300);
|
glutInitWindowSize(600, 600);
|
||||||
glutInitWindowSize(800, 800);
|
|
||||||
glutCreateWindow("OpenGL Pierwszy Program");
|
glutCreateWindow("OpenGL Pierwszy Program");
|
||||||
glewInit();
|
glewInit();
|
||||||
|
|
||||||
init();
|
init();
|
||||||
glutPassiveMotionFunc(mouse);
|
|
||||||
glutKeyboardFunc(keyboard);
|
glutKeyboardFunc(keyboard);
|
||||||
|
glutPassiveMotionFunc(mouse);
|
||||||
glutDisplayFunc(renderScene);
|
glutDisplayFunc(renderScene);
|
||||||
glutIdleFunc(idle);
|
glutIdleFunc(idle);
|
||||||
|
|
||||||
|
@ -1,399 +0,0 @@
|
|||||||
#define STB_IMAGE_IMPLEMENTATION
|
|
||||||
#define GLM_FORCE_SWIZZLE
|
|
||||||
#define SHOW_RAY
|
|
||||||
#include "stb_image.h"
|
|
||||||
|
|
||||||
|
|
||||||
#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"
|
|
||||||
|
|
||||||
|
|
||||||
bool DRAGING_ON = false;
|
|
||||||
|
|
||||||
Core::Shader_Loader shaderLoader;
|
|
||||||
GLuint programColor;
|
|
||||||
GLuint programTexture, programRed;
|
|
||||||
|
|
||||||
obj::Model planeModel, boxModel, sphereModel;
|
|
||||||
Core::RenderContext planeContext, boxContext, sphereContext;
|
|
||||||
Core::RayContext rayContext;
|
|
||||||
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;
|
|
||||||
|
|
||||||
struct GrabbedObject {
|
|
||||||
PxRigidDynamic* actor;
|
|
||||||
float distance;
|
|
||||||
PxVec3 newPos;
|
|
||||||
bool update = false;
|
|
||||||
} grabbedObject;
|
|
||||||
|
|
||||||
// renderable objects (description of a single renderable instance)
|
|
||||||
struct Renderable {
|
|
||||||
Core::RenderContext *context;
|
|
||||||
glm::mat4 modelMatrix;
|
|
||||||
GLuint textureId;
|
|
||||||
};
|
|
||||||
std::vector<Renderable*> renderables;
|
|
||||||
|
|
||||||
PxVec3 vec3ToPxVec(glm::vec3 vector) {
|
|
||||||
return PxVec3(vector.x, vector.y, vector.z);
|
|
||||||
}
|
|
||||||
glm::vec3 PxVecTovec3(PxVec3 vector) {
|
|
||||||
return glm::vec3(vector.x, vector.y, vector.z);
|
|
||||||
}
|
|
||||||
|
|
||||||
// number of rows and columns of boxes the wall consists of
|
|
||||||
const int BOX_NUMBER = 10;
|
|
||||||
|
|
||||||
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");
|
|
||||||
|
|
||||||
// create ground
|
|
||||||
Renderable *ground = new Renderable();
|
|
||||||
ground->context = &planeContext;
|
|
||||||
ground->textureId = groundTexture;
|
|
||||||
renderables.emplace_back(ground);
|
|
||||||
|
|
||||||
for (int i = 0; i < BOX_NUMBER; i++){
|
|
||||||
// create box
|
|
||||||
Renderable* box = new Renderable();
|
|
||||||
box->context = &boxContext;
|
|
||||||
box->textureId = boxTexture;
|
|
||||||
renderables.emplace_back(box);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void initPhysicsScene()
|
|
||||||
{
|
|
||||||
//-----------------------------------------------------------
|
|
||||||
// TASKS
|
|
||||||
//-----------------------------------------------------------
|
|
||||||
// IMPORTANT:
|
|
||||||
// * to create objects use: pxScene.physics
|
|
||||||
// * to manage the scene use: pxScene.scene
|
|
||||||
|
|
||||||
planeBody = pxScene.physics->createRigidStatic(PxTransformFromPlaneEquation(PxPlane(0, 1, 0, 0)));
|
|
||||||
planeMaterial = pxScene.physics->createMaterial(0.5, 0.3, 0.5);
|
|
||||||
PxShape* planeShape = pxScene.physics->createShape(PxPlaneGeometry(), *planeMaterial);
|
|
||||||
planeBody->attachShape(*planeShape);
|
|
||||||
planeShape->release();
|
|
||||||
planeBody->userData = (void*)renderables[0];
|
|
||||||
pxScene.scene->addActor(*planeBody);
|
|
||||||
boxMaterial = pxScene.physics->createMaterial(0.9, 0.5, 0.4);
|
|
||||||
|
|
||||||
for (int i = 0; i < BOX_NUMBER; i++) {
|
|
||||||
auto pos = glm::linearRand(glm::vec2(-8.f, -8.f), glm::vec2(8.f, 8.f));
|
|
||||||
auto x = pxScene.physics->createRigidDynamic(PxTransform(pos.x,3, pos.y));
|
|
||||||
boxBodies.push_back(x);
|
|
||||||
PxShape* boxShape = pxScene.physics->createShape(PxBoxGeometry(1, 1, 1), *boxMaterial);
|
|
||||||
x->attachShape(*boxShape);
|
|
||||||
boxShape->release();
|
|
||||||
x->userData = (void*)renderables[i + 1];
|
|
||||||
pxScene.scene->addActor(*x);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
std::vector<glm::vec3> calculate_ray(float x, float y) {
|
|
||||||
glm::vec2 screen_space_pos(x, y);
|
|
||||||
std::vector<glm::vec3> result;
|
|
||||||
|
|
||||||
//here ray should be calculated
|
|
||||||
|
|
||||||
result.push_back(cameraPos);
|
|
||||||
result.push_back(cameraDir);
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int size_x = glutGet(GLUT_WINDOW_WIDTH);
|
|
||||||
int size_y = glutGet(GLUT_WINDOW_HEIGHT);
|
|
||||||
std::vector<glm::vec3> ray = calculate_ray((x / float(size_x) - 0.5) * 2, -((y / float(size_y)) - 0.5) * 2);
|
|
||||||
grabbedObject.newPos = vec3ToPxVec(ray[1]) * grabbedObject.distance + vec3ToPxVec(ray[0]);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void mouse(int x, int y)
|
|
||||||
{
|
|
||||||
|
|
||||||
int size_x = glutGet(GLUT_WINDOW_WIDTH);
|
|
||||||
int size_y = glutGet(GLUT_WINDOW_HEIGHT);
|
|
||||||
std::vector<glm::vec3> ray = calculate_ray((x / float(size_x) - 0.5) * 2, -((y / float(size_y)) - 0.5) * 2);
|
|
||||||
Core::updateRayPos(rayContext, ray);
|
|
||||||
grabbedObject.newPos = vec3ToPxVec(ray[1]) * grabbedObject.distance + vec3ToPxVec(ray[0]);
|
|
||||||
|
|
||||||
}
|
|
||||||
void click_mouse(int button, int state, int x, int y) {
|
|
||||||
if ((GLUT_LEFT_BUTTON == button && state == GLUT_DOWN)) {
|
|
||||||
|
|
||||||
int size_x = glutGet(GLUT_WINDOW_WIDTH);
|
|
||||||
int size_y = glutGet(GLUT_WINDOW_HEIGHT);
|
|
||||||
std::vector<glm::vec3> ray = calculate_ray((x / float(size_x) - 0.5) * 2, -((y / float(size_y)) - 0.5) * 2);
|
|
||||||
Core::updateRayPos(rayContext, ray);
|
|
||||||
|
|
||||||
//here raycast should be done
|
|
||||||
|
|
||||||
//check if there is a hit
|
|
||||||
if (false) {
|
|
||||||
|
|
||||||
//check if it is rigid dynamic
|
|
||||||
if (false) {
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
std::cout << "no hit\n";
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (GLUT_LEFT_BUTTON == button && state == GLUT_UP) {
|
|
||||||
DRAGING_ON = false;
|
|
||||||
grabbedObject.update = false;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
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);
|
|
||||||
|
|
||||||
context->render();
|
|
||||||
|
|
||||||
glUseProgram(0);
|
|
||||||
}
|
|
||||||
|
|
||||||
void drawRay(Core::RayContext& context) {
|
|
||||||
glUseProgram(programRed);
|
|
||||||
|
|
||||||
glm::mat4 transformation = perspectiveMatrix * cameraMatrix;
|
|
||||||
glUniformMatrix4fv(glGetUniformLocation(programRed, "modelViewProjectionMatrix"), 1, GL_FALSE, (float*)&transformation);
|
|
||||||
context.render();
|
|
||||||
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);
|
|
||||||
|
|
||||||
context->render();
|
|
||||||
glUseProgram(0);
|
|
||||||
}
|
|
||||||
|
|
||||||
void renderScene()
|
|
||||||
{
|
|
||||||
|
|
||||||
if (grabbedObject.update) {
|
|
||||||
// Here should be grab object update
|
|
||||||
}
|
|
||||||
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
#ifdef SHOW_RAY
|
|
||||||
drawRay(rayContext);
|
|
||||||
#endif // SHOW_RAY
|
|
||||||
|
|
||||||
|
|
||||||
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");
|
|
||||||
programRed = shaderLoader.CreateProgram("shaders/shader_red.vert", "shaders/shader_red.frag");
|
|
||||||
|
|
||||||
|
|
||||||
Core::initRay(rayContext);
|
|
||||||
auto ray = calculate_ray(0.5f,0.5f);
|
|
||||||
//Core::updateRayPos(rayContext, ray);
|
|
||||||
|
|
||||||
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);
|
|
||||||
glutMotionFunc(mouse);
|
|
||||||
glutMouseFunc(click_mouse);
|
|
||||||
glutDisplayFunc(renderScene);
|
|
||||||
glutIdleFunc(idle);
|
|
||||||
|
|
||||||
glutMainLoop();
|
|
||||||
|
|
||||||
shutdown();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
@ -1,140 +0,0 @@
|
|||||||
|
|
||||||
|
|
||||||
#ifndef MESH_H
|
|
||||||
#define MESH_H
|
|
||||||
|
|
||||||
#include "glew.h"
|
|
||||||
#include "freeglut.h"
|
|
||||||
#include "glm.hpp"
|
|
||||||
#include "ext.hpp"
|
|
||||||
#include <iostream>
|
|
||||||
#include <cmath>
|
|
||||||
|
|
||||||
#include <string>
|
|
||||||
#include <vector>
|
|
||||||
using namespace std;
|
|
||||||
|
|
||||||
struct Vertex {
|
|
||||||
// position
|
|
||||||
glm::vec3 Position;
|
|
||||||
// normal
|
|
||||||
glm::vec3 Normal;
|
|
||||||
// texCoords
|
|
||||||
glm::vec2 TexCoords;
|
|
||||||
// tangent
|
|
||||||
glm::vec3 Tangent;
|
|
||||||
// bitangent
|
|
||||||
glm::vec3 Bitangent;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct Texture {
|
|
||||||
unsigned int id;
|
|
||||||
string type;
|
|
||||||
string path;
|
|
||||||
};
|
|
||||||
|
|
||||||
class Mesh {
|
|
||||||
public:
|
|
||||||
// mesh Data
|
|
||||||
vector<Vertex> vertices;
|
|
||||||
vector<unsigned int> indices;
|
|
||||||
vector<Texture> textures;
|
|
||||||
glm::mat4 matrix;
|
|
||||||
unsigned int VAO;
|
|
||||||
|
|
||||||
// constructor
|
|
||||||
Mesh(vector<Vertex> vertices, vector<unsigned int> indices, vector<Texture> textures,glm::mat4 matrix)
|
|
||||||
{
|
|
||||||
this->vertices = vertices;
|
|
||||||
this->indices = indices;
|
|
||||||
this->textures = textures;
|
|
||||||
this->matrix = matrix;
|
|
||||||
|
|
||||||
// now that we have all the required data, set the vertex buffers and its attribute pointers.
|
|
||||||
setupMesh();
|
|
||||||
}
|
|
||||||
|
|
||||||
// render the mesh
|
|
||||||
void Draw(GLuint program)
|
|
||||||
{
|
|
||||||
// bind appropriate textures
|
|
||||||
unsigned int diffuseNr = 1;
|
|
||||||
unsigned int specularNr = 1;
|
|
||||||
unsigned int normalNr = 1;
|
|
||||||
unsigned int heightNr = 1;
|
|
||||||
for (unsigned int i = 0; i < textures.size(); i++)
|
|
||||||
{
|
|
||||||
glActiveTexture(GL_TEXTURE0 + i); // active proper texture unit before binding
|
|
||||||
// retrieve texture number (the N in diffuse_textureN)
|
|
||||||
string number;
|
|
||||||
string name = textures[i].type;
|
|
||||||
if (name == "texture_diffuse")
|
|
||||||
number = std::to_string(diffuseNr++);
|
|
||||||
else if (name == "texture_specular")
|
|
||||||
number = std::to_string(specularNr++); // transfer unsigned int to stream
|
|
||||||
else if (name == "texture_normal")
|
|
||||||
number = std::to_string(normalNr++); // transfer unsigned int to stream
|
|
||||||
else if (name == "texture_height")
|
|
||||||
number = std::to_string(heightNr++); // transfer unsigned int to stream
|
|
||||||
|
|
||||||
// now set the sampler to the correct texture unit
|
|
||||||
glUniform1i(glGetUniformLocation(program, (name + number).c_str()), i);
|
|
||||||
// and finally bind the texture
|
|
||||||
glBindTexture(GL_TEXTURE_2D, textures[i].id);
|
|
||||||
}
|
|
||||||
|
|
||||||
glUniformMatrix4fv(glGetUniformLocation(program, "model"), 1, GL_FALSE, (float*)&matrix);
|
|
||||||
// draw mesh
|
|
||||||
glBindVertexArray(VAO);
|
|
||||||
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
|
|
||||||
glBindVertexArray(0);
|
|
||||||
|
|
||||||
// always good practice to set everything back to defaults once configured.
|
|
||||||
glActiveTexture(GL_TEXTURE0);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
// render data
|
|
||||||
unsigned int VBO, EBO;
|
|
||||||
|
|
||||||
// initializes all the buffer objects/arrays
|
|
||||||
void setupMesh()
|
|
||||||
{
|
|
||||||
// create buffers/arrays
|
|
||||||
glGenVertexArrays(1, &VAO);
|
|
||||||
glGenBuffers(1, &VBO);
|
|
||||||
glGenBuffers(1, &EBO);
|
|
||||||
|
|
||||||
glBindVertexArray(VAO);
|
|
||||||
// load data into vertex buffers
|
|
||||||
glBindBuffer(GL_ARRAY_BUFFER, VBO);
|
|
||||||
// A great thing about structs is that their memory layout is sequential for all its items.
|
|
||||||
// The effect is that we can simply pass a pointer to the struct and it translates perfectly to a glm::vec3/2 array which
|
|
||||||
// again translates to 3/2 floats which translates to a byte array.
|
|
||||||
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
|
|
||||||
|
|
||||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
|
|
||||||
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
|
|
||||||
|
|
||||||
// set the vertex attribute pointers
|
|
||||||
// vertex Positions
|
|
||||||
glEnableVertexAttribArray(0);
|
|
||||||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
|
|
||||||
// vertex normals
|
|
||||||
glEnableVertexAttribArray(1);
|
|
||||||
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
|
|
||||||
// vertex texture coords
|
|
||||||
glEnableVertexAttribArray(2);
|
|
||||||
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));
|
|
||||||
// vertex tangent
|
|
||||||
glEnableVertexAttribArray(3);
|
|
||||||
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Tangent));
|
|
||||||
// vertex bitangent
|
|
||||||
glEnableVertexAttribArray(4);
|
|
||||||
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Bitangent));
|
|
||||||
|
|
||||||
glBindVertexArray(0);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,250 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#include "glew.h"
|
|
||||||
#include "freeglut.h"
|
|
||||||
#include "glm.hpp"
|
|
||||||
#include "ext.hpp"
|
|
||||||
#include <iostream>
|
|
||||||
#include <cmath>
|
|
||||||
#include <assimp/Importer.hpp>
|
|
||||||
#include <assimp/scene.h>
|
|
||||||
#include <assimp/postprocess.h>
|
|
||||||
|
|
||||||
#include "stb_image.h"
|
|
||||||
#include "mesh.h"
|
|
||||||
|
|
||||||
#include <string>
|
|
||||||
#include <fstream>
|
|
||||||
#include <sstream>
|
|
||||||
#include <iostream>
|
|
||||||
#include <map>
|
|
||||||
#include <vector>
|
|
||||||
using namespace std;
|
|
||||||
|
|
||||||
|
|
||||||
unsigned int TextureFromFile(const char* path, const string& directory, bool gamma = false);
|
|
||||||
|
|
||||||
class Model
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
// model data
|
|
||||||
vector<Texture> textures_loaded; // stores all the textures loaded so far, optimization to make sure textures aren't loaded more than once.
|
|
||||||
vector<Mesh> meshes;
|
|
||||||
string directory;
|
|
||||||
bool gammaCorrection;
|
|
||||||
|
|
||||||
// constructor, expects a filepath to a 3D model.
|
|
||||||
Model(string const& path, bool gamma = false) : gammaCorrection(gamma)
|
|
||||||
{
|
|
||||||
loadModel(path);
|
|
||||||
}
|
|
||||||
|
|
||||||
// draws the model, and thus all its meshes
|
|
||||||
void Draw(GLuint shader)
|
|
||||||
{
|
|
||||||
for (unsigned int i = 0; i < meshes.size(); i++)
|
|
||||||
meshes[i].Draw(shader);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
// loads a model with supported ASSIMP extensions from file and stores the resulting meshes in the meshes vector.
|
|
||||||
void loadModel(string const& path)
|
|
||||||
{
|
|
||||||
// read file via ASSIMP
|
|
||||||
Assimp::Importer importer;
|
|
||||||
const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_CalcTangentSpace);
|
|
||||||
// check for errors
|
|
||||||
if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero
|
|
||||||
{
|
|
||||||
cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << endl;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
// retrieve the directory path of the filepath
|
|
||||||
directory = path.substr(0, path.find_last_of('/'));
|
|
||||||
|
|
||||||
// process ASSIMP's root node recursively
|
|
||||||
processNode(scene->mRootNode, scene,glm::mat4());
|
|
||||||
}
|
|
||||||
|
|
||||||
// processes a node in a recursive fashion. Processes each individual mesh located at the node and repeats this process on its children nodes (if any).
|
|
||||||
void processNode(aiNode* node, const aiScene* scene,glm::mat4 matrix)
|
|
||||||
{
|
|
||||||
glm::mat4 outMatrix = matrix * mat4_cast(node->mTransformation);
|
|
||||||
// process each mesh located at the current node
|
|
||||||
for (unsigned int i = 0; i < node->mNumMeshes; i++)
|
|
||||||
{
|
|
||||||
// the node object only contains indices to index the actual objects in the scene.
|
|
||||||
// the scene contains all the data, node is just to keep stuff organized (like relations between nodes).
|
|
||||||
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
|
|
||||||
meshes.push_back(processMesh(mesh, scene, outMatrix));
|
|
||||||
}
|
|
||||||
// after we've processed all of the meshes (if any) we then recursively process each of the children nodes
|
|
||||||
for (unsigned int i = 0; i < node->mNumChildren; i++)
|
|
||||||
{
|
|
||||||
processNode(node->mChildren[i], scene, outMatrix);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
Mesh processMesh(aiMesh* mesh, const aiScene* scene, glm::mat4 matrix)
|
|
||||||
{
|
|
||||||
// data to fill
|
|
||||||
vector<Vertex> vertices;
|
|
||||||
vector<unsigned int> indices;
|
|
||||||
vector<Texture> textures;
|
|
||||||
|
|
||||||
// walk through each of the mesh's vertices
|
|
||||||
for (unsigned int i = 0; i < mesh->mNumVertices; i++)
|
|
||||||
{
|
|
||||||
Vertex vertex;
|
|
||||||
glm::vec3 vector; // we declare a placeholder vector since assimp uses its own vector class that doesn't directly convert to glm's vec3 class so we transfer the data to this placeholder glm::vec3 first.
|
|
||||||
// positions
|
|
||||||
vector.x = mesh->mVertices[i].x;
|
|
||||||
vector.y = mesh->mVertices[i].y;
|
|
||||||
vector.z = mesh->mVertices[i].z;
|
|
||||||
vertex.Position = vector;
|
|
||||||
// normals
|
|
||||||
if (mesh->HasNormals())
|
|
||||||
{
|
|
||||||
vector.x = mesh->mNormals[i].x;
|
|
||||||
vector.y = mesh->mNormals[i].y;
|
|
||||||
vector.z = mesh->mNormals[i].z;
|
|
||||||
vertex.Normal = vector;
|
|
||||||
}
|
|
||||||
// texture coordinates
|
|
||||||
if (mesh->mTextureCoords[0]) // does the mesh contain texture coordinates?
|
|
||||||
{
|
|
||||||
glm::vec2 vec;
|
|
||||||
// a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't
|
|
||||||
// use models where a vertex can have multiple texture coordinates so we always take the first set (0).
|
|
||||||
vec.x = mesh->mTextureCoords[0][i].x;
|
|
||||||
vec.y = mesh->mTextureCoords[0][i].y;
|
|
||||||
vertex.TexCoords = vec;
|
|
||||||
// tangent
|
|
||||||
vector.x = mesh->mTangents[i].x;
|
|
||||||
vector.y = mesh->mTangents[i].y;
|
|
||||||
vector.z = mesh->mTangents[i].z;
|
|
||||||
vertex.Tangent = vector;
|
|
||||||
// bitangent
|
|
||||||
vector.x = mesh->mBitangents[i].x;
|
|
||||||
vector.y = mesh->mBitangents[i].y;
|
|
||||||
vector.z = mesh->mBitangents[i].z;
|
|
||||||
vertex.Bitangent = vector;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
vertex.TexCoords = glm::vec2(0.0f, 0.0f);
|
|
||||||
|
|
||||||
vertices.push_back(vertex);
|
|
||||||
}
|
|
||||||
// now wak through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices.
|
|
||||||
for (unsigned int i = 0; i < mesh->mNumFaces; i++)
|
|
||||||
{
|
|
||||||
aiFace face = mesh->mFaces[i];
|
|
||||||
// retrieve all indices of the face and store them in the indices vector
|
|
||||||
for (unsigned int j = 0; j < face.mNumIndices; j++)
|
|
||||||
indices.push_back(face.mIndices[j]);
|
|
||||||
}
|
|
||||||
// process materials
|
|
||||||
aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
|
|
||||||
// we assume a convention for sampler names in the shaders. Each diffuse texture should be named
|
|
||||||
// as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER.
|
|
||||||
// Same applies to other texture as the following list summarizes:
|
|
||||||
// diffuse: texture_diffuseN
|
|
||||||
// specular: texture_specularN
|
|
||||||
// normal: texture_normalN
|
|
||||||
|
|
||||||
// 1. diffuse maps
|
|
||||||
vector<Texture> diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse");
|
|
||||||
textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
|
|
||||||
// 2. specular maps
|
|
||||||
vector<Texture> specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular");
|
|
||||||
textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
|
|
||||||
// 3. normal maps
|
|
||||||
std::vector<Texture> normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal");
|
|
||||||
textures.insert(textures.end(), normalMaps.begin(), normalMaps.end());
|
|
||||||
// 4. height maps
|
|
||||||
std::vector<Texture> heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height");
|
|
||||||
textures.insert(textures.end(), heightMaps.begin(), heightMaps.end());
|
|
||||||
|
|
||||||
|
|
||||||
// return a mesh object created from the extracted mesh data
|
|
||||||
return Mesh(vertices, indices, textures, matrix);
|
|
||||||
}
|
|
||||||
|
|
||||||
// checks all material textures of a given type and loads the textures if they're not loaded yet.
|
|
||||||
// the required info is returned as a Texture struct.
|
|
||||||
vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, string typeName)
|
|
||||||
{
|
|
||||||
vector<Texture> textures;
|
|
||||||
for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)
|
|
||||||
{
|
|
||||||
aiString str;
|
|
||||||
mat->GetTexture(type, i, &str);
|
|
||||||
// check if texture was loaded before and if so, continue to next iteration: skip loading a new texture
|
|
||||||
bool skip = false;
|
|
||||||
for (unsigned int j = 0; j < textures_loaded.size(); j++)
|
|
||||||
{
|
|
||||||
if (std::strcmp(textures_loaded[j].path.data(), str.C_Str()) == 0)
|
|
||||||
{
|
|
||||||
textures.push_back(textures_loaded[j]);
|
|
||||||
skip = true; // a texture with the same filepath has already been loaded, continue to next one. (optimization)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (!skip)
|
|
||||||
{ // if texture hasn't been loaded already, load it
|
|
||||||
Texture texture;
|
|
||||||
texture.id = TextureFromFile(str.C_Str(), this->directory);
|
|
||||||
texture.type = typeName;
|
|
||||||
texture.path = str.C_Str();
|
|
||||||
textures.push_back(texture);
|
|
||||||
textures_loaded.push_back(texture); // store it as texture loaded for entire model, to ensure we won't unnecesery load duplicate textures.
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return textures;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
unsigned int TextureFromFile(const char* path, const string& directory, bool gamma)
|
|
||||||
{
|
|
||||||
string filename = string(path);
|
|
||||||
filename = directory + '/' + filename;
|
|
||||||
|
|
||||||
unsigned int textureID;
|
|
||||||
glGenTextures(1, &textureID);
|
|
||||||
|
|
||||||
int width, height, nrComponents;
|
|
||||||
unsigned char* data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0);
|
|
||||||
if (data)
|
|
||||||
{
|
|
||||||
GLenum format;
|
|
||||||
if (nrComponents == 1)
|
|
||||||
format = GL_RED;
|
|
||||||
else if (nrComponents == 3)
|
|
||||||
format = GL_RGB;
|
|
||||||
else if (nrComponents == 4)
|
|
||||||
format = GL_RGBA;
|
|
||||||
|
|
||||||
glBindTexture(GL_TEXTURE_2D, textureID);
|
|
||||||
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
|
|
||||||
glGenerateMipmap(GL_TEXTURE_2D);
|
|
||||||
|
|
||||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
||||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
||||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
||||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
||||||
|
|
||||||
stbi_image_free(data);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
std::cout << "Texture failed to load at path: " << path << std::endl;
|
|
||||||
stbi_image_free(data);
|
|
||||||
}
|
|
||||||
|
|
||||||
return textureID;
|
|
||||||
}
|
|
Before Width: | Height: | Size: 4.1 MiB |
Before Width: | Height: | Size: 2.6 MiB |
Before Width: | Height: | Size: 1.2 MiB |
Before Width: | Height: | Size: 2.6 MiB |
Before Width: | Height: | Size: 3.0 MiB |
Before Width: | Height: | Size: 2.5 MiB |
Before Width: | Height: | Size: 3.6 MiB |
Before Width: | Height: | Size: 2.9 MiB |
Before Width: | Height: | Size: 4.6 MiB |
Before Width: | Height: | Size: 3.2 MiB |
Before Width: | Height: | Size: 4.9 MiB |
Before Width: | Height: | Size: 3.0 MiB |
Before Width: | Height: | Size: 14 MiB |
Before Width: | Height: | Size: 6.3 MiB |
Before Width: | Height: | Size: 94 KiB |
Before Width: | Height: | Size: 576 KiB |
Before Width: | Height: | Size: 454 KiB |
Before Width: | Height: | Size: 595 KiB |
Before Width: | Height: | Size: 523 KiB |
Before Width: | Height: | Size: 573 KiB |
Before Width: | Height: | Size: 4.9 MiB |
Before Width: | Height: | Size: 3.0 MiB |
Before Width: | Height: | Size: 3.0 MiB |
BIN
GrafikaProjekt/pliki/textures/asteroid.png
Normal file
After Width: | Height: | Size: 4.0 MiB |
Before Width: | Height: | Size: 280 KiB |
Before Width: | Height: | Size: 441 KiB |
Before Width: | Height: | Size: 1.8 MiB |
@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
|
|||||||
# Visual Studio Version 16
|
# Visual Studio Version 16
|
||||||
VisualStudioVersion = 16.0.31019.35
|
VisualStudioVersion = 16.0.31019.35
|
||||||
MinimumVisualStudioVersion = 10.0.40219.1
|
MinimumVisualStudioVersion = 10.0.40219.1
|
||||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "scena_podwodna", "pliki\projekt.vcxproj", "{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}"
|
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "grk-cw6", "pliki\projekt.vcxproj", "{10701B86-9B0B-46A1-85DA-6238CBCC507B}"
|
||||||
EndProject
|
EndProject
|
||||||
Global
|
Global
|
||||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||||
@ -11,10 +11,10 @@ Global
|
|||||||
Release|x86 = Release|x86
|
Release|x86 = Release|x86
|
||||||
EndGlobalSection
|
EndGlobalSection
|
||||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Debug|x86.ActiveCfg = Debug|Win32
|
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|x86.ActiveCfg = Debug|Win32
|
||||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Debug|x86.Build.0 = Debug|Win32
|
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Debug|x86.Build.0 = Debug|Win32
|
||||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Release|x86.ActiveCfg = Release|Win32
|
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|x86.ActiveCfg = Release|Win32
|
||||||
{DC3B0EF1-7A30-41B3-9E0D-A1B2E5896290}.Release|x86.Build.0 = Release|Win32
|
{10701B86-9B0B-46A1-85DA-6238CBCC507B}.Release|x86.Build.0 = Release|Win32
|
||||||
EndGlobalSection
|
EndGlobalSection
|
||||||
GlobalSection(SolutionProperties) = preSolution
|
GlobalSection(SolutionProperties) = preSolution
|
||||||
HideSolutionNode = FALSE
|
HideSolutionNode = FALSE
|
||||||
|