gpesquero/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Implementation of 3d arrow.

Browse source
This commit is contained in:
Daria Volvenkova 2015-12-01 14:19:27 +03:00
parent 9b6977d829
commit cdc06f523f
8 changed files with 270 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
drape/shaders/arrow3d_fragment_shader.fsh Normal file
View file

@ -0,0 +1,7 @@
varying float v_intensity;
void main()
{
gl_FragColor.rgb = (v_intensity * 0.4 + 0.6) * vec3(0.0, 0.75, 1.0);
gl_FragColor.a = 1.0;
}

16
drape/shaders/arrow3d_vertex_shader.vsh Normal file
View file

@ -0,0 +1,16 @@
attribute vec3 a_pos;
attribute vec3 a_normal;
uniform mat4 m_transform;
varying float v_intensity;
void main()
{
vec4 lightDir = vec4(1.0, 0.0, 1.0, 0.0);
vec4 position = m_transform * vec4(a_pos, 1.0);
vec4 normal = m_transform * vec4(a_normal + a_pos, 1.0);
v_intensity = max(0.0, -dot(normalize(lightDir), normalize(normal - position)));
gl_Position = position;
}

1
drape/shaders/shader_index.txt
View file

@ -17,6 +17,7 @@ ROUTE_PROGRAM route_vertex_shader.vsh route_fragment_shader.fsh
ROUTE_ARROW_PROGRAM route_vertex_shader.vsh route_arrow_fragment_shader.fsh
DEBUG_RECT_PROGRAM debug_rect_vertex_shader.vsh debug_rect_fragment_shader.fsh
TEXTURING_3D_PROGRAM texturing3d_vertex_shader.vsh texturing3d_fragment_shader.fsh
ARROW_3D_PROGRAM arrow3d_vertex_shader.vsh arrow3d_fragment_shader.fsh
TEXTURING_BILLBOARD_PROGRAM texturing_billboard_vertex_shader.vsh texturing_fragment_shader.fsh
TEXT_OUTLINED_BILLBOARD_PROGRAM text_outlined_billboard_vertex_shader.vsh text_fragment_shader.fsh
TEXT_BILLBOARD_PROGRAM text_billboard_vertex_shader.vsh text_fragment_shader.fsh

173
drape_frontend/arrow3d.cpp Normal file
View file

@ -0,0 +1,173 @@
#include "arrow3d.hpp"
#include "drape/glconstants.hpp"
#include "drape/glfunctions.hpp"
#include "drape/glsl_func.hpp"
#include "drape/glsl_types.hpp"
#include "drape/glstate.hpp"
#include "drape/gpu_program_manager.hpp"
#include "drape/shader_def.hpp"
#include "drape/uniform_values_storage.hpp"
#include "geometry/screenbase.hpp"
namespace df
{
double const kArrowSizeX = 2.0;
double const kArrowSizeY = 3.0;
double const kArrow3dScale = 1.5;
Arrow3d::Arrow3d()
{
m_vertices = { 0.0f, 0.0f, -1.0f,
-1.0f, -1.0f, 0.0f,
0.0f, 2.0f, 0.0f,
0.0f, 0.0f, -1.0f,
0.0f, 2.0f, 0.0f,
1.0f, -1.0f, 0.0f,
0.0f, 0.0f, -1.0f,
0.0f, -0.5f, 0.0f,
-1.0f, -1.0f, 0.0f,
0.0f, 0.0f, -1.0f,
1.0f, -1.0f, 0.0f,
0.0f, -0.5f, 0.0f
};
m_normals.resize(m_vertices.size());
for (size_t triangle = 0; triangle < m_vertices.size() / 9; ++triangle)
{
glsl::vec3 v[3];
for (size_t vertex = 0; vertex < 3; ++vertex)
{
size_t const offset = triangle * 9 + vertex * 3;
v[vertex] = glsl::vec3(m_vertices[offset], m_vertices[offset + 1], m_vertices[offset + 2]);
}
glsl::vec3 normal = glsl::cross(glsl::vec3(v[1].x - v[0].x, v[1].y - v[0].y, v[1].z - v[0].z),
glsl::vec3(v[2].x - v[0].x, v[2].y - v[0].y, v[2].z - v[0].z));
normal = glsl::normalize(normal);
for (size_t vertex = 0; vertex < 3; ++vertex)
{
size_t const offset = triangle * 9 + vertex * 3;
m_normals[offset] = normal.x;
m_normals[offset + 1] = normal.y;
m_normals[offset + 2] = normal.z;
}
}
}
Arrow3d::~Arrow3d()
{
if (m_bufferId != 0)
GLFunctions::glDeleteBuffer(m_bufferId);
if (m_bufferNormalsId != 0)
GLFunctions::glDeleteBuffer(m_bufferNormalsId);
if (m_VAO != 0)
GLFunctions::glDeleteVertexArray(m_VAO);
}
void Arrow3d::SetPosition(const m2::PointD & position)
{
m_position = position;
}
void Arrow3d::SetAzimuth(double azimuth)
{
m_azimuth = azimuth;
}
void Arrow3d::SetSize(uint32_t width, uint32_t height)
{
m_pixelWidth = width;
m_pixelHeight = height;
}
void Arrow3d::Build(ref_ptr<dp::GpuProgram> prg)
{
m_VAO = GLFunctions::glGenVertexArray();
GLFunctions::glBindVertexArray(m_VAO);
m_bufferId = GLFunctions::glGenBuffer();
GLFunctions::glBindBuffer(m_bufferId, gl_const::GLArrayBuffer);
int8_t attributeLocation = prg->GetAttributeLocation("a_pos");
ASSERT_NOT_EQUAL(attributeLocation, -1, ());
GLFunctions::glEnableVertexAttribute(attributeLocation);
GLFunctions::glVertexAttributePointer(attributeLocation, 3, gl_const::GLFloatType, false, 0, 0);
GLFunctions::glBufferData(gl_const::GLArrayBuffer, m_vertices.size() * sizeof(m_vertices[0]),
m_vertices.data(), gl_const::GLStaticDraw);
m_bufferNormalsId = GLFunctions::glGenBuffer();
GLFunctions::glBindBuffer(m_bufferNormalsId, gl_const::GLArrayBuffer);
attributeLocation = prg->GetAttributeLocation("a_normal");
ASSERT_NOT_EQUAL(attributeLocation, -1, ());
GLFunctions::glEnableVertexAttribute(attributeLocation);
GLFunctions::glVertexAttributePointer(attributeLocation, 3, gl_const::GLFloatType, false, 0, 0);
GLFunctions::glBufferData(gl_const::GLArrayBuffer, m_normals.size() * sizeof(m_normals[0]),
m_normals.data(), gl_const::GLStaticDraw);
GLFunctions::glBindVertexArray(0);
GLFunctions::glBindBuffer(0, gl_const::GLArrayBuffer);
}
void Arrow3d::Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng)
{
ref_ptr<dp::GpuProgram> prg = mng->GetProgram(gpu::ARROW_3D_PROGRAM);
prg->Bind();
if (m_VAO == 0)
Build(prg);
double scaleX = m_pixelWidth * kArrow3dScale * 2.0 / screen.PixelRect().SizeX() / kArrowSizeX;
double scaleY = m_pixelHeight * kArrow3dScale * 2.0 / screen.PixelRect().SizeY() / kArrowSizeY;
double scaleZ = scaleX;
m2::PointD const pos = screen.GtoP(m_position);
double const dX = 2.0 * pos.x / screen.PixelRect().SizeX() - 1.0;
double const dY = 2.0 * pos.y / screen.PixelRect().SizeY() - 1.0;
math::Matrix<float, 4, 4> scaleM = math::Identity<float, 4>();
scaleM(0, 0) = scaleX;
scaleM(1, 1) = scaleY;
scaleM(2, 2) = scaleZ;
math::Matrix<float, 4, 4> rotateM = math::Identity<float, 4>();
rotateM(0, 0) = cos(m_azimuth + screen.GetAngle());
rotateM(0, 1) = -sin(m_azimuth + screen.GetAngle());
rotateM(1, 0) = -rotateM(0, 1);
rotateM(1, 1) = rotateM(0, 0);
math::Matrix<float, 4, 4> translateM = math::Identity<float, 4>();
translateM(3, 0) = dX;
translateM(3, 1) = -dY;
math::Matrix<float, 4, 4> modelTransform = rotateM * scaleM * translateM;
modelTransform = modelTransform * math::Matrix<float, 4, 4>(screen.Pto3dMatrix());
dp::UniformValuesStorage uniforms;
uniforms.SetMatrix4x4Value("m_transform", modelTransform.m_data);
dp::ApplyUniforms(uniforms, prg);
GLFunctions::glEnable(gl_const::GLDepthTest);
GLFunctions::glClearDepth();
GLFunctions::glViewport(0, 0, screen.PixelRectIn3d().SizeX(), screen.PixelRectIn3d().SizeY());
GLFunctions::glBindVertexArray(m_VAO);
GLFunctions::glDrawArrays(gl_const::GLTriangles, 0, m_vertices.size() / 3);
prg->Unbind();
GLFunctions::glBindVertexArray(0);
}
} // namespace df

50
drape_frontend/arrow3d.hpp Normal file
View file

@ -0,0 +1,50 @@
#pragma once
#include "drape/pointers.hpp"
#include "geometry/rect2d.hpp"
#include "std/vector.hpp"
namespace dp
{
class GpuProgram;
class GpuProgramManager;
}
class ScreenBase;
namespace df
{
class Arrow3d
{
public:
Arrow3d();
~Arrow3d();
void SetPosition(m2::PointD const & position);
void SetAzimuth(double azimuth);
void SetSize(uint32_t width, uint32_t height);
void Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng);
private:
void Build(ref_ptr<dp::GpuProgram> prg);
m2::PointD m_position;
double m_azimuth;
uint32_t m_pixelWidth = 0;
uint32_t m_pixelHeight = 0;
uint32_t m_VAO = 0;
uint32_t m_bufferId = 0;
uint32_t m_bufferNormalsId = 0;
vector<float> m_vertices;
vector<float> m_normals;
};
} // namespace df

2
drape_frontend/drape_frontend.pro
View file

@ -33,6 +33,7 @@ SOURCES += \
gui/skin.cpp \
apply_feature_functors.cpp \
area_shape.cpp \
arrow3d.cpp \
backend_renderer.cpp \
base_renderer.cpp \
batchers_pool.cpp \
@ -114,6 +115,7 @@ HEADERS += \
gui/skin.hpp \
apply_feature_functors.hpp \
area_shape.hpp \
arrow3d.hpp \
backend_renderer.hpp \
base_renderer.hpp \
batchers_pool.hpp \

24
drape_frontend/my_position.cpp
View file

@ -103,12 +103,22 @@ void MyPosition::RenderMyPosition(ScreenBase const & screen,
ref_ptr<dp::GpuProgramManager> mng,
dp::UniformValuesStorage const & commonUniforms)
{
dp::UniformValuesStorage uniforms = commonUniforms;
uniforms.SetFloatValue("u_position", m_position.x, m_position.y, dp::depth::MY_POSITION_MARK);
uniforms.SetFloatValue("u_azimut", -(m_azimuth + screen.GetAngle()));
uniforms.SetFloatValue("u_opacity", 1.0);
RenderPart(mng, uniforms, (m_showAzimuth == true) ?
(m_isRoutingMode ? MY_POSITION_ROUTING_ARROW : MY_POSITION_ARROW) : MY_POSITION_POINT);
if (screen.isPerspective() && m_isRoutingMode && m_showAzimuth)
{
m_arrow3d.SetPosition(m_position);
m_arrow3d.SetAzimuth(m_azimuth);
m_arrow3d.Render(screen, mng);
}
else
{
dp::UniformValuesStorage uniforms = commonUniforms;
uniforms.SetFloatValue("u_position", m_position.x, m_position.y, dp::depth::MY_POSITION_MARK);
uniforms.SetFloatValue("u_azimut", -(m_azimuth + screen.GetAngle()));
uniforms.SetFloatValue("u_opacity", 1.0);
RenderPart(mng, uniforms, (m_showAzimuth == true) ?
(m_isRoutingMode ? MY_POSITION_ROUTING_ARROW : MY_POSITION_ARROW) : MY_POSITION_POINT);
}
}
void MyPosition::CacheAccuracySector(ref_ptr<dp::TextureManager> mng)
@ -188,6 +198,8 @@ void MyPosition::CachePointPosition(ref_ptr<dp::TextureManager> mng)
m2::RectF const & routingArrowTexRect = routingArrowSymbol.GetTexRect();
m2::PointF routingArrowHalfSize = m2::PointF(routingArrowSymbol.GetPixelSize()) * 0.5f;
m_arrow3d.SetSize(routingArrowSymbol.GetPixelSize().x, routingArrowSymbol.GetPixelSize().y);
Vertex routingArrowData[4]=
{
{ glsl::vec2(-routingArrowHalfSize.x, routingArrowHalfSize.y), glsl::ToVec2(routingArrowTexRect.LeftTop()) },

3
drape_frontend/my_position.hpp
View file

@ -1,5 +1,6 @@
#pragma once
#include "arrow3d.hpp"
#include "render_node.hpp"
#include "drape/vertex_array_buffer.hpp"
@ -63,6 +64,8 @@ private:
vector<TPart> m_parts;
vector<RenderNode> m_nodes;
Arrow3d m_arrow3d;
};
}