Some drawing improvements on 3d viewport (WIP)

la_tns.h

@@ -30,6 +30,8 @@ extern const char* TNS_VERTEX_SIMPLE_MATCAP;
 extern const char* TNS_FRAGMENT_SIMPLE_MATCAP;
 extern const char* TNS_VERTEX_GRID;
 extern const char* TNS_FRAGMENT_TRANSPARNT_GRID;
+extern const char* LA_FLOOR_VERTEX_SHADER;
+extern const char* LA_FLOOR_FRAGMENT_SHADER;
 extern const char* LA_IMM_VERTEX_SHADER;
 extern const char* LA_IMM_FRAGMENT_SHADER;
 extern const char* LA_RAY_VERTEX_SHADER;
@@ -102,6 +104,7 @@ struct _tnsShader{
     int iTextureMode, StateTextureMode, iColorMode,iHCYGamma;
     int iSampleAmount, StateSampleAmount;
     int iInputColorSpace, iOutputColorSpace, iShowStripes;
+    int iDoOffset;
 
     int uViewDir,uViewPos,uFOV;
 };
@@ -210,6 +213,7 @@ struct _tnsMain {
     tnsShader* ShadowShader;
     tnsShader* SceneShader;
     tnsShader* SelectionShader;
+    tnsShader* FloorShader;
 
     int GlobalVAO;
 
@@ -1246,6 +1250,8 @@ int tnsGetTextureMemoryComponetCount(tnsTexture *t);
 
 void tnsUseNormal(int Use);
 
+void tnsUniformUseOffset(tnsShader* s, int use);
+
 tnsImage* tnsNewImage(void* MemPNG);
 void tnsUseImage(tnsImage* im);
 void tnsStopUsingImage(tnsImage* im);
@@ -1258,7 +1264,7 @@ void tnsConfigure2DTexture(tnsTexture *t);
 void tnsConfigure3DTexture(tnsTexture *t);
 void tnsReconfigureTextureParameters(int Multisample);
 tnsOffscreen *tnsCreate2DOffscreen(int glInternalFormat, int w, int h, int Multisample, int WithDepth, int WithStencil);
-tnsOffscreen *tnsCreateDeferredOffscreen(int w, int h);
+tnsOffscreen *tnsCreateDeferredOffscreen(int w, int h, int Multisample);
 void tnsCopyScreenTo2DTexture(tnsTexture *target, int x_lower_left, int y_lower_left, int w, int h);
 void tnsActiveTexture(GLenum tex);
 void tnsBindTexture(tnsTexture *t);

la_tns_kernel.c

@@ -268,6 +268,7 @@ void tnsShaderMakeIndex(tnsShader *tns){
     tns->iShowStripes=glGetUniformLocation(program, "ShowStripes");
     if(tns->iTexColor>=0){glUniform1i(tns->iTexColor, 0);}
     if(tns->iTexColorMS>=0){glUniform1i(tns->iTexColorMS, 1);}
+    tns->iDoOffset = glGetUniformLocation(program, "DoOffset");
 
     tns->uViewDir = glGetUniformLocation(program, "uViewDir");
     tns->uViewPos = glGetUniformLocation(program, "uViewPos");
@@ -1336,6 +1337,10 @@ void tnsInitBuiltinShaders(){
         tnsNewVertexShader(LA_SELECTION_VERTEX_SHADER),
         tnsNewFragmentShader(LA_SELECTION_FRAGMENT_SHADER), -1);
 
+    T->FloorShader = tnsNewShaderProgram(
+        tnsNewVertexShader(LA_FLOOR_VERTEX_SHADER),
+        tnsNewFragmentShader(LA_FLOOR_FRAGMENT_SHADER), -1);
+
     tnsUseShader(T->immShader);
     tnsEnableShaderv(T->immShader);
 }
@@ -1736,6 +1741,10 @@ void tnsCopyScreenTo2DTexture(tnsTexture *target, int x_lower_left, int y_lower_
     tnsUnbindTexture();
 }
 
+void tnsUniformUseOffset(tnsShader* s, int use){
+    glUniform1i(s->iDoOffset,use);
+}
+
 void tnsUseMaskTexture(tnsTexture *t){
     if(!t){T->StateTextureMode=0; return;}
     T->StateTexColor = t; T->StateTextureMode=1;
@@ -2479,15 +2488,15 @@ tnsOffscreen *tnsCreate2DOffscreen(int glInternalFormat, int w, int h, int Multi
 
     return toff;
 }
-tnsOffscreen *tnsCreateDeferredOffscreen(int w, int h){
+tnsOffscreen *tnsCreateDeferredOffscreen(int w, int h, int Multisample){
     tnsOffscreen *toff = tnsCreateOffscreenHandle();
     tnsTexture *color,*normal,*gpos; tnsTexture *depth;
 
-    color  = tnsCreate2DTexture(GL_RGBA8, w, h, 0);  tnsAttach2DOffscreenBuffer(toff, GL_COLOR_ATTACHMENT0, color);
-    normal = tnsCreate2DTexture(GL_RGB8, w, h, 0);   tnsAttach2DOffscreenBuffer(toff, GL_COLOR_ATTACHMENT1, normal);
-    gpos   = tnsCreate2DTexture(GL_RGB32F, w, h, 0); tnsAttach2DOffscreenBuffer(toff, GL_COLOR_ATTACHMENT2, gpos);
+    color  = tnsCreate2DTexture(GL_RGBA8, w, h, Multisample);  tnsAttach2DOffscreenBuffer(toff, GL_COLOR_ATTACHMENT0, color);
+    normal = tnsCreate2DTexture(GL_RGB8, w, h, Multisample);   tnsAttach2DOffscreenBuffer(toff, GL_COLOR_ATTACHMENT1, normal);
+    gpos   = tnsCreate2DTexture(GL_RGB32F, w, h, Multisample); tnsAttach2DOffscreenBuffer(toff, GL_COLOR_ATTACHMENT2, gpos);
 
-    depth = tnsCreate2DTexture(GL_DEPTH_COMPONENT, w, h, 0); tnsAttach2DOffscreenBuffer(toff, GL_DEPTH_ATTACHMENT, depth);
+    depth = tnsCreate2DTexture(GL_DEPTH_COMPONENT, w, h, Multisample); tnsAttach2DOffscreenBuffer(toff, GL_DEPTH_ATTACHMENT, depth);
 
     return toff;
 }
@@ -4361,19 +4370,36 @@ void tnsDrawFloor(int Size, int Span, int *ShowAxis){
     int Lim = Span * 2 + 1;
     int Dist = Size * Span;
 
-    for (i; i < Lim; i++){
-        if (i == Span && ShowAxis[0]) continue;
-        tnsVertex3d(-Dist, i * Size - Dist, 0);
-        tnsVertex3d(Dist, i * Size - Dist, 0);
-    }
+    tnsFlush();
 
-    for (i = 0; i < Lim; i++){
-        if (i == Span && ShowAxis[1]) continue;
-        tnsVertex3d(i * Size - Dist, -Dist, 0);
-        tnsVertex3d(i * Size - Dist, Dist, 0);
-    }
+    glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(1,1); glEnable(GL_BLEND);
+    tnsUseShader(T->FloorShader);
+    tnsEnableShaderv(T->FloorShader);
 
-    tnsPackAs(GL_LINES);
+    tnsVertex3d(-10000,10000,0);
+    tnsVertex3d(10000,10000,0);
+    tnsVertex3d(10000,-10000,0);
+    tnsVertex3d(-10000,-10000,0);
+    tnsPackAs(GL_TRIANGLE_FAN);
+    tnsFlush();
+
+    tnsUseShader(T->immShader);
+    tnsEnableShaderv(T->immShader);
+    glDisable(GL_POLYGON_OFFSET_FILL);
+
+    //for (i; i < Lim; i++){
+    //    if (i == Span && ShowAxis[0]) continue;
+    //    tnsVertex3d(-Dist, i * Size - Dist, 0);
+    //    tnsVertex3d(Dist, i * Size - Dist, 0);
+    //}
+//
+    //for (i = 0; i < Lim; i++){
+    //    if (i == Span && ShowAxis[1]) continue;
+    //    tnsVertex3d(i * Size - Dist, -Dist, 0);
+    //    tnsVertex3d(i * Size - Dist, Dist, 0);
+    //}
+
+    //tnsPackAs(GL_LINES);
 
     if (ShowAxis[0]){
         tnsColor4d(1, 0, 0, 1);

la_tns_mesh.c

@@ -289,11 +289,13 @@ void tnsDrawMeshObject(tnsMeshObject* mo, int DrawAsObjectSelection, int MeshSel
             tnsDrawBatch(mo->Batch,"body",0,0);
             tnsUseNormal(0);
             if(mo->Mode==TNS_MESH_EDIT_MODE){
+                tnsUniformUseOffset(T->immShader,1);
                 if(MeshSelectionMode==LA_CANVAS_SELECT_MODE_VERTS){
                     tnsDrawBatch(mo->Batch,"verts",0,0); tnsDrawBatch(mo->Batch,"lines",0,0);
                 }else{
                     tnsDrawBatch(mo->Batch,"edges",0,0);
                 }
+                tnsUniformUseOffset(T->immShader,0);
             }
         }
     }

resources/la_modelling.c

@@ -31,7 +31,7 @@ int OPINV_SetCursor(laOperator *a, laEvent *e){
     laCanvasExtra* ex=a->This->EndInstance; tnsCamera*c=ex->ViewingCamera; laUiItem* ui=ex->ParentUi;
     tnsObject*root=ui?ui->PP.EndInstance:0; if(!root || root->Type!=TNS_OBJECT_ROOT) return 0;
 
-    float pos[4]; la_ReadGLocation(ex->DeferredOffScr, e->x-ui->L,ui->B-e->y,pos);
+    float pos[4]; la_ReadGLocation(ex->OffScr, e->x-ui->L,ui->B-e->y,pos);
     if(pos[0]>-1e20){
         tnsVectorSet3v(root->GLocation,pos); laNotifyUsers("tns.world"); return LA_FINISHED_PASS;
     }else

resources/la_properties.c

@@ -110,13 +110,13 @@ void laset_ThemePaddings(laBoxedTheme* bt, int index, int val){
 void laset_ThemeWireTransparency(laTheme* t, real val){ t->WireTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
 void laset_ThemeWireBrightness(laTheme* t, real val){ t->WireBrightness = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
 void laset_ThemeWireSaturation(laTheme* t, real val){ t->WireSaturation = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
-void laset_ThemeEdgeTransparency(laTheme* t, real val){ t->EdgeTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
-void laset_ThemeEdgeBrightness(laTheme* t, real val){ t->EdgeBrightness = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
-void laset_ThemeVertexTransparency(laTheme* t, real val){ t->VertexTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
-void laset_ThemeVertexBrightness(laTheme* t, real val){ t->VertexBrightness = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
-void laset_ThemeSVertexTransparency(laTheme* t, real val){ t->SelectedVertexTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
-void laset_ThemeSEdgeTransparency(laTheme* t, real val){ t->SelectedEdgeTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
-void laset_ThemeSFaceTransparency(laTheme* t, real val){ t->SelectedFaceTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
+void laset_ThemeEdgeTransparency(laTheme* t, real val){ t->EdgeTransparency = val; la_RefreshThemeColorSelf(t); laRedrawAllWindows(); }
+void laset_ThemeEdgeBrightness(laTheme* t, real val){ t->EdgeBrightness = val; la_RefreshThemeColorSelf(t); laRedrawAllWindows(); }
+void laset_ThemeVertexTransparency(laTheme* t, real val){ t->VertexTransparency = val; la_RefreshThemeColorSelf(t); laRedrawAllWindows(); }
+void laset_ThemeVertexBrightness(laTheme* t, real val){ t->VertexBrightness = val; la_RefreshThemeColorSelf(t); laRedrawAllWindows(); }
+void laset_ThemeSVertexTransparency(laTheme* t, real val){ t->SelectedVertexTransparency = val; la_RefreshThemeColorSelf(t); laRedrawAllWindows(); }
+void laset_ThemeSEdgeTransparency(laTheme* t, real val){ t->SelectedEdgeTransparency = val; la_RefreshThemeColorSelf(t); laRedrawAllWindows(); }
+void laset_ThemeSFaceTransparency(laTheme* t, real val){ t->SelectedFaceTransparency = val; la_RefreshThemeColorSelf(t); laRedrawAllWindows(); }
 
 void laset_WireColorSlices(void* unused, int val){ MAIN.WireColorSlices = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
 void laset_WireThickness(void* unused, real val){ MAIN.WireThickness = val;laRedrawAllWindows(); }
@@ -1517,7 +1517,7 @@ void la_RegisterInternalProps(){
         laAddFloatProperty(p, "depth_range", "Depth Range", "Depth Range To Map From 0 To 1", 0,"Near,Far", 0,0,0,0.1, 0,0,offsetof(tnsCamera, ZMin), 0,0,2, 0,0,0,0,0,0,0,0);
         laAddFloatProperty(p, "focus_distance", "Focus Distance", "For Viewing Camera To Determin Zooming Center", 0,0,0,0,0,0.1, 100,0,offsetof(tnsCamera, FocusDistance), 0,0,0,0,0,0,0,0,0,0,0);
         laAddFloatProperty(p, "orth_scale", "Scale", "Orthographical Camera Scale", 0,0,"^^", 1000,0.001, 0.1, 1, 0,offsetof(tnsCamera, OrthScale), 0,0,0,0,0,0,0,0,0,0,0);
-        laAddOperatorProperty(p, "set_active", "Set Active", "Set this camera as the active one", "TNS_set_active_camera", 0,0);
+        //laAddOperatorProperty(p, "set_active", "Set Active", "Set this camera as the active one", "TNS_set_active_camera", 0,0);
     }
     p = laAddPropertyContainer("tns_light", "Light", "Light object", U'🔅', 0,sizeof(tnsLight), 0,0,2);{
         //laPropContainerExtraFunctions(p,0,0,0,tnspropagate_Object,0);

resources/la_tns_shaders.cpp

@@ -592,23 +592,26 @@ void main(){
 })";
 
 extern "C" const char* LA_IMM_VERTEX_SHADER = R"(#version 330
-uniform mat4 mProjection;\
-uniform mat4 mModel;\
-uniform mat4 mView;\
-in vec4 vVertex;\
-in vec4 vColor;\
-in vec3 vNormal;\
-in vec2 vUV;\
-out vec4 fColor;\
-out vec2 fUV;\
-flat out vec3 fNormal;\
-out vec3 fGPos;\
-void main(){\
-    gl_Position = mProjection * mView * mModel * vVertex;\
-    fColor = vColor;\
-    fUV=vUV;\
-    fGPos=vec3((mModel * vVertex).xyz);\
-    fNormal= (mModel * vec4(vNormal,0.)).xyz;\
+uniform mat4 mProjection;
+uniform mat4 mModel;
+uniform mat4 mView;
+uniform int DoOffset;
+in vec4 vVertex;
+in vec4 vColor;
+in vec3 vNormal;
+in vec2 vUV;
+out vec4 fColor;
+out vec2 fUV;
+flat out vec3 fNormal;
+out vec3 fGPos;
+void main(){
+	vec4 pos=mProjection * mView * mModel * vVertex;
+	if(DoOffset>0){ pos.xyw*=1.0001; }
+    gl_Position = pos;
+    fColor = vColor;
+    fUV=vUV;
+    fGPos=vec3((mModel * vVertex).xyz);
+    fNormal= normalize((mModel * vec4(vNormal,0.)).xyz);
 })";
 
 extern "C" const char* LA_IMM_FRAGMENT_SHADER = R"(#version 330
@@ -666,7 +669,7 @@ void main(){
     }else if(TextureMode==3){
         color=vec4(0,0,0,0);
         ivec2 texSize = textureSize(TexColorMS);
-        for(int i=0;i<SampleAmount;i++) color+=texelFetch(TexColorMS, ivec2(fUV * texSize),i);
+        for(int i=0;i<SampleAmount;i++){ vec4 res=texelFetch(TexColorMS, ivec2(fUV * texSize),i); if(res[0]>-1e19) color+=res; };
         color/=SampleAmount;
         if(MultiplyColor!=0){color*=fColor;}
     }
@@ -684,6 +687,29 @@ void main(){
     outGPos = fGPos;
 })";
 
+extern "C" const char* LA_FLOOR_VERTEX_SHADER = R"(#version 330
+uniform mat4 mProjection;
+uniform mat4 mModel;
+uniform mat4 mView;
+in vec4 vVertex;
+out vec3 fGPos;
+void main(){
+    gl_Position=mProjection * mView * mModel * vVertex;
+    fGPos=vec3((mModel * vVertex).xyz);
+})";
+
+extern "C" const char* LA_FLOOR_FRAGMENT_SHADER = R"(#version 330
+layout(location = 0) out vec4 outColor;
+in vec3 fGPos;
+float line(float center, float width,float s){
+	return smoothstep(center-width,center-width+1.e-1,s)-smoothstep(center+width-1.e-1,center+width,s);
+}
+void main(){
+	float s=sin(fGPos.x/10);
+	float v=line(0,0.1,s);
+	outColor=v*vec4(0.5,0.5,0.5,1);
+})";
+
 extern "C" const char* LA_RAY_VERTEX_SHADER = R"(#version 330
 in vec3 vUV;
 in vec4 vVertex;

resources/la_widgets_viewers.c

@@ -71,9 +71,9 @@ void la_RootObjectDraw(laBoxedTheme *bt, tnsObject *root, laUiItem* ui){
 
     if (!e->OffScr || e->OffScr->pColor[0]->Height != ui->B - ui->U || e->OffScr->pColor[0]->Width != ui->R - ui->L){
         if (e->OffScr) tnsDelete2DOffscreen(e->OffScr);
-        if (e->DeferredOffScr) tnsDelete2DOffscreen(e->DeferredOffScr);
-        e->OffScr = tnsCreate2DOffscreen(GL_RGBA, W, H, MAIN.PanelMultisample ,1, 0);
-        e->DeferredOffScr = tnsCreateDeferredOffscreen(W,H);
+        //if (e->DeferredOffScr) tnsDelete2DOffscreen(e->DeferredOffScr);
+        e->OffScr = tnsCreateDeferredOffscreen(W,H,MAIN.PanelMultisample);//tnsCreate2DOffscreen(GL_RGBA, W, H, MAIN.PanelMultisample ,1, 0);
+        //e->DeferredOffScr = tnsCreateDeferredOffscreen(W,H,MAIN.PanelMultisample);
     }
 
     if (0){//(e->CurrentScene && e->CurrentScene->ActiveSun){
@@ -141,7 +141,8 @@ void la_RootObjectDraw(laBoxedTheme *bt, tnsObject *root, laUiItem* ui){
     //    tnsClearAll();
     //}
 
-    tnsDrawToOffscreen(e->DeferredOffScr,3,TNS_ATTACHMENT_ARRAY_0_1_2);
+    tnsDrawToOffscreen(e->OffScr,3,TNS_ATTACHMENT_ARRAY_0_1_2);
+    //tnsDrawToOffscreen(e->DeferredOffScr,3,TNS_ATTACHMENT_ARRAY_0_1_2);
     tnsViewportWithScissor(0, 0, W, H);
     tnsClearColorv(laThemeColor(bt,LA_BT_NORMAL)); tnsClearAll(); float gpos_clear[]={-1e20, -1e20, -1e20, 0};
     glClearBufferfv(GL_COLOR, 2, gpos_clear);
@@ -152,16 +153,19 @@ void la_RootObjectDraw(laBoxedTheme *bt, tnsObject *root, laUiItem* ui){
 
     if(root){
         glEnable(GL_DEPTH_TEST); glDisable(GL_BLEND);
+
         tnsEnableShaderv(T->immShader);
         tnsUnbindTexture(); tnsUniformUseTexture(T->immShader,0,0); tnsUseMultiplyColor(0);
-        glPointSize(6); glLineWidth(3);
+        glPointSize(6); glLineWidth(3); 
         tnsDrawObjectTree(root, 0, 0, e->SelectMode);
-        glPointSize(1); glLineWidth(3);
+        glPointSize(1); glLineWidth(3); 
 
-        glDepthMask(GL_FALSE); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glEnable(GL_POLYGON_OFFSET_LINE); glEnable(GL_POLYGON_OFFSET_POINT); glPolygonOffset(1,1);
+        glEnable(GL_POLYGON_OFFSET_LINE); glPolygonOffset(-10,-10);
+        glDepthMask(GL_FALSE); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
         tnsDrawObjectTree(root, root->Active, 1, 0);
         glDepthMask(GL_TRUE); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
         glLineWidth(1);
+        glDisable(GL_POLYGON_OFFSET_LINE);
     }
 
     if (!e->LineDrawingMode && e->ShowFloorGrid){
@@ -190,9 +194,9 @@ void la_RootObjectDraw(laBoxedTheme *bt, tnsObject *root, laUiItem* ui){
 
     glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND);
 
-    tnsDrawToOffscreen(e->OffScr, 1,0);
-    tnsClearColorv(laThemeColor(bt,LA_BT_NORMAL)); tnsClearAll();
-    la_RootObjectDrawFullscreenQuad(e->DeferredOffScr, c, (real)W/(real)H);
+    //tnsDrawToOffscreen(e->OffScr, 1,0);
+    //tnsClearColorv(laThemeColor(bt,LA_BT_NORMAL)); tnsClearAll();
+    //la_RootObjectDrawFullscreenQuad(e->DeferredOffScr, c, (real)W/(real)H);
 }
 void la_RootObjectDrawOverlay(laUiItem *ui, int h){
     laCanvasExtra *e = ui->Extra;