shaders for drawing text by path

drape/shaders/path_font_fragment_shader.fsh

@@ -0,0 +1,83 @@
+uniform sampler2D u_textures[8];
+
+varying vec3 v_texcoord;
+varying vec4 v_color;
+varying vec4 v_outline_color;
+
+const int Index0  = 0;
+const int Index1  = 1;
+const int Index2  = 2;
+const int Index3  = 3;
+const int Index4  = 4;
+const int Index5  = 5;
+const int Index6  = 6;
+const int Index7  = 7;
+
+const float OUTLINE_MIN_VALUE0 = 0.49;
+const float OUTLINE_MIN_VALUE1 = 0.53;
+const float OUTLINE_MAX_VALUE0 = 0.58;
+const float OUTLINE_MAX_VALUE1 = 0.6;
+
+vec4 colorize(vec4 baseColor)
+{
+  vec4 outline = v_outline_color;
+  float alpha = 1.0 - baseColor.a;
+
+  if (alpha > OUTLINE_MAX_VALUE1)
+    return vec4(outline.rgb,0);
+  if (alpha > OUTLINE_MAX_VALUE0)
+  {
+    float oFactor=smoothstep(OUTLINE_MAX_VALUE1, OUTLINE_MAX_VALUE0, alpha );
+    return mix(vec4(outline.rgb,0), outline, oFactor);
+  }
+  if (alpha > OUTLINE_MIN_VALUE1)
+  {
+    return outline;
+  }
+  if (alpha > OUTLINE_MIN_VALUE0)
+  {
+    float oFactor=smoothstep(OUTLINE_MIN_VALUE0, OUTLINE_MIN_VALUE1, alpha );
+    return mix(v_color, outline, oFactor);
+  }
+  return v_color;
+}
+
+vec4 without_outline(vec4 baseColor)
+{
+  float alpha = 1.0 - baseColor.a;
+
+  if (alpha > OUTLINE_MIN_VALUE0)
+  {
+    float oFactor=smoothstep(OUTLINE_MIN_VALUE0, OUTLINE_MIN_VALUE1, alpha );
+    return mix(v_color, vec4(1,1,1,0), oFactor);
+  }
+  return v_color;
+}
+
+void main (void)
+{
+  float alpha;
+  int textureIndex = int(v_texcoord.z / 2.0);
+  if (textureIndex == Index0)
+    alpha = texture2D(u_textures[Index0], v_texcoord.xy).a;
+  else if (textureIndex == Index1)
+    alpha = texture2D(u_textures[Index1], v_texcoord.xy).a;
+  else if (textureIndex == Index2)
+    alpha = texture2D(u_textures[Index2], v_texcoord.xy).a;
+  else if (textureIndex == Index3)
+    alpha = texture2D(u_textures[Index3], v_texcoord.xy).a;
+  else if (textureIndex == Index4)
+    alpha = texture2D(u_textures[Index4], v_texcoord.xy).a;
+  else if (textureIndex == Index5)
+    alpha = texture2D(u_textures[Index5], v_texcoord.xy).a;
+  else if (textureIndex == Index6)
+    alpha = texture2D(u_textures[Index6], v_texcoord.xy).a;
+  else if (textureIndex == Index7)
+    alpha = texture2D(u_textures[Index7], v_texcoord.xy).a;
+
+  float needOutline = (fract(v_texcoord.z / 2.0)) * 2.0;
+  if (needOutline > 0.5)
+    gl_FragColor = colorize(vec4(v_color.rgb, v_color.a*alpha));
+  else
+    gl_FragColor = without_outline(vec4(v_color.rgb, v_color.a*alpha));
+}                    

drape/shaders/path_font_vertex_shader.vsh

@@ -0,0 +1,20 @@
+attribute vec2 a_position;
+attribute vec4 a_texcoord;
+attribute vec4 a_color;
+attribute vec4 a_outline_color;
+
+uniform highp mat4 modelView;
+uniform highp mat4 projection;
+
+varying vec3 v_texcoord;
+varying vec4 v_color;
+varying vec4 v_outline_color;
+
+void main()
+{
+  gl_Position = vec4(a_position, a_texcoord.w, 1) * modelView * projection;
+    
+  v_texcoord = a_texcoord.xyz;
+  v_color = a_color;
+  v_outline_color = a_outline_color;
+}

drape_frontend/path_text_shape.cpp

@@ -0,0 +1,229 @@
+#include "path_text_shape.hpp"
+
+#include "../drape/shader_def.hpp"
+#include "../drape/attribute_provider.hpp"
+#include "../drape/glstate.hpp"
+#include "../drape/batcher.hpp"
+#include "../drape/texture_set_holder.hpp"
+
+#include "../base/math.hpp"
+#include "../base/logging.hpp"
+#include "../base/stl_add.hpp"
+#include "../base/string_utils.hpp"
+
+#include "../std/algorithm.hpp"
+#include "../std/vector.hpp"
+
+namespace df
+{
+
+using m2::PointF;
+
+namespace
+{
+  static float const realFontSize = 20.0f;
+  float angelFromDir(float x, float y)
+  {
+    float gip = sqrtf(x*x + y*y);
+    float cosa = x / gip;
+    if(y > 0)
+      return acosf(cosa) * 180.0f / M_PI;
+    else
+      return 360.0f - acosf(cosa) * 180.0f / M_PI;
+  }
+}
+
+PathTextShape::PathTextShape(vector<PointF> const & path, TextViewParams const & params):
+  m_params(params)
+{
+  m_path.FromArray(path);
+}
+
+void PathTextShape::Load(RefPointer<Batcher> batcher, RefPointer<TextureSetHolder> textures) const
+{
+  float scale = 1.0f;
+
+  strings::UniString const text = strings::MakeUniString(m_params.m_primaryText);
+  float const fontSize = m_params.m_primaryTextFont.m_size;
+
+  // Fill buffers
+  int cnt = text.size();
+  float *uvs=new float[cnt*12];
+  float *dirs=new float[cnt*12];
+  float *colors=new float[cnt*24];
+  for(int i=0;i<cnt*24;i++)
+  {
+    colors[i++]=0.0f;
+    colors[i++]=0.0f;
+    colors[i++]=0.0f;
+    colors[i]=1.0f;
+  }
+
+  Spline::iterator itr;
+  itr.Attach(m_path);
+  itr.Step(0.0f);
+
+  int textureSet;
+  for (int i = 0 ; i < cnt ; i++)
+  {
+    TextureSetHolder::GlyphRegion region;
+    textures->GetGlyphRegion(text[i], region);
+    float xOffset, yOffset, advance;
+    region.GetMetrics(xOffset, yOffset, advance);
+    float const aspect = fontSize / realFontSize;
+    advance *= aspect;
+
+    textureSet = region.GetTextureNode().m_textureSet;
+    m2::RectF const rect = region.GetTexRect();
+    m2::PointU pixelSize;
+    region.GetPixelSize(pixelSize);
+//    float const h = pixelSize.y * aspect;
+//    float const w = pixelSize.x * aspect;
+    yOffset *= aspect;
+    xOffset *= aspect;
+
+    float uv_x = rect.minX();
+    float uv_y = rect.minY();
+    float h = rect.maxX() - rect.minX();
+    float w = rect.maxY() - rect.minY();
+    uvs[12*i+0]=uv_x;
+    uvs[12*i+1]=uv_y;
+    uvs[12*i+2]=uv_x;
+    uvs[12*i+3]=(uv_y+h);
+    uvs[12*i+4]=uv_x+w;
+    uvs[12*i+5]=uv_y;
+
+    uvs[12*i+6]=uv_x+w;
+    uvs[12*i+7]=(uv_y+h);
+    uvs[12*i+8]=uv_x+w;
+    uvs[12*i+9]=uv_y;
+    uvs[12*i+10]=uv_x;
+    uvs[12*i+11]=(uv_y+h);
+
+    PointF pos = itr.pos;
+    PointF old_dir = itr.dir;
+
+    int index1 = itr.index;
+    itr.Step(advance / scale);
+    int index2 = itr.index;
+    PointF dir;
+    if(index1 != index2)
+    {
+      PointF new_dir = itr.dir;
+      PointF new_pos = m_path.position[index2];
+      float smooth_factor = (new_pos - itr.pos).Length()/(advance / scale);
+      dir = old_dir * (1.0f - smooth_factor) + new_dir * smooth_factor;
+    }
+    else
+    {
+      dir = old_dir;
+    }
+
+    float angle = angelFromDir(dir.x, dir.y) * M_PI / 180.0f;
+
+    float cosa = cosf(angle);
+    float sina = sinf(angle);
+    float half_width = pixelSize.x * aspect / 2.0f;
+    float half_height = pixelSize.y * aspect / 2.0f;
+
+    float x1 = half_width * cosa - half_height * sina;
+    float y1 = half_width * sina + half_height * cosa;
+
+    float x2 = -half_width * cosa - half_height * sina;
+    float y2 = -half_width * sina + half_height * cosa;
+
+    float x3 = -x1;
+    float y3 = -y1;
+
+    float x4 = -x2;
+    float y4 = -y2;
+
+    x1 /= scale;
+    x2 /= scale;
+    x3 /= scale;
+    x4 /= scale;
+
+    y1 /= scale;
+    y2 /= scale;
+    y3 /= scale;
+    y4 /= scale;
+
+    x1 += pos.x;
+    x2 += pos.x;
+    x3 += pos.x;
+    x4 += pos.x;
+
+    y1 += pos.y;
+    y2 += pos.y;
+    y3 += pos.y;
+    y4 += pos.y;
+
+    dirs[12*i+0] = x2;
+    dirs[12*i+1] = y2;
+    dirs[12*i+2] = x3;
+    dirs[12*i+3] = y3;
+    dirs[12*i+4] = x1;
+    dirs[12*i+5] = y1;
+
+    dirs[12*i+6] = x4;
+    dirs[12*i+7] = y4;
+    dirs[12*i+8] = x1;
+    dirs[12*i+9] = y1;
+    dirs[12*i+10] = x3;
+    dirs[12*i+11] = y3;
+  }
+
+  GLState state(gpu::PATH_FONT_PROGRAM, GLState::OverlayLayer);
+  state.SetTextureSet(textureSet);
+  state.SetBlending(Blending(true));
+
+  AttributeProvider provider(3, 6*cnt);
+  {
+    BindingInfo position(1);
+    BindingDecl & decl = position.GetBindingDecl(0);
+    decl.m_attributeName = "a_position";
+    decl.m_componentCount = 2;
+    decl.m_componentType = gl_const::GLFloatType;
+    decl.m_offset = 0;
+    decl.m_stride = 0;
+    provider.InitStream(0, position, MakeStackRefPointer(dirs));
+  }
+  {
+    BindingInfo texcoord(1);
+    BindingDecl & decl = texcoord.GetBindingDecl(0);
+    decl.m_attributeName = "a_texcoord";
+    decl.m_componentCount = 2;
+    decl.m_componentType = gl_const::GLFloatType;
+    decl.m_offset = 0;
+    decl.m_stride = 0;
+    provider.InitStream(1, texcoord, MakeStackRefPointer(uvs));
+  }
+  {
+    BindingInfo base_color(1);
+    BindingDecl & decl = base_color.GetBindingDecl(0);
+    decl.m_attributeName = "a_color";
+    decl.m_componentCount = 4;
+    decl.m_componentType = gl_const::GLFloatType;
+    decl.m_offset = 0;
+    decl.m_stride = 0;
+    provider.InitStream(2, base_color, MakeStackRefPointer(colors));
+  }
+
+  batcher->InsertTriangleList(state, MakeStackRefPointer(&provider));
+
+  delete [] uvs;
+  delete [] dirs;
+  delete [] colors;
+}
+
+void PathTextShape::update(RefPointer<Batcher> batcher, RefPointer<TextureSetHolder> textures) const
+{
+
+}
+
+void PathTextShape::Draw(RefPointer<Batcher> batcher, RefPointer<TextureSetHolder> textures) const
+{
+  Load(batcher, textures);
+}
+
+}

drape_frontend/path_text_shape.hpp

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "map_shape.hpp"
+#include "shape_view_params.hpp"
+
+#include "../std/vector.hpp"
+
+#include "../geometry/point2d.hpp"
+
+namespace df
+{
+
+using m2::PointF;
+
+class Spline
+{
+public:
+  float length_all;
+  vector<PointF> position;
+  vector<PointF> direction;
+  vector<float> length;
+  int amount_ind;
+
+public:
+  Spline(){}
+
+  void FromArray(vector<PointF> const & path)
+  {
+    position = vector<PointF>(path.begin(), path.end() - 1);
+    int cnt = position.size();
+    direction = vector<PointF>(cnt);
+    length = vector<float>(cnt);
+
+    for(int i = 0; i < cnt; ++i)
+    {
+      direction[i] = path[i+1] - path[i];
+      length[i] = direction[i].Length();
+      direction[i] = direction[i].Normalize();
+      length_all += length[i];
+    }
+  }
+
+  class iterator
+  {
+  private:
+    Spline const * spl;
+    float dist;
+  public:
+    int index;
+    PointF pos;
+    PointF dir;
+    iterator(){}
+    void Attach(Spline const & S)
+    {
+      spl = &S;
+      index = 0;
+      dist = 0;
+      dir = spl->direction[index];
+      pos = spl->position[index] + dir * dist;
+    }
+    void Step(float speed)
+    {
+      dist += speed;
+      while(dist > spl->length[index])
+      {
+        dist -= spl->length[index];
+        index++;
+        index %= spl->amount_ind;
+      }
+      dir = spl->direction[index];
+      pos = spl->position[index] + dir * dist;
+    }
+  };
+};
+
+class PathTextShape : public MapShape
+{
+public:
+  PathTextShape(vector<PointF> const & path, TextViewParams const & params);
+  virtual void Draw(RefPointer<Batcher> batcher, RefPointer<TextureSetHolder> textures) const;
+
+  void Load(RefPointer<Batcher> batcher, RefPointer<TextureSetHolder> textures) const;
+  void update(RefPointer<Batcher> batcher, RefPointer<TextureSetHolder> textures) const;
+
+private:
+  TextViewParams m_params;
+  Spline m_path;
+};
+
+} // namespace df