+ Antworten
Ergebnis 1 bis 11 von 11

Thema: LWJGL 3D Linien werden nicht gezeichnet

  1. #1
    User Halbes Megabyte Themenstarter
    Avatar von Zombiepriester
    Registriert seit
    16.05.2013
    Fachbeiträge
    683
    Genannt
    18 Post(s)
    Hallo
    Wahrscheinlich merk ich es nur nicht, weil ich seit Monaten nicht mehr richtig programmiert hab. Diese Sache mit dem Shader und der Weltgenerierung hat mir echt den Rest gegeben (Appropos, ich habs immer noch nicht raus, also wenn irgendwer helfen kann: Zum Thema). Aber nach diesem weiteren verzweifelten Hilferuf nun zu einem neuen Problem. Ich hab zur Ablenkung mal ein kleineres "Projektlein" angefangen. Ein 3D Funktionsplotter soll es werden. Doch irgendwie krieg ich die Basics eines GL Kontexts nicht mehr hin. Also, grundsätzlich schon, aber ich hab das Gefühl, dass irgendwas fehlt. Irgendwie funktioniert nämlich die Projektion nicht. Ich hab zu Anfang versucht 3 Linien für das Koordinatensystem zu zeichnen. Doch obwohl ich sie nur von 0 bis 1 (jeweils) zeichne, gehen sie jeweils bis zum Rand des GL Displays. Das kommt glaube ich daher, dass das nicht projeziert wird. Auch werden Linien die schräg oder ganz in Z Richtung verlaufen gar nicht angezeigt.
    Das Projekt ist bisher relativ übersichtlich, ich hab mal alles in eine Datei zusammengeschrieben. Ist so ausführbar, aber ideal wär natürlich, wenn es direkt jemandem auffallen würde (Wie gesagt, ich glaub es ist ganz einfach).
    Java Code:
    1.  
    2. import java.awt.BorderLayout;
    3. import java.awt.Canvas;
    4. import java.awt.Dimension;
    5. import java.io.BufferedReader;
    6. import java.io.IOException;
    7. import java.io.InputStreamReader;
    8. import java.nio.ByteBuffer;
    9. import java.nio.ByteOrder;
    10. import java.nio.FloatBuffer;
    11. import java.nio.IntBuffer;
    12.  
    13. import javax.swing.*;
    14.  
    15. import org.lwjgl.BufferUtils;
    16. import org.lwjgl.LWJGLException;
    17. import org.lwjgl.opengl.ContextAttribs;
    18. import org.lwjgl.opengl.Display;
    19. import org.lwjgl.opengl.DisplayMode;
    20. import org.lwjgl.opengl.GL20;
    21. import org.lwjgl.opengl.PixelFormat;
    22.  
    23. import static org.lwjgl.opengl.GL11.*;
    24. import static org.lwjgl.opengl.GL15.*;
    25. import static org.lwjgl.opengl.GL20.*;
    26. import static org.lwjgl.opengl.GL30.glBindVertexArray;
    27. import static org.lwjgl.opengl.GL30.glGenVertexArrays;
    28.  
    29. public class Main {
    30.  
    31.     public static void main(String[] args){
    32.         new Main();
    33.     }
    34.  
    35.     private JFrame f;
    36.     private JTextField formelFeld;
    37.     private Canvas plotCanvas;
    38.     private JLabel formelAnzeige;
    39.     JSplitPane splitPane0;
    40.     int shader, plotVAO, plotIBO, indexCount;
    41.     private int modelMatrixLocation;
    42.     private int projectionMatrixLocation;
    43.     private FloatBuffer projectionMatrix;
    44.     private FloatBuffer modelMatrix;
    45.     //private Plot plot;
    46.     private int[] vaos = new int[3];
    47.    
    48.     public Main(){
    49.         try {
    50.             UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    51.             e.printStackTrace();
    52.         }
    53.        
    54.         f = new JFrame("Plotter");
    55.         f.setBounds(1000, 225, 600, 450);
    56.         f.setLayout(new BorderLayout());
    57.         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    58.        
    59.         formelFeld = new JTextField();
    60.         plotCanvas = new Canvas(){
    61.             private static final long serialVersionUID = 1L;
    62.             public final void addNotify() {
    63.                 super.addNotify();
    64.                 create3DEnvironment();
    65.             }
    66.             public final void removeNotify() {
    67.                 Display.destroy();
    68.                 super.removeNotify();
    69.             }
    70.         };;
    71.         formelAnzeige = new JLabel("Formeln");
    72.        
    73.         splitPane0 = new JSplitPane();
    74.         splitPane0.setLeftComponent(formelAnzeige);
    75.         splitPane0.setRightComponent(new JPanel().add(plotCanvas));
    76.        
    77.         JSplitPane splitPane = new JSplitPane();
    78.         splitPane.setOrientation(JSplitPane.VERTICAL_SPLIT);
    79.         splitPane.setDividerLocation((int)(f.getHeight()*0.8311d));
    80.         splitPane.setRightComponent(formelFeld);
    81.         splitPane.setLeftComponent(splitPane0);
    82.        
    83.         f.add(splitPane, BorderLayout.CENTER);
    84.         plotCanvas.setMinimumSize(new Dimension(0, 0));
    85.         plotCanvas.setFocusable(true);
    86.         plotCanvas.requestFocus();
    87.         plotCanvas.setIgnoreRepaint(true);
    88.         f.setVisible(true);
    89.        
    90.         try {
    91.             shader = createDefaultShader();
    92.         } catch (IOException e) {
    93.             e.printStackTrace();
    94.         }
    95.         setUniformPositions();
    96.         createPlot();
    97.        
    98.         renderLoop();
    99.     }
    100.  
    101.     private void createPlot() {
    102.         float[] points1 = {
    103.                 0, 0, 0,
    104.                 1, 0, 0
    105.         };
    106.        
    107.         FloatBuffer b1 = BufferUtils.createFloatBuffer(6);
    108.         b1.put(points1);
    109.         b1.flip();
    110.        
    111.         int vbo1 = Main.createVBO(b1);
    112.        
    113.         vaos[0] = glGenVertexArrays();
    114.         glBindVertexArray(vaos[0]);
    115.  
    116.         glBindBuffer(GL_ARRAY_BUFFER, vbo1);
    117.         glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0);
    118.         glEnableVertexAttribArray(0);
    119.        
    120.         float[] points2 = {
    121.                 0, 0, 0,
    122.                 0, 1, 0
    123.         };
    124.        
    125.         FloatBuffer b2 = BufferUtils.createFloatBuffer(6);
    126.         b2.put(points2);
    127.         b2.flip();
    128.        
    129.         int vbo2 = Main.createVBO(b2);
    130.        
    131.         vaos[1] = glGenVertexArrays();
    132.         glBindVertexArray(vaos[1]);
    133.  
    134.         glBindBuffer(GL_ARRAY_BUFFER, vbo2);
    135.         glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0);
    136.         glEnableVertexAttribArray(0);
    137.        
    138.         float[] points3 = {
    139.                 0, 0, 0,
    140.                 0, 0, 1
    141.         };
    142.        
    143.         FloatBuffer b3 = BufferUtils.createFloatBuffer(6);
    144.         b3.put(points3);
    145.         b3.flip();
    146.        
    147.         int vbo3 = Main.createVBO(b3);
    148.        
    149.         vaos[2] = glGenVertexArrays();
    150.         glBindVertexArray(vaos[2]);
    151.  
    152.         glBindBuffer(GL_ARRAY_BUFFER, vbo3);
    153.         glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0);
    154.         glEnableVertexAttribArray(0);
    155.     }
    156.  
    157.     private void setUniformPositions() {
    158.         modelMatrixLocation = GL20.glGetUniformLocation(shader, "model");
    159.         projectionMatrixLocation = GL20.glGetUniformLocation(shader, "projection");
    160.     }
    161.  
    162.     private void renderLoop() {
    163.         matrixMultiply(modelMatrix, rotate(0, 0, 1, -45));
    164.         while(f.isVisible()){
    165.             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    166.             glViewport(0, 0, 200, 200);
    167.             glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    168.             glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    169.             glUseProgram(shader);
    170.            
    171.             GL20.glUniformMatrix4(projectionMatrixLocation, false, projectionMatrix);
    172.             GL20.glUniformMatrix4(modelMatrixLocation, false, modelMatrix);
    173.            
    174.             for(int vao : vaos){
    175.                 glBindVertexArray(vao);
    176.                 glDrawArrays(GL_LINES, 0, 2);
    177.             }
    178.            
    179.             Display.update();
    180.         }
    181.         Display.destroy();
    182.         System.exit(0);
    183.     }
    184.  
    185.     private void create3DEnvironment() {
    186.         try {
    187.             final int GL_MAJOR_VERSION = 3;
    188.             final int GL_MINOR_VERSION = 3;
    189.        
    190.             final DisplayMode displayMode = new DisplayMode(plotCanvas.getWidth(), plotCanvas.getHeight());
    191.             final PixelFormat pixelFormat = new PixelFormat();
    192.             final ContextAttribs contextAttribs = new ContextAttribs(GL_MAJOR_VERSION, GL_MINOR_VERSION);
    193.        
    194.             Display.setParent(plotCanvas);
    195.             Display.setDisplayMode(displayMode);
    196.             Display.create(pixelFormat, contextAttribs);
    197.             Display.setResizable(true);
    198.             Display.setVSyncEnabled(true);
    199.         } catch (LWJGLException e) {
    200.             e.printStackTrace();
    201.         }
    202.         projectionMatrix = createFloatBuffer(projection(75.0f, 1, 0.1f, 100.0f));
    203.         modelMatrix = createFloatBuffer(einheitsMatrix());
    204.     }
    205.    
    206.     public static float[] einheitsMatrix(){
    207.         float[] m = new float[16];
    208.         m[0] = 1;
    209.         m[1] = 0;
    210.         m[2] = 0;
    211.         m[3] = 0;
    212.        
    213.         m[4] = 0;
    214.         m[5] = 1;
    215.         m[6] = 0;
    216.         m[7] = 0;
    217.        
    218.         m[8] = 0;
    219.         m[9] = 0;
    220.         m[10] = 1;
    221.         m[11] = 0;
    222.        
    223.         m[12] = 0;
    224.         m[13] = 0;
    225.         m[14] = 0;
    226.         m[15] = 1;
    227.         return m;
    228.     }
    229.    
    230.     public static float[] projection(final float fovy, final float aspect, final float zNear, final float zFar) {
    231.          
    232.         final double f = (1.0 / Math.tan(Math.toRadians(fovy / 2.0)));
    233.  
    234.         final float[] m = new float[16];
    235.  
    236.         m[0] = (float) (f / aspect);
    237.         m[5] = (float) (f);
    238.         m[10] = (zFar + zNear) / (zNear - zFar);
    239.         m[11] = (-1);
    240.         m[14] = (2 * zFar * zNear) / (zNear - zFar);
    241.         m[15] = 0;
    242.  
    243.         return m;
    244.     }
    245.    
    246.     public static FloatBuffer createFloatBuffer(float[] coords){
    247.         ByteBuffer vbb = ByteBuffer.allocateDirect(coords.length * 4);
    248.         vbb.order(ByteOrder.nativeOrder());
    249.         FloatBuffer vertexBuffer = vbb.asFloatBuffer();
    250.         vertexBuffer.put(coords);
    251.         vertexBuffer.position(0);
    252.         return vertexBuffer;
    253.     }
    254.  
    255.     public static int createVBO(FloatBuffer b){
    256.         int id = glGenBuffers();
    257.         glBindBuffer(GL_ARRAY_BUFFER, id);
    258.         glBufferData(GL_ARRAY_BUFFER, b, GL_STATIC_DRAW);
    259.         glBindBuffer(GL_ARRAY_BUFFER, 0);
    260.         return id;
    261.     }
    262.    
    263.     public static int createIBO(IntBuffer b){
    264.         int id = glGenBuffers();
    265.         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
    266.         glBufferData(GL_ELEMENT_ARRAY_BUFFER, b, GL_STATIC_DRAW);
    267.         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    268.         return id;
    269.     }
    270.    
    271.     public static float[] rotate(float x, float y, float z, float angle) {
    272.          
    273.         final float len = (float) Math.sqrt(x * x + y * y + z * z);
    274.         final float c = (float) Math.cos(Math.toRadians(angle));
    275.         final float s = (float) Math.sin(Math.toRadians(angle));
    276.  
    277.         x = x / len;
    278.         y = y / len;
    279.         z = z / len;
    280.  
    281.         final float[] m = new float[16];
    282.  
    283.         m[0] = x * x * (1 - c) + c;
    284.         m[1] = y * x * (1 - c) + z * s;
    285.         m[2] = x * z * (1 - c) - y * s;
    286.         m[4] = x * y * (1 - c) - z * s;
    287.         m[5] = y * y * (1 - c) + c;
    288.         m[6] = y * z * (1 - c) + x * s;
    289.         m[8] = x * z * (1 - c) + y * s;
    290.         m[9] = y * z * (1 - c) - x * s;
    291.         m[10] = z * z * (1 - c) + c;
    292.         m[15] = 1;
    293.  
    294.         return m;
    295.     }
    296.    
    297.     public static float[] scale(float x, float y, float z){
    298.         float[] mat = new float[16];
    299.         mat[0] = x;
    300.         mat[1] = 0;
    301.         mat[2] = 0;
    302.         mat[3] = 0;
    303.        
    304.         mat[4] = 0;
    305.         mat[5] = y;
    306.         mat[6] = 0;
    307.         mat[7] = 0;
    308.        
    309.         mat[8] = 0;
    310.         mat[9] = 0;
    311.         mat[10] = z;
    312.         mat[11] = 0;
    313.        
    314.         mat[12] = 0;
    315.         mat[13] = 0;
    316.         mat[14] = 0;
    317.         mat[15] = 1;
    318.        
    319.         return mat;
    320.     }
    321.    
    322.     public static void matrixMultiply(FloatBuffer b1, float[] o) {
    323.         float[] m = new float[b1.capacity()];
    324.         for(int i = 0; i < m.length; i++){
    325.             m[i] = b1.get(i);
    326.         }
    327.        
    328.         final float[] result = new float[16];
    329.  
    330.         result[0] = m[0] * o[0] + m[4] * o[1] + m[8] * o[2] + m[12] * o[3];
    331.         result[1] = m[1] * o[0] + m[5] * o[1] + m[9] * o[2] + m[13] * o[3];
    332.         result[2] = m[2] * o[0] + m[6] * o[1] + m[10] * o[2] + m[14] * o[3];
    333.         result[3] = m[3] * o[0] + m[7] * o[1] + m[11] * o[2] + m[15] * o[3];
    334.         result[4] = m[0] * o[4] + m[4] * o[5] + m[8] * o[6] + m[12] * o[7];
    335.         result[5] = m[1] * o[4] + m[5] * o[5] + m[9] * o[6] + m[13] * o[7];
    336.         result[6] = m[2] * o[4] + m[6] * o[5] + m[10] * o[6] + m[14] * o[7];
    337.         result[7] = m[3] * o[4] + m[7] * o[5] + m[11] * o[6] + m[15] * o[7];
    338.         result[8] = m[0] * o[8] + m[4] * o[9] + m[8] * o[10] + m[12] * o[11];
    339.         result[9] = m[1] * o[8] + m[5] * o[9] + m[9] * o[10] + m[13] * o[11];
    340.         result[10] = m[2] * o[8] + m[6] * o[9] + m[10] * o[10] + m[14] * o[11];
    341.         result[11] = m[3] * o[8] + m[7] * o[9] + m[11] * o[10] + m[15] * o[11];
    342.         result[12] = m[0] * o[12] + m[4] * o[13] + m[8] * o[14] + m[12] * o[15];
    343.         result[13] = m[1] * o[12] + m[5] * o[13] + m[9] * o[14] + m[13] * o[15];
    344.         result[14] = m[2] * o[12] + m[6] * o[13] + m[10] * o[14] + m[14] * o[15];
    345.         result[15] = m[3] * o[12] + m[7] * o[13] + m[11] * o[14] + m[15] * o[15];
    346.  
    347.         b1.clear();
    348.         b1.put(result);
    349.         b1.flip();
    350.     }
    351.    
    352.     public static String readFromFile(String datei) throws IOException{
    353.         String text;
    354.         BufferedReader br = new BufferedReader(new InputStreamReader(ShaderManager.class.getClassLoader().getResourceAsStream(datei)));
    355.         try {
    356.             StringBuilder sb = new StringBuilder();
    357.             String line = br.readLine();
    358.  
    359.             while (line != null) {
    360.                 sb.append(line);
    361.                 sb.append(System.lineSeparator());
    362.                 line = br.readLine();
    363.             }
    364.             text = sb.toString();
    365.         }finally {
    366.            br.close();
    367.         }
    368.         return text;
    369.     }
    370.    
    371.     public static int createDefaultShader() throws IOException{
    372.        
    373.         final int vs = glCreateShader(GL_VERTEX_SHADER);
    374.  
    375.         glShaderSource(vs, readFromFile("default.vertex"));
    376.         glCompileShader(vs);
    377.  
    378.         if (GL_FALSE == glGetShaderi(vs, GL_COMPILE_STATUS)) {
    379.  
    380.             final int length = glGetShaderi(vs, GL_INFO_LOG_LENGTH);
    381.             final String log = glGetShaderInfoLog(vs, length);
    382.  
    383.             throw new RuntimeException("Fehler: "+vs+" "+log);
    384.  
    385.         }
    386.        
    387.         final int fs = glCreateShader(GL_FRAGMENT_SHADER);
    388.  
    389.         glShaderSource(fs, readFromFile("default.fragment"));
    390.         glCompileShader(fs);
    391.  
    392.         if (GL_FALSE == glGetShaderi(fs, GL_COMPILE_STATUS)) {
    393.  
    394.             final int length = glGetShaderi(fs, GL_INFO_LOG_LENGTH);
    395.             final String log = glGetShaderInfoLog(fs, length);
    396.  
    397.             throw new RuntimeException("Fehler: "+fs+" "+log);
    398.  
    399.         }
    400.        
    401.         final int handle = glCreateProgram();
    402.  
    403.         glAttachShader(handle, vs);
    404.         glAttachShader(handle, fs);
    405.  
    406.         glLinkProgram(handle);
    407.  
    408.         if (GL_FALSE == glGetProgrami(handle, GL_LINK_STATUS)) {
    409.  
    410.             final int length = glGetProgrami(handle, GL_INFO_LOG_LENGTH);
    411.             final String log = glGetProgramInfoLog(handle, length);
    412.  
    413.             throw new RuntimeException("Fehler beim Programm: "+handle+" "+log);
    414.  
    415.         }
    416.        
    417.         return handle;
    418.     }
    419. }

    Die einfachsten Shader:

    Code:
    #version 330
    layout (location = 0) in vec3 in_Position;
    
    uniform mat4 projection;
    uniform mat4 model;
    
    void main(){
    	vec4 pos = projection*model*vec4(in_Position, 0);
        gl_Position = pos;
    }
    Code:
    #version 330
    
    out vec4 outColor;
    
    void main(){
    	outColor = vec4(1, 0, 0, 1);
    }
    Geändert von SlaterB (14.05.2016 um 20:12 Uhr) Grund: Titel

  2. #2
    User int Avatar von Sunshine
    Registriert seit
    31.07.2013
    Fachbeiträge
    59
    Genannt
    6 Post(s)
    Sollte im VertexShader nicht der Vektor mit einer 1 Angegeben sein, da es sich um eine Position handelt?
    Code:
    vec4 pos = projection*model*vec4(in_Position, 1.0);

  3. #3
    User Halbes Megabyte Themenstarter
    Avatar von Zombiepriester
    Registriert seit
    16.05.2013
    Fachbeiträge
    683
    Genannt
    18 Post(s)
    Ja, stimmt. Aber dann wird gar nichts mehr angezeigt. Trotzdem danke, ich hab mich immer gefragt ob das einen unterschied macht.

  4. #4
    User Halbes Megabyte Themenstarter
    Avatar von Zombiepriester
    Registriert seit
    16.05.2013
    Fachbeiträge
    683
    Genannt
    18 Post(s)
    Hat wirklich keiner eine Ahnung, was es sein könnte?

  5. #5
    Global Moderator Viertel Gigabyte
    Registriert seit
    05.08.2008
    Fachbeiträge
    4.950
    Genannt
    323 Post(s)
    So sieht's hier aus: LWJGL 3D Linien werden nicht gezeichnet-plotter01.png
    Wie soll es aussehen?

  6. #6
    User Halbes Megabyte Themenstarter
    Avatar von Zombiepriester
    Registriert seit
    16.05.2013
    Fachbeiträge
    683
    Genannt
    18 Post(s)
    Schon so, aber versuch doch mal Linien in schräge Z-Richtung oder so zu zeichnen (In der Funktion createPlot()).

  7. #7
    Global Moderator Viertel Gigabyte
    Registriert seit
    05.08.2008
    Fachbeiträge
    4.950
    Genannt
    323 Post(s)
    So?
    Java Code:
    1.  
    2.         float[] points1 = {
    3.                 0, 0, 0,
    4.                 1, 1, 0
    5.         };
    LWJGL 3D Linien werden nicht gezeichnet-plotter02.png

    *** Edit ***

    Das was Sunshine gesagt hat stimmt. Und wenn du das geändert hast, gib' deinen Punkten mal z-Werte von -5 oder so. Im Zweifelsfall stimmt da wohl irgendeine Transformationsmatrix nicht.

  8. #8
    User Halbes Megabyte Themenstarter
    Avatar von Zombiepriester
    Registriert seit
    16.05.2013
    Fachbeiträge
    683
    Genannt
    18 Post(s)
    Ich meine, dass wenn man einen Vektor in den Z-Raum gehen lässt, zum Beispiel:
    Java Code:
    1.  
    2. float[] points1 = {
    3.                 0, 0, 0,
    4.                 1, 1, 1
    5.         };
    Dass dieser dann überhaupt nicht angezeigt wird. Wie ich schon erwähnte, glaube ich es liegt an der Projektionsmatrix, aber die hab ich 1:1 aus einem anderen Projekt kopiert und da funktioniert es perfekt.

  9. #9
    Global Moderator Viertel Gigabyte
    Registriert seit
    05.08.2008
    Fachbeiträge
    4.950
    Genannt
    323 Post(s)
    Hast du irgendwie überprüft, ob deine Matrix-Funktionen (rotate und matrixMultiply) das richtige machen? Ich meine, wer genau soll seine Zeit damit verschwenden, das ganze zu debuggen, wenn der Fehler vielleicht an irgendsoeinem Trivial-Kack liegt? Mit
    Java Code:
    1.  
    2.         float[] points1 = {
    3.                 0, 0, -1f,
    4.                 1, 1, -2f
    5.         };
    zeichnet er was, mit
    Java Code:
    1.  
    2.         float[] points1 = {
    3.                 0, 0, 1f,
    4.                 1, 1, 2f
    5.         };
    zeichnet er nichts, also wird da wohl *händewedel* irgendwo irgendwas irgendwie so berechnet, dass es nicht richtig ist...

  10. #10
    User Viertel Megabyte
    Registriert seit
    30.07.2013
    Fachbeiträge
    302
    Genannt
    74 Post(s)
    Moin,

    hab mir den Code nicht wirklich angesehen oder ausprobiert und vielleicht schlafe ich noch, aber die OpenGL "Kamera" sitzt normalerweise im Koordinatenursprung mit Blickrichtung -Z. Negative Z Werte damit ein Objekt sichtbar wird scheint erst mal nicht so verkehrt. Verwunderlicher finde ich das was bei Z=0 gezeichnet wird, wenn zNear auf 0.1 gesetzt wird.

    Ansonsten scheint projection(), rotate() und matrixMultiply() von mir zu sein. Wobei zumindest letzteres modifiziert wurde.

    Gruß
    Fancy

  11. #11
    User Halbes Megabyte Themenstarter
    Avatar von Zombiepriester
    Registriert seit
    16.05.2013
    Fachbeiträge
    683
    Genannt
    18 Post(s)
    Oh Gott. Danke dafür. Ich hab wirklich das Gefühl ich bin raus, wenn mir sowas total offensichtliches nicht auffällt. Danke.

+ Antworten Thema als "gelöst" markieren

Direkt antworten Direkt antworten

Nenne ein bekanntes Betriebssystem!

Aktive Benutzer

Aktive Benutzer

Aktive Benutzer in diesem Thema: 1 (Registrierte Benutzer: 0, Gäste: 1)

Ähnliche Themen

  1. Antworten: 16
    Letzter Beitrag: 20.09.2015, 22:57
  2. Uhr wird nicht gezeichnet
    Von Haruka93 im Forum HTML / CSS / JavaScript / AJAX
    Antworten: 0
    Letzter Beitrag: 21.05.2015, 15:34
  3. (Schleifen) Werte werden nicht erhöht
    Von TheAceOfSpades im Forum Java-Grundlagen
    Antworten: 2
    Letzter Beitrag: 14.03.2014, 18:48
  4. Zitate werden nicht angezeigt
    Von darekkay im Forum Kritiken & Anregungen
    Antworten: 2
    Letzter Beitrag: 30.08.2013, 13:06

Berechtigungen

  • Neue Themen erstellen: Ja
  • Themen beantworten: Ja
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •