Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Di Jul 08, 2025 15:40

Foren-Übersicht » Programmierung » Einsteiger-Fragen
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 15 Beiträge ] 
Autor Nachricht
 Betreff des Beitrags: probleme mit texturen auf trapezen
BeitragVerfasst: Fr Aug 11, 2006 00:23 
Offline
DGL Member

Registriert: Di Aug 08, 2006 09:56
Beiträge: 6
Hi,
ich habe (wie könnt es ader sein) ein kleines problem.
Ich habe angefangen mit OpenGL für die FH was zu machen und bin nun soweit das ich meine modelle texturieren will, dies funktionierte (dank der tutorials auf dieser seite (die besten anfänger tuts die ich bis jetzt gefunden hab^^ ) ) soweit ganz gut bis ich dann eine trapezförmige fläche texturieren wollte und eine seltsame verzerrung bemerkte. Daraufhin habe ich eine probe textur gebastelt und einige versuche gemacht mit sehr unbefriedigendem ergebnis.
Ich habe es nicht hinbekommen eine Textur auf ein nicht rechteckiges viereck zu legen ohne das diese seltsam verzerrt wird -.-

kann mir da jemand weiterhelfen ?

anbei mein test-programm und ein par screenshots:
anmerkung:
reihe 1: ein normales rechteck das schief im raum liegt - so würd ich gerne die textur auf meinem trapez sehen..
reihe 2: ein normales trapez - selbe textur
reihe 3-7 : verschiedene versuche das trapez anders darzustellen

und hier der code (c/c++, windows, borland 6 - bei nem kumpel siehts genauso aus und der hats unter linux compiliert)

Code:
  1.  
  2. #include <windows.h>
  3. #include <gl/gl.h>
  4. #include <gl/glu.h>
  5. #include <gl/glut.h>
  6. #include <math.h>
  7. #include <iostream.h>
  8.  
  9.  
  10. unsigned char tex1[128*128*3];
  11. GLuint  TexID;
  12. int     typ=1;
  13. int     mode=GL_POLYGON;
  14.  
  15.  
  16. GLfloat ul [3]={ -5.0f , -2.5f , -15.0f };  // unten links
  17. GLfloat uml[3]={ -2.5f , -2.5f , -15.0f };  // unten mitte links
  18. GLfloat um [3]={  0.0f , -2.5f , -15.0f };  // unten mitte
  19. GLfloat umr[3]={  2.5f , -2.5f , -15.0f };  // unten mitte rechts
  20. GLfloat ur [3]={  5.0f , -2.5f , -15.0f };  // unten rechts
  21. GLfloat mm [3]={  0.0f ,  0.8f , -15.0f };  // schnittpunkt der diagonalen (ca.)
  22. GLfloat ol [3]={ -2.5f ,  2.5f , -15.0f };  // oben links
  23. GLfloat or [3]={  2.5f ,  2.5f , -15.0f };  // oben rechts
  24.  
  25.  
  26.  
  27. // Light values and coordinates
  28. GLfloat  Light0Pos[] = { -100.0f, 50.0f, 0.0f, 1.0f };
  29. GLfloat  Light0Ambient[] = { 0.3f, 0.3f, 0.3f, 1.0f };
  30. GLfloat  Light0Diffuse[] = { 0.5f, 0.5f, 0.5f, 1.0f };
  31. GLfloat  Light0Specular[] = { 1.0f, 1.0f, 1.0f, 1.0f};
  32.  
  33. GLfloat  specref[] =  { 1.0f, 1.0f, 1.0f, 1.0f };
  34.  
  35.  
  36. /////////////////////////////////////////////////////////////////////////////////////////////////
  37. /////////////////////////////////////////////////////////////////////////////////////////////////
  38. ///////////////////////////////  R E N D E R S C E N E  /////////////////////////////////////////
  39. /////////////////////////////////////////////////////////////////////////////////////////////////
  40. /////////////////////////////////////////////////////////////////////////////////////////////////
  41. // Called to draw scene
  42. void RenderScene(void){
  43.     glColor3ub(255,255,255);
  44.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear the window
  45.     glPushMatrix();
  46.         glColor3ub(255,255,255);
  47.         glNormal3f( 0.0f , 0.0f , 1.0f );  // Reflektions-Vektor
  48.         glBindTexture( GL_TEXTURE_2D, TexID );
  49.  
  50.         if (mode==GL_POLYGON){          // Texturen auf Lieneien sind keine gute idee^^
  51.             glEnable(GL_TEXTURE_2D);
  52.         }
  53.  
  54.         if(typ==1){
  55.             glBegin(mode);           //schräg gelegtes viereck als referenz
  56.                 glTexCoord2f(0,0);
  57.                 glVertex3f( -5.0f , -2.5f , -15.0f );
  58.                 glTexCoord2f(1,0);
  59.                 glVertex3f(  5.0f , -2.5f , -15.0f );
  60.                 glTexCoord2f(1,1);
  61.                 glVertex3f(  5.0f ,  5.0f , -30.0f );
  62.                 glTexCoord2f(0,1);
  63.                 glVertex3f( -5.0f ,  5.0f , -30.0f );
  64.             glEnd();
  65.         }
  66.         if(typ==2){
  67.            glBegin(mode);           //normales trapez
  68.                 glTexCoord2f(0,0);
  69.                 glVertex3fv(ul);
  70.                 glTexCoord2f(1,0);
  71.                 glVertex3fv(ur);
  72.                 glTexCoord2f(1,1);
  73.                 glVertex3fv(or);
  74.                 glTexCoord2f(0,1);
  75.                 glVertex3fv(ol);
  76.             glEnd();
  77.         }
  78.         if (typ==3){                      // trapez aus 3 dreiecken
  79.             glBegin(mode);
  80.                 glTexCoord2f(0,0);
  81.                 glVertex3fv(ul);
  82.                 glTexCoord2f(0.5,0);
  83.                 glVertex3fv(um);
  84.                 glTexCoord2f(0,1);
  85.                 glVertex3fv(ol);
  86.             glEnd();
  87.             glBegin(mode);
  88.                 glTexCoord2f(0.5,0);
  89.                 glVertex3fv(um);
  90.                 glTexCoord2f(1,0);
  91.                 glVertex3fv(ur);
  92.                 glTexCoord2f(1,1);
  93.                 glVertex3fv(or);
  94.             glEnd();
  95.             glBegin(mode);
  96.                 glTexCoord2f(1,1);
  97.                 glVertex3fv(or);
  98.                 glTexCoord2f(0,1);
  99.                 glVertex3fv(ol);
  100.                 glTexCoord2f(0.5,0);
  101.                 glVertex3fv(um);
  102.             glEnd();
  103.         }
  104.         if (typ==4){                      //paralellogramm mit dreieck
  105.             glBegin(mode);
  106.                 glTexCoord2f(0,0);
  107.                 glVertex3fv(ul);
  108.                 glTexCoord2f(0.5,0);
  109.                 glVertex3fv(um);
  110.                 glTexCoord2f(1,1);
  111.                 glVertex3fv(or);
  112.                 glTexCoord2f(0,1);
  113.                 glVertex3fv(ol);
  114.             glEnd();
  115.             glBegin(mode);
  116.                 glTexCoord2f(0.5,0);
  117.                 glVertex3fv(um);
  118.                 glTexCoord2f(1,0);
  119.                 glVertex3fv(ur);
  120.                 glTexCoord2f(1,1);
  121.                 glVertex3fv(or);
  122.             glEnd();
  123.         }
  124.         if (typ==5){                      //ein viereck mt je einem dreieck links und rechts
  125.             glBegin(mode);
  126.                 glTexCoord2f(0,0);
  127.                 glVertex3fv(ul);
  128.                 glTexCoord2f(0.25,0);
  129.                 glVertex3fv(uml);
  130.                 glTexCoord2f(0,1);
  131.                 glVertex3fv(ol);
  132.             glEnd();
  133.             glBegin(mode);
  134.                 glTexCoord2f(0.25,0);
  135.                 glVertex3fv(uml);
  136.                 glTexCoord2f(0.75,0);
  137.                 glVertex3fv(umr);
  138.                 glTexCoord2f(1,1);
  139.                 glVertex3fv(or);
  140.                 glTexCoord2f(0,1);
  141.                 glVertex3fv(ol);
  142.             glEnd();
  143.             glBegin(mode);
  144.                 glTexCoord2f(0.75,0);
  145.                 glVertex3fv(umr);
  146.                 glTexCoord2f(1,0);
  147.                 glVertex3fv(ur);
  148.                 glTexCoord2f(1,1);
  149.                 glVertex3fv(or);
  150.             glEnd();
  151.         }
  152.         if (typ==6){                      //trapez aus 2 dreiecken
  153.             glBegin(mode);
  154.                 glTexCoord2f(0,0);
  155.                 glVertex3fv(ul);
  156.                 glTexCoord2f(1,0);
  157.                 glVertex3fv(ur);
  158.                 glTexCoord2f(1,1);
  159.                 glVertex3fv(or);
  160.             glEnd();
  161.             glBegin(mode);
  162.                 glTexCoord2f(1,1);
  163.                 glVertex3fv(or);
  164.                 glTexCoord2f(0,1);
  165.                 glVertex3fv(ol);
  166.                 glTexCoord2f(0,0);
  167.                 glVertex3fv(ul);
  168.             glEnd();
  169.         }
  170.         if (typ==7){                      //trapez aus 4 dreiecken
  171.             glBegin(mode);
  172.                 glTexCoord2f(0,0);
  173.                 glVertex3fv(ul);
  174.                 glTexCoord2f(1,0);
  175.                 glVertex3fv(ur);
  176.                 glTexCoord2f(0.5,0.5);
  177.                 glVertex3fv(mm);
  178.             glEnd();
  179.             glBegin(mode);
  180.                 glTexCoord2f(1,0);
  181.                 glVertex3fv(ur);
  182.                 glTexCoord2f(1,1);
  183.                 glVertex3fv(or);
  184.                 glTexCoord2f(0.5,0.5);
  185.                 glVertex3fv(mm);
  186.             glEnd();
  187.             glBegin(mode);
  188.                 glTexCoord2f(1,1);
  189.                 glVertex3fv(or);
  190.                 glTexCoord2f(0,1);
  191.                 glVertex3fv(ol);
  192.                 glTexCoord2f(0.5,0.5);
  193.                 glVertex3fv(mm);
  194.             glEnd();
  195.             glBegin(mode);
  196.                 glTexCoord2f(0,1);
  197.                 glVertex3fv(ol);
  198.                 glTexCoord2f(0,0);
  199.                 glVertex3fv(ul);
  200.                 glTexCoord2f(0.5,0.5);
  201.                 glVertex3fv(mm);
  202.             glEnd();
  203.  
  204.         }
  205.  
  206.         glDisable(GL_TEXTURE_2D);
  207.     glPopMatrix();
  208.     glutSwapBuffers();
  209.  
  210. }
  211.  
  212.  
  213.  
  214.  
  215.  
  216. void SetupRC(){
  217.     glGenTextures(1, &TexID);
  218.     FILE *in;
  219.     int OK;
  220.  
  221.     in=fopen("test.raw","rb");
  222.     OK=fread(tex1,128*128*3,1,in);
  223.     fclose(in);
  224.     glBindTexture(GL_TEXTURE_2D, TexID);
  225.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  226.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  227.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
  228.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
  229.     glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
  230.     glTexImage2D(GL_TEXTURE_2D, 0, 3, 128, 128,0, GL_RGB, GL_UNSIGNED_BYTE, tex1);
  231.  
  232.  
  233.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f );  // Black background
  234.     glEnable(GL_DEPTH_TEST);                // Enable Depth Testing // Hidden surface removal
  235.     glEnable(GL_LIGHTING);          // Enable lighting
  236.     glEnable(GL_COLOR_MATERIAL);    // Enable color tracking
  237.     // Setup and enable light 0
  238.     glLightfv(GL_LIGHT0,GL_AMBIENT,Light0Ambient);
  239.     glLightfv(GL_LIGHT0,GL_DIFFUSE,Light0Diffuse);
  240.     glLightfv(GL_LIGHT0,GL_SPECULAR,Light0Specular);
  241.     glEnable(GL_LIGHT0);
  242.     // All materials hereafter have full specular reflectivity
  243.     // with a high shine
  244.     glMaterialfv(GL_FRONT, GL_SPECULAR,specref);
  245.     glMateriali(GL_FRONT,GL_SHININESS,128);
  246.     glFrontFace(GL_CCW);            // Counter clock-wise polygons face out
  247.     glEnable(GL_CULL_FACE);         // Do not calculate inside of jet
  248.     glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);    // Set Material properties to follow glColor values
  249.     glColor3ub(0, 0, 255);                  // Set drawing color to blue
  250. }
  251.  
  252. void ChangeSize(int w, int h){
  253.     glViewport(0, 0, w, h); // Set Viewport to window dimensions
  254.     // Reset projection matrix stack
  255.     glMatrixMode(GL_PROJECTION);
  256.     glLoadIdentity();
  257.     gluPerspective(60.0f,(GLfloat)w/(GLfloat)h,1.0f, 1000.0f);
  258.     // Reset Texture Model view matrix stack
  259.     glMatrixMode(GL_TEXTURE);
  260.     glLoadIdentity;
  261.     // Reset Model view matrix stack
  262.     glMatrixMode(GL_MODELVIEW);
  263.     glLoadIdentity();
  264.     glLightfv(GL_LIGHT0,GL_POSITION,Light0Pos);
  265. }
  266.  
  267.  
  268. void NormalKeys(unsigned char key, int x, int y){
  269.     if(key == '1'){
  270.         typ=1;
  271.     }
  272.     if(key == '2'){
  273.         typ=2;
  274.     }
  275.     if(key == '3'){
  276.         typ=3;
  277.     }
  278.     if(key == '4'){
  279.         typ=4;
  280.     }
  281.     if(key == '5'){
  282.         typ=5;
  283.     }
  284.     if(key == '6'){
  285.         typ=6;
  286.     }
  287.     if(key == '7'){
  288.         typ=7;
  289.     }
  290.     if(key == 27){      // ESC-taste
  291.         exit(0);
  292.     }
  293.     if(key == ' '){
  294.         if (mode==GL_POLYGON){mode=GL_LINE_LOOP;}else{mode=GL_POLYGON;}
  295.     }
  296.     glutPostRedisplay();    // Refresh the Window
  297. }
  298.  
  299.  
  300. void MenueFunktion(int was){
  301.     if (was==99){exit(0);}
  302.     glutPostRedisplay();
  303. }
  304.  
  305.  
  306. int main(int argc, char* argv[]){
  307.     glutInit(&argc, argv);
  308.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  309.     glutCreateWindow("Texturen Test");
  310.  
  311. //    glutGameModeString("640x480:16@60");      //für neuere glut versionen...
  312. //    glutEnterGameMode();
  313.  
  314. //    glutFullScreen();                                         //für ältere glut versionen
  315.  
  316.     glutCreateMenu(MenueFunktion);
  317.     glutAddMenuEntry("<ESC> Beenden",99);
  318.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  319.  
  320.     glutReshapeFunc(ChangeSize);
  321.     glutKeyboardFunc(NormalKeys);
  322.     glutDisplayFunc(RenderScene);
  323.     SetupRC();
  324.     glutMainLoop();
  325.  
  326.     return 0;
  327. }
  328.  
  329.  




und hier die screenis in einem bild zusammengefasst (das forum will die irgendwie nicht als atachment -.- )

Bild


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 00:56 
Offline
Ernährungsberater
Benutzeravatar

Registriert: Sa Jan 01, 2005 17:11
Beiträge: 2068
Programmiersprache: C++
Du deaktivierst nach dem ersten Rendern das Texturieren mit glDisable(GL_TEXTURE_2D);
glBindTexture aktiviert es aber nicht, jedenfalls nach meinem Wissen. Kommentier das glDisalbe erstmal aus oder ersetze es mit glBindTexture(GL_TEXTURE_2D,0);


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 01:00 
Offline
DGL Member

Registriert: Di Aug 08, 2006 09:56
Beiträge: 6
daran liegt es nicht, den ich aktiviere es auch wieder mit:

if (mode==GL_POLYGON){ // Texturen auf Lieneien sind keine gute idee^^
glEnable(GL_TEXTURE_2D);
}

ich habe dies eingefügt damit, wenn ich nur die lienien seen will, opengl nicht versucht mir diese ebenfalls zu texturieren.


und bevor noch jemand auf die idee kommt: es macht für mein problem kein unterschied ob ich GL_POLYGON oder entsprechend GL_QUADS / GL_TRIANGLES benutze (habs schon längst getestet).

für mich sieht es so aus als ob der fehler entsteht wenn opengl das trapez in 2 dreiecke zerlegt und diese dann intern einzeln texturiert, das dann die verzerrung der textur wie man sie erwarten würd verlohren geht und er jedes dreiech unabhängig texturiert... (so schein es mir zumindest, these aufgestellt als ich die zeichenreihenfolge mal geändert hab - also oben links bekonnen)


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Fr Aug 11, 2006 01:39 
Offline
Ernährungsberater
Benutzeravatar

Registriert: Sa Jan 01, 2005 17:11
Beiträge: 2068
Programmiersprache: C++
Edit & Clear:
Es ist spät, ich bin müde ;)

Und zwar sehr :/

Martok hat recht, es liegt einfach an der Zerlegung in Dreiecke:
Das ganze nochmal mit stärkerem Trapez:
Bild

Wenn man sich die Dreiecke jetzt anschaut, ist das eine (rechte) "normal", das andere aber sehr gestaucht:
Bild
OpenGL rechnet die Texturkoordinaten für das linke Dreieck nur bis zur rechten oberen Ecke. Das ganze ist gestaucht und der Effekt tritt auf.

Wie man ihn umgeht ist die andere gute Frage :?
Da kann ich dir gerade keine Antwort geben.


Zuletzt geändert von i0n0s am Fr Aug 11, 2006 02:04, insgesamt 1-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 01:51 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Mai 29, 2006 21:13
Beiträge: 142
Wohnort: Ballenstedt/Sachsen-Anhalt
So wir mir das erscheint liegt dein Quad ja wirklich im Raum, beim OP scheint es aber nur so. Er hat meines Erachtens keine Tiefenwerte.

Der Effekt kommt übrigens wirklich von der Zerlegung in Dreiecke, man kann ihn auch beobachten wenn man auf ein Quadrat Texturen aufträgt, und unterschiedliche Texturkoordinaten übergibt. Also die Koordinaten so:
Code:
  1.  
  2. (0,0)--------(1,0)
  3.   |            |
  4.   |            |
  5.   |            |
  6.   |            |
  7. (0,0.5)------(1,1)

Der unten links produziert diesen effekt.

_________________
Gott sei Dank bin ich Atheist!


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 09:18 
Offline
DGL Member

Registriert: Di Aug 08, 2006 09:56
Beiträge: 6
das erste bild (m==1) ist ja auch ein normales rechteck das im raum gekipt wurde um zu zeigen wie ich erwarte wie die textur aussehen soll. das problem ist ab dem 2. bild.

da bleibt jetzt nur noch die frage: wie bekomm ich texturen vernünftig auf nicht-rechteckförmige vierecke, es muss doch irgendwie gehen!


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 09:42 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Ja. Indem du die passenden Texturkoordinaten ausrechnest. Du übergibst nämlich die Eckpunkte einer Rechteckigen Figur, und weist OpenGL damit an diese auf eine nicht-rechteckige zu projezieren. Klar das das zu Artefakten führt.

Du grigst das nur weg, indem du entweder den Inhalt der Textur trapezförmig machst, oder aber du könntest mal versuchen die Textur so zu drehen wie das Rechteck. Also per manipulation der Texturmatrix (glMatrixMode(GL_TEXTURE)).


Das die Tesselierung/Trianglulation aber tatsächlich hin und wieder nerven kann, ist eine Tatsache die ich nicht verneinen will ;)

_________________
Blog: kevin-fleischer.de und fbaingermany.com


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 10:17 
Offline
DGL Member

Registriert: Di Aug 08, 2006 09:56
Beiträge: 6
Flash hat geschrieben:
Du grigst das nur weg, indem du entweder den Inhalt der Textur trapezförmig machst,

und kennt wer ein programm mit dem ich texturen entsprechend verzerren kann (also ne rechteckige textur auf ein gewünschtes nicht rechteckiges viereck) das opengl es dann wieder "richtig" anzeigt?
Flash hat geschrieben:
oder aber du könntest mal versuchen die Textur so zu drehen wie das Rechteck. Also per manipulation der Texturmatrix (glMatrixMode(GL_TEXTURE)).

öhm und wie soll das helfen wenn ich die textur drehe - die verzerrungen bleiben doch weiterhin O_o


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 10:41 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Also ich sehe das Problem primär in der Fehlenden Perspektive der Fläche. Nehmen wir mal an wir zerteilen unser Quad in 10x10 gleichgroße Quads. Wenn man dann eines der Hinteren mit einem Vorderen vergleicht sind diese zwar von den Werten her gleichgroß, belegen aber unterschiedlich viel Platz auf dem Bildschirm. Da durch die Perspektive sowohl die Breite als auch die Höhe kleiner geworden ist.

Die Textur anzupassen denke dürfte nur halbwegs richtig funktionieren, wenn diese auch die Perspektive beachten. Allerdings muss dein Quad dann weiterhin gerade bleiben. Also nicht selber etwas verzerren sondern die Figur mittels der Textur darstellen. Rest mittels Blenden oder Alphatest abschneiden. Finde ich aber nicht so wirklich optimal.

Die andere alternative wären evtl Shader. Damit sollte es vielleicht möglich sein, dass du ein Quad benutzt und auf diesem die Textur so darstellen kannst wie du es für richtig hältst. Wie das allerdings zu bewerkstelligen ist ist ein ganz anderes Thema.

Mir persönlich stellt sich aber die Fragen warum du eine Textur perspektivisch auf ein nicht perspektivesches Objekt auftragen möchtest? Das ist äußers untypisch. Wie du ja selber an den leichten Schwirigkeiten merkst.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 13:44 
Offline
DGL Member

Registriert: Di Aug 08, 2006 09:56
Beiträge: 6
ich glaube ihr versteht mein problem falsch - das schief gelegte quad dient nur zur veranschaulichung wie ich mir die textur vorstelle.
beispiel ein pyramidenstumpf - da habe ich unten und oben je eine Quadrat und dann 4 trapezförmige seiten - und um diese geht es.

im end effekt habe ich ein aufwendigeres modell, in dem rellativ viele nicht-rechteck förmige vierecke vorkommen, die ich aber vernünftig texturiert haben will...

hierbei ist es föllig egal wie schief und krumm meine trapez-förmige fläche im raum steht..

ps.: ich habe mal eine screenshot von meiner schiefen fläche gemacht und daraus ne neue textur mit passenden koordinaten - funktioniert auch - allerdings nur bei echten trapezen und nicht bei flächen die so:
Code:
  1.  
  2.                                                  --------
  3.                                                /          |
  4.                                                ----------
  5.  

aussehen.
desweiteren wäre der aufwand bei 50+ nicht rechteckigen vierecken sehr hoch wenn ich jedesmal eine rechteck experimentell so schief in den raum lege das es dessen projektion der fläche meines trapezes entspricht :p

edit Lossy: Codetag hinzugefügt


Zuletzt geändert von qwertzu123 am Fr Aug 11, 2006 14:37, insgesamt 1-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 14:14 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Hmmm...Am aller einfachsten wäre es, wenn du dein Modell z.B. mit 3DS Max modellierst und dort Texturierst. Das ergebnis kannst du dann in dein Programm laden, mittels Noeskas 3ds.pas

_________________
Blog: kevin-fleischer.de und fbaingermany.com


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 18:31 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Das ist eher ein grundsätzliches Problem. Man kann das mit projektivem Texturekoordinaten lösen glTexCoord4f(s,t,1,q). Die Eckpunkte werden so zugewiesen, als wenn es sich um ein Quadrat handeln würde. Bei einer Seite setzt man q auf 1 und bei der anderen auf einen höheren Wert. Da die Texturekoordinaten pro Pixel durch q geteilt werden, also s/q t/q verwendet wird, wird pro Pixel diese Projektion ausgeführt und dann funktioniert das. Wenn man nur s,t benutzt macht man die Projektion nur pro Vertex und das läßt sich nicht linear interpolieren.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 21:00 
Offline
DGL Member

Registriert: Di Aug 08, 2006 09:56
Beiträge: 6
hmm könntest du mir die parameter etwas genauer erklären? - hab im netz irgendwie nix brauchbares dazu gefunden -.-


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 21:09 
Offline
DGL Member
Benutzeravatar

Registriert: Di Dez 27, 2005 12:44
Beiträge: 393
Wohnort: Berlin
Programmiersprache: Java, C++, Groovy
hallo

ich hatte früher auch das problem.
die einzige lösung die ich hatte war, die texturkoordinaten an die vertex-koordinaten anzugleichen.

also wenn das viereck unten breiter war, musst ich auch den s-bereich der textur unten entsprechend vergrössern.


viele grüße
dj3hut1


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Aug 11, 2006 21:25 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Es gibt genau zu diesem Trapez Problem ein pdf von NVidia, in dem das erklärt wurde, aber ich habe es nicht mehr wiedergefunden.


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 15 Beiträge ] 
Foren-Übersicht » Programmierung » Einsteiger-Fragen


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 11 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.011s | 14 Queries | GZIP : On ]