I have found one error: I was not returning "true" from some
of my configInit() methods. Stefan, in eqPly, you sometimes
write code for configInit(), followed by a call to the parent class.
Usually, the parent class emthod shoudl be called first in case memory
is allocated and variables initialized. Perhaps it was an oversight.
Specifically, look at:
bool Window::configInit( const uint32_t initID )
{
if( !eq::Window::configInit( initID ))
return false;
EQASSERT( !_state );
_state = new VertexBufferState( getObjectManager( ));
const Node* node = static_cast< const Node* >( getNode( ));
const InitData& initData = node->getInitData();
if( initData.useVBOs() )
{
// Check if VBO funcs available, else leave DISPLAY_LIST_MODE on
if( GLEW_VERSION_1_5 )
{
_state->setRenderMode( mesh::BUFFER_OBJECT_MODE );
EQINFO << "VBO rendering enabled" << endl;
}
else
EQWARN << "VBO function pointers missing, using display lists"
<< endl;
}
_loadLogo();
if( initData.useGLSL() )
_loadShaders();
return true;
}
Gordon
Quoting Gordon Erlebacher <[EMAIL PROTECTED]>:
> Stefan,
>
> Here is my current program: with my own node, window and channel:
> The windows are NOT updating properly. I obviously do not understand
> what I am doing. Perhaps somebody can take a look? The problem has
> nothing to do with RapidMind. It occurs when plotting the original display
> from hello.cpp . I am not getting correct screen refresh, and somehow,
> there is interference between the display window and the window
> (terminal) from which I launch the appNode (./hello) . Strange.
>
> Gordon
>
>
>
>
>
> #include "life.h"
>
> // Copyright (c) 2007 RapidMind Inc. All Rights Reserved
> // All copies of this file must include the preceding copyright notice.
> //
> // Usage of this software requires acceptance and compliance with the
> RAPIDMIND
> // SAMPLE LICENSE, which is included in the LICENSE.TXT file. Any further
> // distribution of this file must include this license agreement.
> //////////////////////////////////////////////////////////////////////////////
>
> using namespace rapidmind;
> using namespace rapidmind::graphics;
> using namespace std;
>
> Life::Life(int size) : m_board(size, size)
> {
> m_update = RM_BEGIN {
> InOut<Value1i> RM_DECL(value);
> In<Value1i> neighbours[8];
>
> Value1i RM_DECL(count) = 0;
> for(int i = 0; i < 8; i++) {
> count += neighbours[i];
> }
>
> RM_IF(count < 2 || count > 3) {
> value = 0;
> } RM_ENDIF;
>
> RM_IF(count == 3) {
> value = 1;
> } RM_ENDIF;
>
> } RM_END;
>
> // initialize the board
> reset();
> }
> //----------------------------------------------------------------------
> void Life::reset()
> {
> int* data = m_board.write_data();
> for(unsigned int i = 0; i < product(m_board.size())[0]; i++) {
> data[i] = (rand() % 3) == 0;
> }
> }
> //----------------------------------------------------------------------
> void Life::update()
> {
> // use shifts to pass in the 8 surrounding neighbours of each cell
> m_board = m_update(m_board)
> (shift(m_board, -1, -1), shift(m_board, 0, -1), shift(m_board, 1, -1))
> (shift(m_board, -1, 0), shift(m_board, 1, 0))
> (shift(m_board, -1, 1), shift(m_board, 0, 1), shift(m_board, 1, 1));
> }
> //----------------------------------------------------------------------
> rapidmind::Array<2, rapidmind::Value1i>& Life::board()
> {
> return m_board;
> }
> //----------------------------------------------------------------------
>
>
>
> //----------------------------------------------------------------------
> void Life_GLSL::init_shaders()
> {
> // This is a simple pass through vertex program.
> Program vsh = RM_BEGIN_VERTEX_PROGRAM("semantic") {
> InOut<Position<Value2f> > pos; // from glVertex2f
> InOut<TexCoord<Value2f> > tex; // from glTexCoord2f
> } RM_END;
>
> Program fsh = RM_BEGIN_FRAGMENT_PROGRAM {
> In<TexCoord<Value2f> > tex;
> Value1i a = life.board()(tex);
> Out<Color<Value3f> > color = a*Value3f(1.0f);
> } RM_END;
>
> shaders = new ProgramSet(vsh, fsh);
> }
> //----------------------------------------------------------------------
> void Life_GLSL::display()
> {
> glClear(GL_COLOR_BUFFER_BIT);
>
> rapidmind::graphics::bind(*shaders);
>
> // Draw a rectangle over the entire window
> glBegin(GL_QUADS);
> // top left
> glTexCoord2f(0.0f, 0.0f);
> glVertex2f(-1.0f, 1.0f);
> // top right
> glTexCoord2f(1.0f, 0.0f);
> glVertex2f(1.0f, 1.0f);
> // bottom right
> glTexCoord2f(1.0f, 1.0f);
> glVertex2f(1.0f, -1.0f);
> // bottom left
> glTexCoord2f(0.0f, 1.0f);
> glVertex2f(-1.0f, -1.0f);
> glEnd();
>
> rapidmind::graphics::unbind();
>
> // glutSwapBuffers();
> }
> //----------------------------------------------------------------------
> void Life_GLSL::update()
> {
> static Timer last = Timer::now();
> Timer now = Timer::now();
>
> // update every 50ms (~20fps)
> if (!limit_fps || (now-last).value() > 50.0f) {
> // execute the Game of Life stream program
> life.update();
> last = now;
> //glutPostRedisplay();
> }
> }
> //----------------------------------------------------------------------
> [EMAIL PROTECTED] eqHelloGE]$ cat hello.cpp
>
> /* Copyright (c) 2007, Stefan Eilemann <[EMAIL PROTECTED]>
> * All rights reserved.
> *
> * Equalizer 'Hello, World!' example. Shows the minimum Equalizer
> program which
> * renders spinning quads around the origin.
> */
>
> #include <eq/eq.h>
> #include <stdlib.h>
> #include "life.h"
>
> using namespace eqBase;
> using namespace std;
>
> Life* glife;
> Life_GLSL* glife_glsl;
>
>
> //----------------------------------------------------------------------
> //Added by GE
> class MyWindow : public eq::Window
> {
> public:
> Life* life;
> Life_GLSL* life_glsl;
>
> public:
> MyWindow(eq::Pipe* pipe) : eq::Window(pipe) {
> printf("MyWindow::constructor\n");
> }
>
> //bool configInit( const uint32_t initID);
>
> bool configInitGL( const uint32_t initID)
> {
> if( !eq::Window::configInit( initID )) {
> printf("MyWindow did not inialize properly\n");
> return false;
> }
> printf("MyWindow::configInit\n");
> life = new Life(512);
> life_glsl = new Life_GLSL(*life);
> life_init();
>
> printf("glife= %d\n", glife);
> glife = life;
> printf("glife= %d\n", glife);
> glife_glsl = life_glsl;
> }
> void life_init() {
> rm::init();
> life = new Life(512);
> life_glsl = new Life_GLSL(*life);
> life_glsl->init_shaders();
> life_glsl->bind();
> }
> bool configExit()
> {
> printf("MyWindow::configExit\n");
> delete life;
> delete life_glsl;
> return eq::Window::configExit();
> }
> };
> //----------------------------------------------------------------------
> //ADDED by GE
> class MyNode : public eq::Node
> {
> public:
> Life* life;
> Life_GLSL* life_glsl;
> public:
> MyNode(eq::Config* parent) : eq::Node(parent) {
> printf("MyNode constructor\n");
> }
> bool configInit(const uint32_t initID) {
> if( !eq::Node::configInit( initID )) {
> printf("MyNode did not inialize properly\n");
> return false;
> }
> printf("MyNode:;configInit: initID= %d\n", initID);
> return true;
> }
> bool configExit()
> {
> printf("MyNode::configExit");
> return eq::Node::configExit();
> }
> #if 0
> void life_init() {
> //rm::init();
> life = new Life(512);
> life_glsl = new Life_GLSL(*life);
> life_glsl->init_shaders();
> life_glsl->bind();
> }
> #endif
> };
> //----------------------------------------------------------------------
> class Channel : public eq::Channel
> {
> public:
> rm::ProgramSetPtr shaders;
> rm::Program vsh, fsh;
>
> public:
> Channel( eq::Window* parent ) : eq::Channel( parent ) { }
>
> bool configInit(const uint32_t initID) {
> printf("inside channel constructor\n");
> printf("glife= %d\n", glife);
> vsh = RM_BEGIN_VERTEX_PROGRAM("semantic") {
> rm::InOut<rmg::Position<rm::Value2f> > pos; // from
> glVertex2f
> rm::InOut<rmg::TexCoord<rm::Value2f> > tex; // from
> glTexCoord2f
> } RM_END;
>
> fsh = RM_BEGIN_FRAGMENT_PROGRAM {
> rm::In<rmg::TexCoord<rm::Value2f> > tex;
> rm::Value1i a = glife->board()(tex);
> rm::Out<rmg::Color<rm::Value3f> > color =
> a*rm::Value3f(1.0f);
> } RM_END;
>
> shaders = new rm::ProgramSet(vsh, fsh);
>
> }
>
> protected:
> virtual void frameDraw( const uint32_t spin );
> };
> //----------------------------------------------------------------------
> class NodeFactory : public eq::NodeFactory
> {
> public:
> virtual eq::Window* createWindow(eq::Pipe* pipe)
> { return new MyWindow(pipe); }
> // channel needs glife, defined in MyWindow
> virtual eq::Node* createNode(eq::Config* parent)
> { return new MyNode(parent); }
> virtual eq::Channel* createChannel( eq::Window* parent )
> { return new Channel( parent ); }
> };
>
> //----------------------------------------------------------------------
> // This is a simple pass through vertex program.
>
>
>
>
>
>
> //----------------------------------------------------------------------
> // initialize this on the appropriate node or channel
>
> int main( const int argc, char** argv )
> {
>
> // 1. Equalizer initialization
> NodeFactory nodeFactory;
> if( !eq::init( argc, argv, &nodeFactory ))
> {
> EQERROR << "Equalizer init failed" << endl;
> return EXIT_FAILURE;
> }
>
> // 2. get a configuration
> bool error = false;
> eq::Config* config = eq::getConfig( argc, argv );
> if( config )
> {
> // 3. init config
> if( config->init( 0 )) {
> // 4. run main loop
> uint32_t spin = 0;
> while( config->isRunning( ))
> {
> config->startFrame( ++spin );
> config->finishFrame();
> }
>
> // 5. exit config
> config->exit();
> } else {
> EQERROR << "Config initialization failed: "
> << config->getErrorMessage() << endl;
> error = true;
> }
>
> // 6. release config
> eq::releaseConfig( config );
> }
> else
> {
> EQERROR << "Cannot get config" << endl;
> error = true;
> }
>
> // 7. exit
> eq::exit();
> return error ? EXIT_FAILURE : EXIT_SUCCESS;
> }
>
> /** The rendering routine, a.k.a., glutDisplayFunc() */
> void Channel::frameDraw( const uint32_t spin )
> {
> // setup OpenGL State
> eq::Channel::frameDraw( spin );
>
> #if 0
> glife_glsl->update(); // need better method than glife
> glife_glsl->display();
>
> glClear(GL_COLOR_BUFFER_BIT);
>
> glUseProgram(0);
> rapidmind::graphics::bind(*shaders);
>
> glOrtho(-2.,2.,-2.,2., 2.,-2.);
>
> // Draw a rectangle over the entire window
> glBegin(GL_QUADS);
> // top left
> glTexCoord2f(0.0f, 0.0f);
> glVertex2f(-1.0f, 1.0f);
> // top right
> glTexCoord2f(1.0f, 0.0f);
> glVertex2f(1.0f, 1.0f);
> // bottom right
> glTexCoord2f(1.0f, 1.0f);
> glVertex2f(1.0f, -1.0f);
> // bottom left
> glTexCoord2f(0.0f, 1.0f);
> glVertex2f(-1.0f, -1.0f);
> glEnd();
>
> rapidmind::graphics::unbind();
>
> #endif
>
> #if 1
> const float lightPos[] = { 0.0f, 0.0f, 1.0f, 0.0f };
> glLightfv( GL_LIGHT0, GL_POSITION, lightPos );
>
> const float lightAmbient[] = { 0.2f, 0.2f, 0.2f, 1.0f };
> glLightfv( GL_LIGHT0, GL_AMBIENT, lightAmbient );
>
> // rotate scene around the origin
> glRotatef( static_cast< float >( spin ) * 0.1f, 1.0f, 0.5f, 0.25f );
>
> // render six axis-aligned colored quads around the origin
> // front
> glColor3f( 1.0f, 0.5f, 0.5f );
> glNormal3f( 0.0f, 0.0f, 1.0f );
> glBegin( GL_TRIANGLE_STRIP );
> glVertex3f( .7f, .7f, -1.0f );
> glVertex3f( .7f, -.7f, -1.0f );
> glVertex3f( -.7f, .7f, -1.0f );
> glVertex3f( -.7f, -.7f, -1.0f );
> glEnd();
>
> // bottom
> glColor3f( 0.5f, 1.0f, 0.5f );
> glNormal3f( 0.0f, 1.0f, 0.0f );
> glBegin( GL_TRIANGLE_STRIP );
> glVertex3f( .7f, -1.0f, .7f );
> glVertex3f( .7f, -1.0f, -.7f );
> glVertex3f( -.7f, -1.0f, .7f );
> glVertex3f( -.7f, -1.0f, -.7f );
> glEnd();
>
> // back
> glColor3f( 0.5f, 0.5f, 1.0f );
> glNormal3f( 0.0f, 0.0f, -1.0f );
> glBegin( GL_TRIANGLE_STRIP );
> glVertex3f( .7f, .7f, 1.0f );
> glVertex3f( .7f, -.7f, 1.0f );
> glVertex3f( -.7f, .7f, 1.0f );
> glVertex3f( -.7f, -.7f, 1.0f );
> glEnd();
>
> // top
> glColor3f( 1.0f, 1.0f, 0.5f );
> glNormal3f( 0.f, -1.f, 0.f );
> glBegin( GL_TRIANGLE_STRIP );
> glVertex3f( .7f, 1.0f, .7f );
> glVertex3f( .7f, 1.0f, -.7f );
> glVertex3f( -.7f, 1.0f, .7f );
> glVertex3f( -.7f, 1.0f, -.7f );
> glEnd();
>
> // right
> glColor3f( 1.0f, 0.5f, 1.0f );
> glNormal3f( -1.f, 0.f, 0.f );
> glBegin( GL_TRIANGLE_STRIP );
> glVertex3f( 1.0f, .7f, .7f );
> glVertex3f( 1.0f, .7f, -.7f );
> glVertex3f( 1.0f, -.7f, .7f );
> glVertex3f( 1.0f, -.7f, -.7f );
> glEnd();
>
> // left
> glColor3f( 0.5f, 1.0f, 1.0f );
> glNormal3f( 1.f, 0.f, 0.f );
> glBegin( GL_TRIANGLE_STRIP );
> glVertex3f( -1.0f, .7f, .7f );
> glVertex3f( -1.0f, .7f, -.7f );
> glVertex3f( -1.0f, -.7f, .7f );
> glVertex3f( -1.0f, -.7f, -.7f );
> glEnd();
> #endif
> }
>
> ----------------------------------------------------------------
> This message was sent using IMP, the Internet Messaging Program.
Gordon Erlebacher
----------------------------------------------------------------
This message was sent using IMP, the Internet Messaging Program.
--
This message has been scanned for viruses and
dangerous content by MailScanner, and is
believed to be clean.
_______________________________________________
eq-dev mailing list
[email protected]
https://in-zueri.ch/cgi-bin/mailman/listinfo/eq-dev
http://www.equalizergraphics.com
