shader string manipulator and etc

la_tns.h

@@ -88,6 +88,13 @@ struct _tnsMatrixStack
     int max_level;
 };
 
+typedef struct _tnsShaderComponent tnsShaderComponent;
+struct _tnsShaderComponent{
+    laListItem Item;
+    const char* name;
+    const char* replacement;
+};
+
 typedef struct _tnsShader tnsShader;
 struct _tnsShader{
     laListItem Item;
@@ -105,7 +112,7 @@ struct _tnsShader{
     int iUseNormal;
 
     int iTexColor,iTexColor2,iTexNormal,iTexGPos;
-    int iTexIsUI,iTex2IsUI;
+    int iTexIsUI,iTex2IsUI,iTexPremultiplied;
     int iTexColorMS,iTexColorU,iTexColor2U;
     int iMultiplyColor;
     int iTextureMode,iColorMode,iHCYGamma;
@@ -114,7 +121,7 @@ struct _tnsShader{
     int iComposing, iComposingGamma, iComposingBlackpoint;
     int iDoOffset;
     int iUseHalftone,iHalftoneSize;
-    int StateTextureMode,StateMultiplyColor,StateSampleAmount,StateTexIsUI,StateTex2IsUI;
+    int StateTextureMode,StateMultiplyColor,StateSampleAmount,StateTexIsUI,StateTex2IsUI,StatePremultiplied;
 
     int uViewDir,uViewPos,uFOV,uNear,uFar;
 };
@@ -152,6 +159,7 @@ STRUCTURE(tnsCommand){
     tnsTexture *ColorTexture2;
     int TextureMode;
     int MultiplyColor;
+    int Premultiply;
 
     GLfloat LineWidth,PointSize;
 };
@@ -244,6 +252,8 @@ struct _tnsMain {
     tnsShader *SobelShader;
     tnsShader *ExtraBuffersShader;
 
+    laListHandle ShaderComponents;
+
     laListHandle Textures;
     tnsTexture *PreviewTexture;
 
@@ -257,6 +267,7 @@ struct _tnsMain {
     // For commands
     tnsTexture *StateTexColor;
     tnsTexture *StateTexColor2;
+    int StatePremultiplied;
     int StateTextureMode;
     int StateMultiplyColor;
     int StateUseNormal;
@@ -942,12 +953,21 @@ STRUCTURE(tnsEdgeHash){
 
 void tnsSetuptnsFontManager();
 
-char* tnsEnsureShaderCommoms(const char* Content, const char* Library, const char* Material);
+void tnsAddShaderComponent(const char* name, const char* replacement);
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+char* tnsRegexReplace(char* in, char* pairs[]);
 tnsShader *tnsNewShaderProgram(int VertexShaderID, int FragmentShaderID, int GeometryShaderID);
 int tnsNewGeometryShader(const char *Content);
 int tnsNewFragmentShader(const char *Content);
 int tnsNewFragmentShaderMaterial(const char *Content, const char* Library, const char* Material);
 int tnsNewVertexShader(const char *Content);
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 void tnsDeleteShaderProgram(tnsShader* s);
 int tnsCheckShaderCompileStatus(GLuint shader_object, char* name);
 int tnsCheckProgramLinkStatus(GLuint program_object, char* name);
@@ -1410,7 +1430,7 @@ void tnsUnbindTexture2();
 void tnsUniformUseNormal(tnsShader* s, int Use);
 void tnsUniformUseHalftone(tnsShader* s, real Use);
 void tnsUniformHalftoneSize(tnsShader* s, real Use);
-void tnsUniformUseTexture(tnsShader* s, int mode, int sample, int TexIsUInt, int Tex2IsUInt);
+void tnsUniformUseTexture(tnsShader* s, int mode, int sample, int TexIsUInt, int Tex2IsUInt, int Premultiply);
 void tnsUniformColorMode(tnsShader *s, int mode);
 void tnsUniformHCYGamma(tnsShader* s, float Gamma);
 void tnsUniformInputColorSpace(tnsShader* s, int ColorSpace);
@@ -1420,7 +1440,7 @@ void tnsUniformColorComposing(tnsShader* s, int Composing, real gamma, real blac
 void tnsUniformUseMultiplyColor(tnsShader* s, int enable);
 void tnsUseMaskTexture(tnsTexture *t);
 void tnsUseTexture(tnsTexture *t);
-void tnsUseTexture2(tnsTexture* t, int mixmode);
+void tnsUseTexture2(tnsTexture* t, int mixmode, int premultiplied);
 void tnsUseNoTexture();
 void tnsUseMultiplyColor(int enable);
 void tnsDeleteTexture(tnsTexture *t);

la_tns_kernel.c

@@ -320,6 +320,11 @@ int tnsNextPowOf2(int i){
     return result;
 }
 
+void tnsAddShaderComponent(const char* name, const char* replacement){
+    tnsShaderComponent* sc=lstAppendPointerSized(&T->ShaderComponents,0,sizeof(tnsShaderComponent));
+    sc->name=name; sc->replacement=replacement;
+}
+
 void tnsShaderMakeIndex(tnsShader *tns){
     int program;
 
@@ -357,6 +362,7 @@ void tnsShaderMakeIndex(tnsShader *tns){
     tns->iInputColorSpace=glGetUniformLocation(program, "InputColorSpace");
     tns->iTexIsUI=glGetUniformLocation(program, "TexIsUI");
     tns->iTex2IsUI=glGetUniformLocation(program, "Tex2IsUI");
+    tns->iTexPremultiplied=glGetUniformLocation(program, "TexPremultiplied");
     tns->iUseLut=glGetUniformLocation(program, "UseLut");
     tns->iShowStripes=glGetUniformLocation(program, "ShowStripes");
     tns->iComposing=glGetUniformLocation(program, "Composing");
@@ -413,103 +419,6 @@ void tnsShaderApplyShadowMatrix(tnsShader *tns, tnsMatrix44d m){
     glUniformMatrix4fv(tns->iShadow, 1, 0, mf);
 }
 
-char* tnsEnsureShaderCommoms(const char* Content, const char* Library, const char* Material){
-    char* c=0,*c1=0;
-    c1=strSub(Content,"#with TNS_SHADER_COLOR_COMMON",TNS_SHADER_COLOR_COMMON);
-    c=strSub(c1,"#with LA_SHADER_LIB_FXAA",LA_SHADER_LIB_FXAA); free(c1);
-    c1=strSub(c,"#with TNS_SHADER_MATERIAL",Material?Material:""); free(c);
-    c=strSub(c1,"#with TNS_SHADER_LIBRARY",Library?Library:""); free(c1);
-#ifdef LA_USE_GLES
-    const char uint_texture_selection[] = "#define GLES_UINT_TEXTURE";
-#else
-    const char uint_texture_selection[] = "";
-#endif
-    c1=strSub(c,"#with TNS_GLES_UINT_TEXTURE",uint_texture_selection); free(c);
-    return c1;
-}
-int tnsCheckShaderCompileStatus(GLuint shader_object, char* name){
-    int status=0; char error[65536]={0};
-    glGetShaderiv(shader_object, GL_COMPILE_STATUS, &status);
-    if (status == GL_FALSE){
-        glGetShaderInfoLog(shader_object, sizeof(error), 0, error); logPrint("%s shader error:\n%s",name?name:"(unnamed)",error);
-        glDeleteShader(shader_object); return 0;
-    } else {
-        glGetShaderInfoLog(shader_object, sizeof(error), 0, error); if(error[0]) logPrint("%s shader info:\n%s",name?name:"(unnamed)",error);
-    }
-    return 1;
-}
-int tnsCheckProgramLinkStatus(GLuint program_object, char* name){
-    int status=0; char error[65536]={0};
-    glGetProgramiv(program_object, GL_LINK_STATUS, &status);
-    if (status == GL_FALSE){
-        glGetProgramInfoLog(program_object, sizeof(error), 0, error); logPrintNew("%s program Linking error:\n%s",name?name:"(unnamed)",error); return 0;
-        glDeleteProgram(program_object); return 0;
-    } else {
-        glGetProgramInfoLog(program_object, sizeof(error), 0, error); if (error[0]) logPrintNew("%s program Linking info:\n%s",name?name:"(unnamed)",error);
-    }
-    return 1;
-}
-int tnsNewVertexShader(const char *Content){
-    int status = 0;
-    char error[8192]={0};
-    GLuint VertexShaderObject;
-    tnsShader *s = 0;
-
-    if (!Content) return -1;
-
-    VertexShaderObject = glCreateShader(GL_VERTEX_SHADER);
-
-    char* UseContent=tnsEnsureShaderCommoms(Content,0,0);
-    glShaderSource(VertexShaderObject, 1, &UseContent, 0);
-    glCompileShader(VertexShaderObject);
-    if(!tnsCheckShaderCompileStatus(VertexShaderObject,"Vertex")){ free(UseContent); return -1; }
-    free(UseContent);
-
-    return VertexShaderObject;
-}
-int tnsNewFragmentShaderMaterial(const char *Content, const char* Library, const char* Material){
-    int status = 0;
-    char error[8192]={0};
-    GLuint FragmentShaderObject;
-    tnsShader *s = 0;
-
-    if (!Content) return -1;
-
-    FragmentShaderObject = glCreateShader(GL_FRAGMENT_SHADER);
-
-    char* UseContent=tnsEnsureShaderCommoms(Content,Library,Material);
-    glShaderSource(FragmentShaderObject, 1, &UseContent, 0);
-    glCompileShader(FragmentShaderObject);
-    if(!tnsCheckShaderCompileStatus(FragmentShaderObject,"Vertex")){ free(UseContent); return -1; }
-    free(UseContent);
-
-    return FragmentShaderObject;
-}
-int tnsNewFragmentShader(const char *Content){
-    return tnsNewFragmentShaderMaterial(Content,0,0);
-}
-int tnsNewGeometryShader(const char *Content){
-#ifndef LAGUI_ANDROID
-    int status = 0;
-    char error[8192]={0};
-    GLuint GeometryShaderObject;
-    tnsShader *s = 0;
-
-    if (!Content) return -1;
-
-    GeometryShaderObject = glCreateShader(GL_GEOMETRY_SHADER);
-
-    char* UseContent=tnsEnsureShaderCommoms(Content,0,0);
-    glShaderSource(GeometryShaderObject, 1, &UseContent, 0);
-    glCompileShader(GeometryShaderObject);
-    if(!tnsCheckShaderCompileStatus(GeometryShaderObject,"Geometry")){ free(UseContent); return -1; }
-    free(UseContent);
-    
-    return GeometryShaderObject;
-#endif
-    return 0;
-}
-
 tnsShader *tnsNewShaderProgram(int VertexShaderID, int FragmentShaderID, int GeometryShaderID){
     int vso = VertexShaderID;
     int fso = FragmentShaderID;
@@ -1435,6 +1344,17 @@ void tnsInitRenderKernel(int matrixStackLevel){
     arrEnsureLength(&T->DrawingCommand, T->NextCommand, &T->MaxCommand, sizeof(tnsCommand));
 }
 void tnsInitBuiltinShaders(){
+
+
+#ifdef LA_USE_GLES
+    const char uint_texture_selection[] = "#define GLES_UINT_TEXTURE";
+#else
+    const char uint_texture_selection[] = "";
+#endif
+    tnsAddShaderComponent("#with TNS_GLES_UINT_TEXTURE",uint_texture_selection);
+    tnsAddShaderComponent("#with TNS_SHADER_COLOR_COMMON",TNS_SHADER_COLOR_COMMON);
+    tnsAddShaderComponent("#with LA_SHADER_LIB_FXAA",LA_SHADER_LIB_FXAA);
+
     T->immShader = tnsNewShaderProgram(
         tnsNewVertexShader(LA_IMM_VERTEX_SHADER),tnsNewFragmentShader(LA_IMM_FRAGMENT_SHADER),-1);
 
@@ -1702,7 +1622,7 @@ void tnsDrawBatchInitArrayStates(tnsBatch* batch){
         }
     }
     if(cs->iUV>=0){ glDisableVertexAttribArray(cs->iUV); }
-    tnsUniformUseTexture(cs,0,0,0,0);
+    tnsUniformUseTexture(cs,0,0,0,0,0);
 }
 int tnsDrawBatch(tnsBatch* batch, const char* OverrideCommand, real* OverrideUniformColor, int OverrideAsArray) {
 	if (!batch) return 0;
@@ -1948,9 +1868,10 @@ void tnsUseTexture(tnsTexture *t){
     else if(t->GLTexType == GL_TEXTURE_2D_MULTISAMPLE){ T->StateTexColor = t; T->StateTextureMode=3; }
 #endif
 }
-void tnsUseTexture2(tnsTexture* t, int mixmode){
+void tnsUseTexture2(tnsTexture* t, int mixmode, int premultiplied){
     if(!t){ T->StateTextureMode=TEX_MODE_IS_MIXING(T)?2:0; return; }
     if(t->GLTexType == GL_TEXTURE_2D){ T->StateTexColor2=t; T->StateTextureMode=5+mixmode; }
+    T->StatePremultiplied=premultiplied;
 }
 void tnsUseNoTexture(){
     tnsUseTexture(0);
@@ -2015,11 +1936,12 @@ void tnsUnbindTexture2(){
         else{ tnsActiveTexture(GL_TEXTURE4); glBindTexture(T->TexColor2->GLTexType, 0); T->TexColor2=0; }
     }
 }
-void tnsUniformUseTexture(tnsShader* s, int mode, int sample, int TexIsUInt, int Tex2IsUInt){
+void tnsUniformUseTexture(tnsShader* s, int mode, int sample, int TexIsUInt, int Tex2IsUInt, int Premultiply){
     if(s->StateTextureMode != mode){ s->StateTextureMode=mode; glUniform1i(s->iTextureMode,mode); }
     if(mode==3 && s->StateSampleAmount != sample){ s->StateSampleAmount=sample, glUniform1i(s->iSampleAmount,sample); }
     if(s->StateTexIsUI != TexIsUInt){ s->StateTexIsUI=TexIsUInt; glUniform1i(s->iTexIsUI,TexIsUInt); }
     if(s->StateTex2IsUI != Tex2IsUInt){ s->StateTex2IsUI=Tex2IsUInt; glUniform1i(s->iTex2IsUI,Tex2IsUInt); }
+    if(s->StatePremultiplied != Premultiply){ s->StatePremultiplied=Premultiply; glUniform1i(s->iTexPremultiplied,Premultiply); }
 }
 void tnsUniformUseMultiplyColor(tnsShader* s, int enable){
     int mode=enable?1:0;
@@ -2468,6 +2390,7 @@ void tnsPackAs(GLenum Mode){
     c->ColorTexture2 = T->StateTexColor2;
     c->TextureMode = T->StateTextureMode;
     c->MultiplyColor = T->StateMultiplyColor;
+    c->Premultiply = T->StatePremultiplied;
     c->LineWidth=T->StateLineWidth;
     c->PointSize=T->StatePointSize;
     c->UseHalftone = T->StateUseHalftone;
@@ -2570,9 +2493,11 @@ void tnsFlush(){
             tnsBindTexture(c->ColorTexture);
             if(c->ColorTexture2) tnsBindTexture2(c->ColorTexture2);
             tnsUniformUseTexture(cs, c->TextureMode, c->ColorTexture->Multisample,
-                c->ColorTexture?c->ColorTexture->IsUIntTexture:0, c->ColorTexture2?c->ColorTexture2->IsUIntTexture:0);
+                c->ColorTexture?c->ColorTexture->IsUIntTexture:0,
+                c->ColorTexture2?c->ColorTexture2->IsUIntTexture:0,
+                c->Premultiply);
         }else{
-            tnsUniformUseTexture(cs,0,0,0,0); //tnsUnbindTexture(); 
+            tnsUniformUseTexture(cs,0,0,0,0,0); //tnsUnbindTexture(); 
         }
 
         if(cs->iMultiplyColor != -1){ tnsUniformUseMultiplyColor(cs, c->MultiplyColor); }

resources/la_modelling.c

@@ -120,7 +120,7 @@ void la_PopulateSelectDataObjects(MSelectData* sd, tnsObject* root, laCanvasExtr
     sd->nextV++; // starting from 1;
     la_AssignObjectSelectIDRecursive(root, sd);
     if(sd->nextV==1) return; int w=sd->Color->Width, h=sd->Color->Height;
-    tnsUnbindTexture(); tnsUniformUseTexture(T->immShader,0,0,0,0); tnsUseMultiplyColor(0);
+    tnsUnbindTexture(); tnsUniformUseTexture(T->immShader,0,0,0,0,0); tnsUseMultiplyColor(0);
     tnsEnableShaderv(T->SelectionShader);
     glDisableVertexAttribArray(T->SelectionShader->iColor); glVertexAttrib4f(T->SelectionShader->iColor,0,0,0,0);
     tnsViewportWithScissor(0,0,w,h);tnsResetViewMatrix();tnsResetModelMatrix();tnsResetProjectionMatrix();
@@ -182,7 +182,7 @@ void la_PopulateSelectDataPrimitives(MSelectData* sd, tnsObject* o, tnsCamera* c
         la_PopulateSelectPoints(sd,so);
     }
     int w=sd->Color->Width, h=sd->Color->Height;
-    tnsUnbindTexture(); tnsUniformUseTexture(T->immShader,0,0,0,0); tnsUseMultiplyColor(0);
+    tnsUnbindTexture(); tnsUniformUseTexture(T->immShader,0,0,0,0,0); tnsUseMultiplyColor(0);
     tnsEnableShaderv(T->SelectionShader);
     tnsViewportWithScissor(0,0,w,h);tnsResetViewMatrix();tnsResetModelMatrix();tnsResetProjectionMatrix();
 

resources/la_tns_shader_infrastructure.cpp

@@ -0,0 +1,127 @@
+/*
+* LaGUI: A graphical application framework.
+* Copyright (C) 2022-2023 Wu Yiming
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define _GNU_SOURCE 1
+
+#include "la_5.h"
+
+#include <string>
+#include <regex>
+
+extern tnsMain* T;
+
+char* tnsRegexReplace(char* in, char* pairs[]){
+    std::string a=in; char** p=pairs;
+    while(p[0]){
+        a = std::regex_replace(a,std::regex(p[0]),p[1]); p+=2;
+    }
+    int len=a.length()+1; void* ret=malloc(len); memcpy(ret, a.c_str(), len); return (char*)ret;
+}
+
+std::string tnsEnsureShaderCommoms(std::string in){
+    std::string str=in;
+    for(tnsShaderComponent* sc=(tnsShaderComponent*)T->ShaderComponents.pFirst;sc;sc=(tnsShaderComponent*)sc->Item.pNext){
+        str = std::regex_replace(str,std::regex(sc->name),sc->replacement);
+    }
+    return str;
+}
+std::string tnsEnsureShaderCommomsLib(std::string in, std::string lib, std::string material){
+    std::string str=tnsEnsureShaderCommoms(in);
+    str = std::regex_replace(str,std::regex("#with TNS_SHADER_MATERIAL"),material);
+    str = std::regex_replace(str,std::regex("#with TNS_SHADER_LIBRARY"),lib);
+    return str;
+}
+int tnsCheckShaderCompileStatus(GLuint shader_object, char* name){
+    int status=0; char error[65536]={0};
+    glGetShaderiv(shader_object, GL_COMPILE_STATUS, &status);
+    if (status == GL_FALSE){
+        glGetShaderInfoLog(shader_object, sizeof(error), 0, error); logPrint("%s shader error:\n%s",name?name:"(unnamed)",error);
+        glDeleteShader(shader_object); return 0;
+    } else {
+        glGetShaderInfoLog(shader_object, sizeof(error), 0, error); if(error[0]) logPrint("%s shader info:\n%s",name?name:"(unnamed)",error);
+    }
+    return 1;
+}
+int tnsCheckProgramLinkStatus(GLuint program_object, char* name){
+    int status=0; char error[65536]={0};
+    glGetProgramiv(program_object, GL_LINK_STATUS, &status);
+    if (status == GL_FALSE){
+        glGetProgramInfoLog(program_object, sizeof(error), 0, error); logPrintNew("%s program Linking error:\n%s",name?name:"(unnamed)",error); return 0;
+        glDeleteProgram(program_object); return 0;
+    } else {
+        glGetProgramInfoLog(program_object, sizeof(error), 0, error); if (error[0]) logPrintNew("%s program Linking info:\n%s",name?name:"(unnamed)",error);
+    }
+    return 1;
+}
+
+int tnsNewVertexShader(const char *Content){
+    int status = 0;
+    GLuint VertexShaderObject;
+    tnsShader *s = 0;
+
+    if (!Content) return -1;
+
+    VertexShaderObject = glCreateShader(GL_VERTEX_SHADER);
+
+    std::string UseContent=tnsEnsureShaderCommoms(Content);
+    const char* str=UseContent.c_str();
+    glShaderSource(VertexShaderObject, 1, &str, 0);
+    glCompileShader(VertexShaderObject);
+    if(!tnsCheckShaderCompileStatus(VertexShaderObject,"Vertex")){ return -1; }
+
+    return VertexShaderObject;
+}
+int tnsNewFragmentShaderMaterial(const char *Content, const char* Library, const char* Material){
+    int status = 0;
+    GLuint FragmentShaderObject;
+    tnsShader *s = 0;
+    if (!Content) return -1;
+
+    FragmentShaderObject = glCreateShader(GL_FRAGMENT_SHADER);
+
+    std::string UseContent=tnsEnsureShaderCommomsLib(Content,Library?Library:"",Material?Material:"");
+    const char* str=UseContent.c_str();
+    glShaderSource(FragmentShaderObject, 1, &str, 0);
+    glCompileShader(FragmentShaderObject);
+    if(!tnsCheckShaderCompileStatus(FragmentShaderObject,"Vertex")){ return -1; }
+
+    return FragmentShaderObject;
+}
+int tnsNewFragmentShader(const char *Content){
+    return tnsNewFragmentShaderMaterial(Content,0,0);
+}
+int tnsNewGeometryShader(const char *Content){
+#ifndef LAGUI_ANDROID
+    int status = 0;
+    GLuint GeometryShaderObject;
+    tnsShader *s = 0;
+    if (!Content) return -1;
+
+    GeometryShaderObject = glCreateShader(GL_GEOMETRY_SHADER);
+
+    std::string UseContent=tnsEnsureShaderCommoms(Content);
+    const char* str=UseContent.c_str();
+    glShaderSource(GeometryShaderObject, 1, &str, 0);
+    glCompileShader(GeometryShaderObject);
+    if(!tnsCheckShaderCompileStatus(GeometryShaderObject,"Geometry")){ return -1; }
+    
+    return GeometryShaderObject;
+#endif
+    return 0;
+}
+

resources/la_tns_shaders.cpp

@@ -689,6 +689,7 @@ layout (binding=4) uniform highp sampler2D TexColor2;
 layout (binding=5) uniform highp usampler2D TexColorUI2;
 uniform int TexIsUI;
 uniform int Tex2IsUI;
+uniform int TexPremultiplied;
 uniform int UseLut;
 uniform int TextureMode;
 uniform int ColorMode;
@@ -793,7 +794,12 @@ void main(){
 	}else if(TextureMode==5){
         vec4 color1=texture1(fUV.st); if(MultiplyColor!=0){color1*=fColor;}
 		vec4 color2=texture2();
-		color = color1+color2*(1.0-color1.a);
+		if(TexPremultiplied!=0){
+			color = color1+color2*(1.0-color1.a);
+		}else{
+			color.rgb=color1.rgb*color1.a+color2.rgb*(1.-color1.a);
+			color.a=color1.a+(1.-color1.a)*color2.a;
+		}
 	}else if(TextureMode==6){
         vec4 color1=texture1(fUV.st); if(MultiplyColor!=0){color1*=fColor;}
 		vec4 color2=texture2();

resources/la_widgets_viewers.c

@@ -208,7 +208,7 @@ void la_RootObjectDraw(laBoxedTheme *bt, tnsObject *root, laUiItem* ui){
             glEnable(GL_DEPTH_TEST); glDisable(GL_BLEND);
 
             tnsUseShader(T->immShader); tnsEnableShaderv(T->immShader); tnsUseNoTexture();
-            tnsUnbindTexture(); tnsUniformUseTexture(T->immShader,0,0,0,0); tnsUseMultiplyColor(0);
+            tnsUnbindTexture(); tnsUniformUseTexture(T->immShader,0,0,0,0,0); tnsUseMultiplyColor(0);
             tnsDrawObjectTree(root,TNS_EVAL_LAYER_SOLID|Do2DInstance,&de,e->AsPlayer);
             
             glLineWidth(7);  tnsUniformUseOffset(T->immShader,-100);