+//! IS_SHRINKED   display shrunk triangulation of surface.
...
+Aspect_IS_SHRUNK,

--- a/src/OpenGl/OpenGl_Text.cxx
+++ b/src/OpenGl/OpenGl_Text.cxx
+  OpenGl_AspectFace anAspect;
+  anAspect.Aspect()->SetAlphaMode(Graphic3d_AlphaMode_Opaque);
   theCtx->ShaderManager()->BindFaceProgram (Handle(OpenGl_TextureSet)(), Graphic3d_TOSM_UNLIT,
-                                            Graphic3d_AlphaMode_Opaque, Standard_False, Standard_False,
+                                            anAspect.Aspect(), Standard_False, Standard_False,

--- a/src/Graphic3d/Graphic3d_AspectFillArea3d.hxx
+++ b/src/Graphic3d/Graphic3d_AspectFillArea3d.hxx
   Aspect_TypeOfLine            myEdgeType;
   Standard_ShortReal           myEdgeWidth;
   Handle(Graphic3d_HatchStyle) myHatchStyle;
+  Standard_Integer             myWireframeWidth;

-    Standard_Integer aBits = getProgramBits (theTextures, theAlphaMode, theHasVertColor, false);
+    Standard_Integer aBits = getProgramBits(theTextures, theAlphaMode, theHasVertColor, false);

-                                   Graphic3d_AlphaMode theAlphaMode,
+                                   const Graphic3d_AlphaMode theAlphaMode,

+    switch (theAspect->InteriorStyle())
+    {
+    case Aspect_IS_HOLLOW:

+  Standard_Boolean BindFaceProgram (const Handle(OpenGl_TextureSet)&          theTextures,
+    myWireframeWidth = theAspect->WireframeWidth();
+    myWireframeColor = theAspect->EdgeColor();

+    theProgram->SetUniform(myContext, aLocViewPort, aViewport);
+  }
+  
+  const GLint aLocLineWidth = theProgram->GetUniformLocation(myContext, "occLineWidth");

+  const GLint aLocViewPort = theProgram->GetUniformLocation(myContext, "occViewport");
+  const GLint aLocLineWidth = theProgram->GetUniformLocation(myContext, "occLineWidth");
+  const GLint aLocWireframeColor = theProgram->GetUniformLocation(myContext, "occWireframeColor");

occLineWidth

+        EOL"THE_SHADER_IN  vec4 VertColorVS[];"
+        EOL"THE_SHADER_OUT vec4 VertColorFS;" : "")

+  const Standard_Boolean  isUseGeomShader  = theBits & OpenGl_PO_HollowMode || 
+                                             theBits & OpenGl_PO_ShrinkMode || 
+                                             theBits & OpenGl_PO_SolidWFMode;

-    aSrcVertExtraOut  += EOL"THE_SHADER_OUT vec4 VertColor;";
-    aSrcVertExtraMain += EOL"  VertColor = occVertColor;";
-    aSrcFragExtraOut  += EOL"THE_SHADER_IN  vec4 VertColor;";
-    aSrcFragGetColor  =  EOL"vec4 getColor(void) { return VertColor; }";
+    if (isUseGeomShader)
+    {
+      aSrcVertExtraOut  += EOL"THE_SHADER_OUT vec4 VertColorVS;";
+      aSrcVertExtraMain += EOL"  VertColorVS = occVertColor;";
+      aSrcFragExtraOut  += EOL"THE_SHADER_IN  vec4 VertColorFS;";
+      aSrcFragGetColor   = EOL"vec4 getColor(void) { return VertColorFS; }";
+    }
+    else
+    {
+      aSrcVertExtraOut  += EOL"THE_SHADER_OUT vec4 VertColor;";
+      aSrcVertExtraMain += EOL"  VertColor = occVertColor;";
+      aSrcFragExtraOut  += EOL"THE_SHADER_IN  vec4 VertColor;";
+      aSrcFragGetColor   = EOL"vec4 getColor(void) { return VertColor; }";
+    }

+  const Standard_Boolean isUseGeomShader = theBits & OpenGl_PO_HollowMode ||
+                                           theBits & OpenGl_PO_ShrinkMode ||
+                                           theBits & OpenGl_PO_SolidWFMode;

out VertexData
{
  vec4 VertColor;
};
void main()
{
  VertColor = occColor;
  gl_Position = occVertex;
}

layout(triangles) in;
layout(triangle_strip, max_vertices=3) out;
in VertexData
{
  vec4 VertColor;
} geomIn[3];

out VertexData
{
  vec4 VertColor;
} geomOut;
void main()
{
  mat4 aMat = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix;
  for (int aTriVertIter = 0; aTriVertIter < 3; ++aTriVertIter)
  {
    gl_Position = aMat * gl_in[aTriVertIter].gl_Position;
    geomOut.VertColor = geomIn[aTriVertIter].VertColor;
    EmitVertex();
  }
  EndPrimitive();
}

in VertexData
{
  vec4 VertColor;
};
void main()
{
  occFragColor = VertColor;
}

+  void SetScaleFactor (const Standard_Real theScaleFactor)
+  {
+    myScaleFactor = (float)theScaleFactor;
+  }

+  //! Returns true if advanced shading is on (true by default).
+  Standard_Boolean IsAdvancedShading() const { return myIsAdvancedShading; }

+  //! Returns true if quad presentation is on (false by default).
+  bool IsQuadMode() const { return myIsQuadMode; }

   bool                    myToMapTexture;
+  Standard_ShortReal      myScaleFactor;
+  Standard_Boolean        myIsQuadMode;

-  Graphic3d_TypeOfLimit_NB                              //!< number of elements in this enumeration
+  Graphic3d_TypeOfLimit_NB,                             //!< number of elements in this enumeration
+  Graphic3d_TypeOfLimit_HasShrunkPrs                    //!< indicates whether shrunk presentation is supported

--- a/src/OpenGl/OpenGl_Context.hxx
+++ b/src/OpenGl/OpenGl_Context.hxx
@@ -784,6 +784,9 @@ public: //! @name methods to alter or retrieve current state
     myLineWidthScale  = Max (1.0f, std::floor (theRatio + 0.5f));
   }
 
+  //! Return scale factor for line width.
+  Standard_ShortReal LineWidthScale() const { return myLineWidthScale; }

+    case Graphic3d_TypeOfLimit_HasShrunkPrs:
+      return aCtx->IsGlGreaterEqual (3, 2);

+  OpenGl_PO_PixelShrinkMode = 0x2000,  //!< pixel shrunk triangulation display mode
+  OpenGl_PO_SolidWFMode     = 0x4000,  //!< solid wireframe display mode
+  OpenGl_PO_HiddenLine      = 0x8000,  //!< removed hidden lines display mode
+  OpenGl_PO_ScaleShrinkMode = 0x10000, //!< scalability shrunk triangulation display mode

+// =======================================================================
+// function : prepareEdgeDistString
+// purpose  : Auxiliary function for prepareGeomSrc function
+// =======================================================================
+TCollection_AsciiString prepareEdgeDistString (const Standard_Integer& theTriVertIter)

+// =======================================================================
+// function : prepareGeomSrc
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_ShaderManager::prepareGeomMainSrc (const OpenGl_ShaderVarList& theVarList,

+          EOL"    for (int aTriVertIter = 0; aTriVertIter < 3; ++aTriVertIter)"
+          EOL"    {"
+          EOL"      aCenter += gl_in[aTriVertIter].gl_Position.xyz;"
+          EOL"    }"
+          EOL"    aCenter /= 3.0;"

+  TCollection_AsciiString aSrcMainGeom = TCollection_AsciiString()
+    + ((theBits & OpenGl_PO_ScaleShrinkMode) != 0
+        ? EOL"void main()"

+          EOL"  vec3 aWinCoord = theVec.xyz / theVec.w;"
+          EOL"  aWinCoord   = aWinCoord * 0.5 + 0.5;"
+          EOL"  aWinCoord.x = aWinCoord.x * occViewport[0] + occViewport[2];"
+          EOL"  aWinCoord.y = aWinCoord.y * occViewport[1] + occViewport[3];"
+          EOL"  return aWinCoord;"

+  const Standard_Boolean  toUseGeomShader  = myContext->IsGlGreaterEqual(3, 2) && (theBits & OpenGl_PO_AdvShading) != 0;

+        EOL"  Normal = normalize (cross (dFdx (Position.xyz / Position.w), dFdy (Position.xyz / Position.w)));"//;

+//! List of variable of shader program.
+typedef NCollection_Vector<TCollection_AsciiString> OpenGl_ShaderVarList;

+    if (myContext->SampleAlphaToCoverage())
+    {
+      theBits |= OpenGl_PO_MSAA;

+  Standard_EXPORT void SetAspects (const Standard_ShortReal& theWireframeWidth,
+                                   const OpenGl_Vec3&        theWireframeColor,
+                                   const Standard_ShortReal& theScaleFactor,

+  Standard_EXPORT void SetViewport (const OpenGl_Vec4& theViewport) { myViewport = theViewport; }
+  Standard_EXPORT Standard_ShortReal WireframeWidth() const { return myWireframeWidth; }
+  Standard_EXPORT const OpenGl_Vec3& WireframeColor() const { return myWireframeColor; }
...
>> other places <<

+  Standard_ShortReal myWireframeWidth; //!< wireframe width
+  OpenGl_Vec3        myWireframeColor; //!< wireframe color
+  OpenGl_Vec4        myViewport;       //!< viewport properties
+  Standard_ShortReal myScaleFactor;    //!< scale factor for shrunk presentation

+  aManager->SetWireframeViewportState (OpenGl_Vec4 ((float)aContext->Viewport()[2], 
+                                                    (float)aContext->Viewport()[3],
+                                                    (float)aContext->Viewport()[0], 
+                                                    (float)aContext->Viewport()[1]));

+      if (aValue == "on"
+       || aValue == "1")
+      {
+        aChangeSet->ToSetAdvancedShading = 1;
+      }
+      else if (aValue == "off"
+            || aValue == "0")

+      + ((theBits & OpenGl_PO_MSAA) != 0 ? EOL"  occSetFragColor (vec4 (aEdgeColor, 1 - aMixVal));"

+                                           EOL"  if (aMixColor.a == 0.0) discard;"
+                                           EOL"  else occSetFragColor (aMixColor);");

+void OpenGl_ShaderManager::prepareShadersOutSrc()

Hollow, Hidden Line, Shrinks and Solid Wireframe interior styles are drawing by shader program with geometry shader.