[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von mrbbc:
Wichtiger: es gibt SDL für AmigaOS.

---

Zitat:

---

Original von mrbbc:
Leider gibt es in der SDL keine Mausabfrage

---

[ - Antworten - Zitieren - Direktlink - ]

Versucht doch die FadingEffekte auch per SDL zu managen.
So ist ein Port sicherlich machbarer.
Die Beschleunigung könnt man dann ja hinterher Amiga-spezifisch integrieren.

Naja, ich red schon wieder wirr
--
SiegNatur

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Alybox

Klingt interessant, nur:was ist es ?

Gemessen an den Screens der anderen Spiele auf der Page, eine Art neues Denkspiel.
Cool....
--
SiegNatur

[ Dieser Beitrag wurde von westpdmkids am 04.02.2003 editiert. ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von westpdmkids:
Versucht doch die FadingEffekte auch per SDL zu managen.
So ist ein Port sicherlich machbarer.

---

Zitat:

---

Original von Mad_Dog:
Es gibt Storm MESA von Haage&Partner.
Das entspricht IMHO OpenGL V1.2 .

---

Danke für den Tipp! Da werde ich mich mal drum kümmern...

Deine Homepage konnte ich übrigens nicht aufrufen, ist die URL in Deinem Profil vielleicht nicht mehr aktuell?

Bye,

~Certain

---
visit http://www.tukult.de

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Mad_Dog:
Es gibt Storm MESA von Haage&Partner.
Das entspricht IMHO OpenGL V1.2 .

---

Danke für den Tipp! Da werde ich mich mal drum kümmern...

Deine Homepage konnte ich übrigens nicht aufrufen, ist die URL in Deinem Profil vielleicht nicht mehr aktuell?

[/quote]

Die URL ist aktuell!

http://www.norman-interactive.com


oder alternativ:

http://w3studi.informatik.uni-stuttgart.de/~walternn/


Da findest Du im Download-Bereich 100% portable OpenGL Source Codes,
die ich sowohl auf meinem Amiga 4000/030 mit Cybervision64/3D,
als auch auf einem PentiumIII/600 PC mit GForce 4 Graphikkarte unter
Red Hat Linux getestet habe (ohne eine Zeile Code zu ändern).

Im Aminet findest Du noch einige weitere Sources (samt 68k
Executables) von mir, bei denen zusammen mit OpenGL Teilen auch
Amiga-spezifisches Zeug verwendet wird.
Geb dazu einfach mal in die Aminet-Suchmaschine OpenGL ein.
Die Mesa-Version die Du im Aminet findest, ist übrigens nicht das
Storm Mesa, das ich meine.

Aminet URL: http://de.aminet.net

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von mrbbc:
Hmmm... da seh' ich keine bessere Lösung als das Alphablending von Hand zu Fuss zu programmieren...
Mit der SDL kann man ja direkt auf die Grafikdaten zugreifen.

---

Da liegt dann auch das Problem: wenn ich eine z.B. transparente Grafik auf eine andere blitten will, muss ich jeden Pixel, den ich übermalen will, vorher von der unteren Grafik einlesen. Tja, und dieser Lesevorgang ist bei Hardwaresurfaces leider ziemlich langsam unter SDL. Schneller wirds nur durch Softwaresurfaces, aber dann wird das Spiel insgesamt langsamer...

Zitat:

---

Original von mrbbc:
Läuft das Spiel in 8, 15, 16 oder 24 bpp ?

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Mad_Dog:
Was willst Du eigentlich machen? Fake-Lensflares und
Transparente Polygone, oder einfach nur nen Fade/Plasma Effekt?

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Certain:
Da liegt dann auch das Problem: wenn ich eine z.B. transparente Grafik auf eine andere blitten will, muss ich jeden Pixel, den ich übermalen will, vorher von der unteren Grafik einlesen. Tja, und dieser Lesevorgang ist bei Hardwaresurfaces leider ziemlich langsam unter SDL. Schneller wirds nur durch Softwaresurfaces, aber dann wird das Spiel insgesamt langsamer... ?

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von mrbbc:

Zitat:

---

Original von Certain:
Da liegt dann auch das Problem: wenn ich eine z.B. transparente Grafik auf eine andere blitten will, muss ich jeden Pixel, den ich übermalen will, vorher von der unteren Grafik einlesen. Tja, und dieser Lesevorgang ist bei Hardwaresurfaces leider ziemlich langsam unter SDL. Schneller wirds nur durch Softwaresurfaces, aber dann wird das Spiel insgesamt langsamer... ?

---

Zum einen könnte man die Grafikdaten komplett als Bitmap ausschneiden, zum anderen sollte man so oder so unbedingt eine Softwaresurface verwenden - für "flackerfreie Grafik".

Wenn die SDL-Implementierung diesbezüglich lahm wäre, müsste man allerdings einen eigenen logischen Bildschirm anlegen auf dem man werkelt, und den dann ständig in die Hardware rüberblitten.

Grundsätzlich sieht das dann flotter aus, obwohl es -zwar unwesentlich- länger braucht[1]; das Problem ist hier aber der Arbeitsaufwand. Die SDL-Funktionen selbst funktionieren ja nur in einer SDL_Surface.

Wenn man mehr braucht, als diese Blitting-Funktion, z.B. Linien und Text, dann könnt's haarig werden.

---

[ - Antworten - Zitieren - Direktlink - ]

code:

---

/*
 * Copyright (c) 1993-1997, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED 
 * Permission to use, copy, modify, and distribute this software for 

/*
 *  alpha.c
 *  This program draws several overlapping filled polygons
 *  to demonstrate the effect order has on alpha blending results.
 *  Use the 't' key to toggle the order of drawing polygons.
 */
#include <GL/glut.h>
#include <stdlib.h>

static int leftFirst = GL_TRUE;

/*  Initialize alpha blending function.
 */
static void init(void)
{
   glEnable (GL_BLEND);
   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glShadeModel (GL_FLAT);
   glClearColor (0.0, 0.0, 0.0, 0.0);
}

static void drawLeftTriangle(void)
{
   /* draw yellow triangle on LHS of screen */

   glBegin (GL_TRIANGLES);
      glColor4f(1.0, 1.0, 0.0, 0.75);
      glVertex3f(0.1, 0.9, 0.0); 
      glVertex3f(0.1, 0.1, 0.0); 
      glVertex3f(0.7, 0.5, 0.0); 
   glEnd();
}

static void drawRightTriangle(void)
{
   /* draw cyan triangle on RHS of screen */

   glBegin (GL_TRIANGLES);
      glColor4f(0.0, 1.0, 1.0, 0.75);
      glVertex3f(0.9, 0.9, 0.0); 
      glVertex3f(0.3, 0.5, 0.0); 
      glVertex3f(0.9, 0.1, 0.0); 
   glEnd();
}

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT);

   if (leftFirst) {
      drawLeftTriangle();
      drawRightTriangle();
   }
   else {
      drawRightTriangle();
      drawLeftTriangle();
   }

   glFlush();
}

void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   if (w <= h) 
      gluOrtho2D (0.0, 1.0, 0.0, 1.0*(GLfloat)h/(GLfloat)w);
   else 
      gluOrtho2D (0.0, 1.0*(GLfloat)w/(GLfloat)h, 0.0, 1.0);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 't':
      case 'T':
         leftFirst = !leftFirst;
         glutPostRedisplay();   
         break;
      case 27:  /*  Escape key  */
         exit(0);
         break;
      default:
         break;
   }
}

/*  Main Loop
 *  Open window with initial window size, title bar, 
 *  RGBA display mode, and handle input events.
 */
int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (200, 200);
   glutCreateWindow (argv[0]);
   init();
   glutReshapeFunc (reshape);
   glutKeyboardFunc (keyboard);
   glutDisplayFunc (display);
   glutMainLoop();
   return 0;
}

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Zum einen könnte man die Grafikdaten komplett als Bitmap ausschneiden, zum anderen sollte man so oder so unbedingt eine Softwaresurface verwenden - für "flackerfreie Grafik".

---

Zitat:

---

Wenn die SDL-Implementierung diesbezüglich lahm wäre, müsste man allerdings einen eigenen logischen Bildschirm anlegen auf dem man werkelt, und den dann ständig in die Hardware rüberblitten.

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Zum einen könnte man die Grafikdaten komplett als Bitmap ausschneiden, zum anderen sollte man so oder so unbedingt eine Softwaresurface verwenden - für "flackerfreie Grafik".

---

code:

---

/*  Turtle-Graphics Demo
 *  Norman Walter, Universität Stuttgart
 *  Rev. 1.1 (1.9.2001)
 */


#include <stdio.h>
#include <math.h>
#include <GL/glut.h>

struct Cursor
// Cursor Koordinaten und Winkel (="Blickrichtung")
{
 double X;  // Cursor X
 double Y;  // Cursor Y
 double A;  // Winkel
};

struct Cursor Turtle;

struct Destination
// Zielkoordinaten
{
  double X;  // Ziel X
  double Y;  // Ziel Y
};

struct Destination Target;

double go = 5.0;
double speedup = 25.0;

void malen(void);
void draw_lines(double X0, double Y0, double X1, double Y1);
void move(void);
void refresh(void);

int main(int argc, char **argv)
{
  // initialisierung des Cursors

  Turtle.X = 200.0;
  Turtle.Y = 150.0;
  // Turtle.A = 90.0;

  // initialisierung der Zielkoordinaten

  Target.X = 0.0;
  Target.Y = 0.0;

  glutInit(&argc, argv);

  // Double Buffer Mode
  glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);

  glutInitWindowSize(400,300);
  glutInitWindowPosition(100,100);
  glutCreateWindow("Turtle-Graphics");
  glClearColor(0.0, 0.0, 0.0, 0.0);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  glOrtho(-400.0, 400.0, -300.0, 300.0, -1.0, 1.0);
  glutDisplayFunc(&malen);

  glutIdleFunc(&refresh);
  glutMainLoop();

  return(0);
}

void malen(void)
{

  int i;
  double rotate;

  glClear(GL_COLOR_BUFFER_BIT);

  Turtle.X = 0.0;
  Turtle.Y = 0.0;
  Turtle.A = 90.0;

  for (i = 1; i < 1000; i++)
  {
    move();              // neue koordinaten berechnen
    Turtle.A += rotate;  // Cursor rotieren
    rotate += speedup;       // Rotationsgeschwindigkeit erhöhen

  // Hier wird die Funktion draw_lines aufgerufen
  // Eingabe X0, Y0, X1, Y1
  draw_lines(Turtle.X,Turtle.Y,Target.X,Target.Y);

  }

  glFinish();
  glutSwapBuffers();

}

void refresh(void)
{
 speedup += 1./3600.;
 glutPostRedisplay();
}

void draw_lines(double X0, double Y0, double X1, double Y1)
/* Zeichnet eine Linie */
{
    glBegin(GL_LINES);
    glColor3f(1.0,0.0,0.0);
    glVertex2f(X0,Y0);
    glVertex2f(X1,Y1);
    glEnd();

    // Cursor auf Zielkoordinaten verschieben
    Turtle.Y=Target.Y;
    Turtle.X=Target.X;
}

void move(void)
/* Berechnet neue Start- und Zielkoordinaten */
{
  Target.Y=sin(Turtle.A/180.0*PI)*go+Turtle.Y; // Delta Y
  Target.X=cos(Turtle.A/180.0*PI)*go+Turtle.X; // Delta X
}

---

code:

---

glutIdleFunc()

---

code:

---

glutMainLoop()

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Mad_Dog:
Das mit dem "Flackern" sollte kein Problem darstellen.

---

Zitat:

---

Da benutzt man dann einfach Double Buffering

---

Zitat:

---

Soll ich mal was zum Thema "Transparenz" hier posten?

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von mrbbc:

Zitat:

---

Original von Mad_Dog:
Das mit dem "Flackern" sollte kein Problem darstellen.

---

Das kann man meinem Posting entnehmen.

---

Zitat:

---

Zitat:

---

Da benutzt man dann einfach Double Buffering

---

Das dürfte das sein, was alle Grafikkarten schon seit der ersten "DirectX"-Karte intern beherrschen; und das ist genau das, was wir nicht brauchen können. Wir brauchen einen logischen Bildschirm, in den wir selbst schnell hinein fassen können.

Für die Grafikbeschleunigung ist das natürlich Schwachsinn. Die Grafikkarte kann ja nur in ihren eigenen Grafikspeicher grafikbeschleunigt zeichnen.

Was wir bräuchten - wenn wir das SDL-Blending von Hand programmieren - ist ein logischer Bildschirm, auf den wir direkt hinfassen können. Obwohl's wohl mit

---

Zitat:

---

Grundsätzlich weiss wohl jeder wie's geht; man kann aber den Algorithmus frisieren, wenn man z.B. Sonderfälle wie 50% gesondert behandelt. Mitunter ist auch z.B. >>1 schneller als /2...

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Mad_Dog:
Aber es gab IMHO auch auf dem PC schon lange vor DirectX
Grafikkarten, die einen Blitter hatten.

Wieso könnt Ihr das nicht brauchen? Natürlich ist es ne Bremse, wenn
Ihr mehr Ram braucht, als die Graphikkarte hat, aber selbst meine
uralte CyberVision hat 4 MB...

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Certain:

Zitat:

---

Original von mrbbc:
Hmmm... da seh' ich keine bessere Lösung als das Alphablending von Hand zu Fuss zu programmieren...
Mit der SDL kann man ja direkt auf die Grafikdaten zugreifen.

---

Da liegt dann auch das Problem: wenn ich eine z.B. transparente Grafik auf eine andere blitten will, muss ich jeden Pixel, den ich übermalen will, vorher von der unteren Grafik einlesen. Tja, und dieser Lesevorgang ist bei Hardwaresurfaces leider ziemlich langsam unter SDL. Schneller wirds nur durch Softwaresurfaces, aber dann wird das Spiel insgesamt langsamer...

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Man muß nicht die Daten aus dem Grafikspeicher lesen. Der besteht ohnehin nur aus den Bilder, die Du selbst dorthin gezeichnet hast. Man kann also auch genausogut versuchen, sich zu merken, welches Objekt man an welche Stelle gezeichnet hat, um die Transparenz direkt aus den originalen Bildern zu berechnen.

---

Das haben wir gedanklich auch schon mal durchgespielt. Hat sich schon in der Theorie nicht als sonderlich praktikabel erwiesen.

Aber wir arbeiten daran

Was das 'Mischen' von SDL und OpenGL angeht: soweit ich weiß, gibt es einige recht portable Engines, die das bis jetzt schon halbwegs erfolgreich praktiziert haben.

Ich wollte mich auch gerade mal für die wirklich umfangreiche Hilfe hier bedanken! Keine Frage, für jegliche Frage bzgl. Amiga-Coding ist man hier goldrichtig.


Bye,

~Certain

---
visit http://www.tukult.de

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]