Пример #1
0
//--------------------------------------------------------------
void ofApp::setup(){
    
    W = 100;
    H = 100;
    
    for (int y=0; y<H; y++) {
        for (int x=0; x<W; x++) {
            mesh.addVertex(
                           ofPoint( (x - W/2) * 6, (y - H/2) * 6, 0 ) );
            mesh.addColor( ofColor( 0, 0, 0 ) );
        }
    }                                   //Set up vertices and colors
                                        //Set up triangles' indices
    for (int y=0; y<H-1; y++) {
        for (int x=0; x<W-1; x++) {
            int i1 = x + W * y;
            int i2 = x+1 + W * y;
            int i3 = x + W * (y+1);
            int i4 = x+1 + W * (y+1);
            mesh.addTriangle( i1, i2, i3 );
            mesh.addTriangle( i2, i4, i3 );
        }
    }
    
    setNormals( mesh );
    light.enable();

}
Пример #2
0
/*!
    Add \a quads - a series of one or more quads - to this builder.

    If \a quads has less than four vertices this function exits without
    doing anything.

    One normal per quad is calculated if \a quads does not have normals.
    For this reason quads should have all four vertices in the same plane.
    If the vertices do not lie in the same plane, use addTriangleStrip()
    to add two adjacent triangles instead.

    Since internally \l{geometry-building}{quads are stored as two triangles},
    each quad is actually divided in half into two triangles.

    Degenerate triangles are skipped in the same way as addTriangles().

    \sa addTriangles(), addTriangleStrip()
*/
void QGLBuilder::addQuads(const QGeometryData &quads)
{
    if (quads.count() < 4)
        return;
    QGeometryData q = quads;
    bool calcNormal = !q.hasField(QGL::Normal);
    if (calcNormal)
    {
        QVector3DArray nm(q.count());
        q.appendNormalArray(nm);
    }
    bool skip = false;
    int k = 0;
    QVector3D norm;
    for (int i = 0; i < q.count(); i += 4)
    {
        if (calcNormal)
            skip = qCalculateNormal(i, i+1, i+2, q, &norm);
        if (!skip)
            dptr->addTriangle(i, i+1, i+2, q, k);
        if (skip)
            skip = qCalculateNormal(i, i+2, i+3, q, &norm);
        if (!skip)
        {
            if (calcNormal)
                setNormals(i, i+2, i+3, q, norm);
            dptr->addTriangle(i, i+2, i+3, q, k);
        }
    }
    dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
Пример #3
0
static bool qCalculateNormal(int i, int j, int k, QGeometryData &p, QVector3D *vec = 0)
{
    QVector3D norm;
    QVector3D *n = &norm;
    if (vec)
        n = vec;
    bool nullTriangle = false;
    *n = QVector3D::crossProduct(p.vertexAt(j) - p.vertexAt(i),
                                   p.vertexAt(k) - p.vertexAt(j));
    if (qFskIsNull(n->x()))
        n->setX(0.0f);
    if (qFskIsNull(n->y()))
        n->setY(0.0f);
    if (qFskIsNull(n->z()))
        n->setZ(0.0f);
    if (n->isNull())
    {
        nullTriangle = true;
    }
    else
    {
        setNormals(i, j, k, p, *n);
    }
    return nullTriangle;
}
Пример #4
0
/*!
    Adds to this section a set of quads defined by \a strip.

    If \a strip has less than four vertices this function exits without
    doing anything.

    The first quad is formed from the 0'th, 2'nd, 3'rd and 1'st vertices.
    The second quad is formed from the 2'nd, 4'th, 5'th and 3'rd vertices,
    and so on, as shown in this diagram:

    \image quads.png

    One normal per quad is calculated if \a strip does not have normals.
    For this reason quads should have all four vertices in the same plane.
    If the vertices do not lie in the same plane, use addTriangles() instead.

    Since internally \l{geometry-building}{quads are stored as two triangles},
    each quad is actually divided in half into two triangles.

    Degenerate triangles are skipped in the same way as addTriangles().

    \sa addQuads(), addTriangleStrip()
*/
void QGLBuilder::addQuadStrip(const QGeometryData &strip)
{
    if (strip.count() < 4)
        return;
    QGeometryData s = strip;
    bool calcNormal = !s.hasField(QGL::Normal);
    if (calcNormal)
    {
        QVector3DArray nm(s.count());
        s.appendNormalArray(nm);
    }
    bool skip = false;
    QVector3D norm;
    int k = 0;
    for (int i = 0; i < s.count() - 3; i += 2)
    {
        if (calcNormal)
            skip = qCalculateNormal(i, i+2, i+3, s, &norm);
        if (!skip)
            dptr->addTriangle(i, i+2, i+3, s, k);
        if (skip)
            skip = qCalculateNormal(i, i+3, i+1, s, &norm);
        if (!skip)
        {
            if (calcNormal)
                setNormals(i, i+3, i+1, s, norm);
            dptr->addTriangle(i, i+3, i+1, s, k);
        }
    }
    dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
Пример #5
0
//-----------------------------------------------------------------------------------------
//
void ofApp::update()

{
    float time = ofGetElapsedTimef(); // time is equal to the amount of time passed
    // changes the vertices for each mesh at j
    for(int j=0; j<number; j++) {
        for(int y=0; y<h; y++) {
            for(int x=0; x<w; x++) {
                // vertex index
                int i = x + w * y;
                
                ofPoint pt = mesh[j].getVertex(i);
                float noise = ofNoise(x, y, time * 0.5); // Perlin noise value
                float rNoise = ofSignedNoise(x*0.5, y*0.3, time*0.1); // Creates a Perlin signed noise value for the red value of the mesh color
//  comment above line and uncomment line below for a variation of blue, purple, and red colors
//               float rNoise = ofSignedNoise(x*0.5, y*0.3, time);
                float bNoise = ofSignedNoise(x*0.5, y*0.3, time*0.1); // creates a Perlin signed noise value for the blue value of the mesh
                pt.z = noise ; // assigns noise to the z value so the noise affects the z space of the mesh
                
                
                mesh[j].setVertex(i, pt);
                mesh[j].setColor(i, ofColor(250*rNoise, 0, 250*bNoise)); // sets color of mesh
                // note: only using red and blue to make a purple color, then adding the rNoise and bNoise to change the values of red and blue to make different shades of purple
            }
        }
        
        setNormals(mesh[j]); // updates the normals for each mesh at j
    }
    
    
}
Пример #6
0
//http://www.packtpub.com/sites/default/files/9781849518048_Chapter_07.pdf
//knotExample
void ofApp::addCircle( ofVec3f nextPoint, ofMesh &mesh ){
    float time = ofGetElapsedTimef();    //Time
    //Parameters – twisting and rotating angles and color

    ofFloatColor color( ofNoise( time * 0.05 ),
                       ofNoise( time * 0.1 ),
                       ofNoise( time * 0.15 ));
    color.setSaturation( 1.0 );  //Make the color maximally
    
    //Add vertices
    for (int i=0; i<circleN; i++) {
        float angle = float(i) / circleN * TWO_PI+(PI*0.25);
        float x = Rad * cos( angle );
        float y = Rad * sin( angle );
        ofPoint p =    nextPoint+ofVec3f(x ,y , 0);
        mesh.addVertex( p );
        mesh.addColor( color );
    }
    //Add the triangles
    int base = mesh.getNumVertices() - 2 * circleN;
    if ( base >= 0 ) {  //Check if it is not the first step
        //and we really need to add the triangles
        for (int i=0; i<circleN; i++) {
            int a = base + i;
            int b = base + (i + 1) % circleN;
            int c = circleN  + a;
            int d = circleN  + b;
            mesh.addTriangle(a,b,d);
            mesh.addTriangle(a, d, c);
        }
        //Update the normals
        setNormals( mesh );
    }
}
Пример #7
0
//--------------------------------------------------------------
void ofxOcean::setupMesh(float W, float H, int gridSize){
    
    mesh.clear();
    mesh.setMode(OF_PRIMITIVE_TRIANGLES);
    mesh.clear();
    mesh.enableColors();
    mesh.enableIndices();
    mesh.enableNormals();
    mesh.disableTextures();
    
    //Set up vertices and colors
    bool odd = true;
    float offset = 0;
    for (int y=0; y<H; y+=gridSize) {
        for (int x=0; x<W; x+=gridSize) {
            
            if (odd) {
                if (x == 0) {
                    //mesh.addVertex(ofPoint(0, y, 0));
                    //mesh.addColor( ofColor( 0, 0, 0 ) );
                }
                offset = gridSize/2.0;
            } else {
                offset = 0;
            }
            mesh.addVertex(ofPoint(x+offset, y, 0));
            mesh.addColor( ofColor(255.f, 255.f, 255.f, 64.f) );
        }
        if (!odd){
            //mesh.addVertex(ofPoint(W-gridSize/2, y, 0));
            //mesh.addColor( ofColor( 0, 0, 0 ) );
        }
        odd = !odd;
    }
    
    //Set up triangles' indices
    odd = true;
    int numRows = H/gridSize;
    int numCols = W/gridSize;

    for (int y=0; y<numRows-1; y++) {
        for (int x=0; x<numCols-1; x++) {
            int i1 = x + numCols * y;
            int i2 = x+1 + numCols * y;
            int i3 = x + numCols * (y+1);
            int i4 = x+1 + numCols * (y+1);
            
            if (odd) {
                mesh.addTriangle( i1, i4, i3 );
                mesh.addTriangle( i1, i2, i4 );
            } else {
                mesh.addTriangle( i1, i2, i3 );
                mesh.addTriangle( i2, i4, i3 );
            }
        }
        odd = !odd;
    }
    setNormals( mesh );  //Set normals
    
}
Пример #8
0
/*!
    Add a series of quads by 'interleaving' \a top and \a bottom.

    This function behaves like quadStrip(), where the odd-numbered vertices in
    the input primitive are from \a top and the even-numbered vertices from
    \a bottom.

    It is trivial to do extrusions using this function:

    \code
    // create a series of quads for an extruded edge along -Y
    addQuadsInterleaved(topEdge, topEdge.translated(QVector3D(0, -1, 0));
    \endcode

    N quad faces are generated where \c{N == min(top.count(), bottom.count() - 1}.
    If \a top or \a bottom has less than 2 elements, this functions does
    nothing.

    Each face is formed by the \c{i'th} and \c{(i + 1)'th}
    vertices of \a bottom, followed by the \c{(i + 1)'th} and \c{i'th}
    vertices of \a top.

    If the vertices in \a top and \a bottom are the perimeter vertices of
    two polygons then this function can be used to generate quads which form
    the sides of a \l{http://en.wikipedia.org/wiki/Prism_(geometry)}{prism}
    with the polygons as the prisms top and bottom end-faces.

    \image quad-extrude.png

    In the diagram above, the \a top is shown in orange, and the \a bottom in
    dark yellow.  The first generated quad, (a, b, c, d) is generated in
    the order shown by the blue arrow.

    To create such a extruded prismatic solid, complete with top and bottom cap
    polygons, given just the top edge do this:
    \code
    QGeometryData top = buildTopEdge();
    QGeometryData bottom = top.translated(QVector3D(0, 0, -1));
    builder.addQuadsInterleaved(top, bottom);
    builder.addTriangulatedFace(top);
    builder.addTriangulatedFace(bottom.reversed());
    \endcode
    The \a bottom QGeometryData must be \b{reversed} so that the correct
    winding for an outward facing polygon is obtained.
*/
void QGLBuilder::addQuadsInterleaved(const QGeometryData &top,
                                     const QGeometryData &bottom)
{
    if (top.count() < 2 || bottom.count() < 2)
        return;
    QGeometryData zipped = bottom.interleavedWith(top);
    bool calcNormal = !zipped.hasField(QGL::Normal);
    if (calcNormal)
    {
        QVector3DArray nm(zipped.count());
        zipped.appendNormalArray(nm);
    }
    bool skip = false;
    QVector3D norm;
    int k = 0;
    for (int i = 0; i < zipped.count() - 2; i += 2)
    {
        if (calcNormal)
            skip = qCalculateNormal(i, i+2, i+3, zipped, &norm);
        if (!skip)
            dptr->addTriangle(i, i+2, i+3, zipped, k);
        if (skip)
            skip = qCalculateNormal(i, i+3, i+1, zipped, &norm);
        if (!skip)
        {
            if (calcNormal)
                setNormals(i, i+3, i+1, zipped, norm);
            dptr->addTriangle(i, i+3, i+1, zipped, k);
        }
    }
    dptr->currentNode->setCount(dptr->currentNode->count() + k);
}
Пример #9
0
//--------------------------------------------------------------
void ofApp::setup(){
    
    gridWidth = 200;
    gridHeight = 200;
    
    // set up the vertices and colors
    //first on the y axis
    for(int y = 0; y < gridWidth; y++){
        //now on the x axis
        for(int x = 0; x < gridHeight; x++){
            myMesh.addVertex(ofPoint((x-gridWidth*0.5)*6, (y-gridHeight*0.5)*6, 0));
            myMesh.addColor(ofColor(0,0,0));
        }
    }
    
    // set up triangles indices
    //first on the y axis
    for(int y = 0; y < gridWidth - 1; y++){
        //now on the x axis
        for(int x = 0; x < gridHeight -1; x++){
            i1 = x + gridWidth * y;
			i2 = x+1 + gridWidth * y;
			i3 = x + gridWidth * (y+1);
			i4 = x+1 + gridWidth * (y+1);
            myMesh.addTriangle( i1, i2, i3);
            myMesh.addTriangle( i2, i4, i3);
        }
    }
    setNormals(myMesh);
    myLight.enable();

}
Пример #10
0
//--------------------------------------------------------------
void ofApp::setup(){
	//Pyramid's base vertices with indices 0, 1, 2
	mesh.addVertex( ofPoint( -200, -100, -50 ) );
	mesh.addVertex( ofPoint( 200, -100, -50 ) );
	mesh.addVertex( ofPoint( 0, 200, 0 ) );

	//Pyramid's top vertex with index 3
	mesh.addVertex( ofPoint( 0, 0, 50 ) );

	//Vertices with indices 3, 2, 0
	mesh.addTriangle( 3, 2, 0 );

	//Vertices with indices 3, 1, 2
	mesh.addTriangle( 3, 1, 2 ); 

	//Vertices with indices 3, 0, 1
	mesh.addTriangle( 3, 0, 1 );

	setNormals( mesh );			//Set normals to the surface
	//Note, setNormals is our function, 
	//which is declared 

	//Enabling light source
	light.enable();
}
Пример #11
0
void Terrain::setBezierMode(bool draw_bezier)
{
    if(this->draw_bezier != draw_bezier)
    {
        this->draw_bezier = draw_bezier;
        draw_bezier ? setNormalsBezier() : setNormals();
    }
}
Пример #12
0
//-----------------------------------------------------------------------------------------
//
void ofApp::setup()
{
	fontSmall.loadFont("Fonts/DIN.otf", 8 );
    //resolution
    W = 300;
    H = 300;
    
	camera.setNearClip(0.01f);
    //the starting point of the camera
    camera.setPosition( 0, 20 , 180 );
	camera.setMovementMaxSpeed( 0.1f );
   
    //material and light setup
    material.setShininess( 100 );
    material.setSpecularColor(ofColor(40, 100,255,  250));
    
    pointLight.setDiffuseColor( ofFloatColor(.85, .85, .55) );
    pointLight.setSpecularColor( ofFloatColor(1.f, 1.f, 1.f));
    
    pointLight2.setDiffuseColor( ofFloatColor( 238.f/255.f, 57.f/255.f, 135.f/255.f ));
    pointLight2.setSpecularColor(ofFloatColor(.8f, .8f, .9f));
    
    pointLight3.setDiffuseColor( ofFloatColor(40.f/255.f,110/255.f,135.f/255.f) );
    pointLight3.setSpecularColor( ofFloatColor(.2, .2, .2) );
    
    //initialize points and color to the mesh
    for(int x = 0; x < W; x++){
        for (int y = 0; y< H; y++){
            
            ofPoint vert = ofPoint(x - W/2 , y - H/2, 0);
            mesh.addVertex(vert);
            mesh.addColor( ofColor( 0, 0, 0 ) );
        }
        
        
    }
    
    //initializ small triangles that make up the mesh
    for (int x = 0 ; x < W-1; x ++) {
        for (int y= 0; y < H-1; y++) {
            
            int index1 = x * W + y;
            int index2 = (x+1) * W + y;
            int index3 = x * W+(y+1);
            int index4 = (x+1) * W + (y + 1);
            
            mesh.addTriangle(index1, index2, index3);
            mesh.addTriangle(index3, index2, index4);
        }
        
    }
    
    setNormals(mesh);
    
}
Пример #13
0
TriangleFace::TriangleFace(const Ric::Vector &v0, const Ric::Vector &v1, const Ric::Vector &v2, const Ric::Material &material)
  : material_(material),
    v0_(v0),
    v1_(v1),
    v2_(v2),
    fc_((v0+v1+v2)/3),
    n_(((v1-v0)^(v2-v0)).Normalized()),
    area_(((v1-v0)^(v2-v0)).Length()),
    vertex_texture_coord(false),
    vertex_normal_(false)
{
  setNormals(n_,n_,n_);
}
Пример #14
0
//-----------------------------------------------------------------------------------------
//
void ofApp::update()
{
    float time = ofGetElapsedTimef();

    for (int y=0; y<H; y++) {
        for (int x=0; x<W; x++) {
            int i = x + W * y;			//Vertex index
            ofPoint p = mesh.getVertex( i );

            //the following equation is based on the linear theory of ocean surface waves
            // assuming the amplitude of waves on the water surface is infinitely small so the surface is almost exactly a plane. To simplify the mathematics, we can also assume that the flow is 2-dimensional with waves traveling in the x-direction.
            //read more details on http://oceanworld.tamu.edu/resources/ocng_textbook/chapter16/chapter16_01.htm
            
            freq = sqrt(g * k);
            float height = amp * sin(k * x - freq * time * 2);

            // the z position of each mesh vertex are determined by the x position, the height that's caculated by the linear theory of the ocean suface wave, and ofSignedNoise, which returns a number between -1 and 1
            p.z  = (W-x)/7.f * ofSignedNoise(height * .001, y*.007, height)+ofSignedNoise(x * .01, y*.08, height);
            
          //  p.z  = (W-x)/15.f * height * ofSignedNoise(height * .001, y*.007 );
                
            mesh.setVertex( i, p );
            
            //The color of vertex changes as the z position goes up and down
            mesh.setColor(i, ofFloatColor( (abs(height) + .5) * 30/255.f,
                                          (abs(height) + .5) * 80/255.f,
                                          (abs(height) + .5)*100/255.f));
            
//            mesh.setColor( i, ofFloatColor(
//                                ofMap(height, amp, -amp, 60, 100)/255.f,
//                               1- ofMap(height, amp, -amp, 200, 250)/255.f,
//                                ofMap(height, amp, -amp, 200, 250)/255.f
//                                           ));
       
            
        }
    }
    setNormals( mesh );
    
    //the light moves position and changes color
    pointLight.setPosition((ofGetWidth()*.5)+ cos(ofGetElapsedTimef()*.5)*(ofGetWidth()*.3), ofGetHeight()/2, 500);
    pointLight2.setPosition((ofGetWidth()*.5)+ cos(ofGetElapsedTimef()*.15)*(ofGetWidth()*.3),
                            ofGetHeight()*.5 + sin(ofGetElapsedTimef()*.7)*(ofGetHeight()), -300);
    
    pointLight3.setPosition(
                            cos(ofGetElapsedTimef()*1.5) * ofGetWidth()*.5,
                            sin(ofGetElapsedTimef()*1.5f) * ofGetWidth()*.5,
                            cos(ofGetElapsedTimef()*.2) * ofGetWidth()
                            );
 
}
Пример #15
0
//-----------------------------------------------------------------------------
// build a surface 
void Wreck::buildSurface(
  mgBezier& bodySpline,
  double bodyScale,
  int bodySteps,
  mgBezier& lenSpline,
  double lenScale,
  int lenSteps,
  const mgMatrix4& xform,
  BOOL outwards,
  int texture)
{
  double bodyLen = bodySpline.getLength();
  double lenLen = lenSpline.getLength();

  mgVertexTA* points = new mgVertexTA[(bodySteps+1) * (lenSteps+1)];

  mgPoint3 lenPt, bodyPt, xpt;
  for (int i = 0; i <= lenSteps; i++)
  {
    lenSpline.splinePt((lenLen * i)/lenSteps, lenPt);
    double ht = lenPt.y - lenPt.z;
    for (int j = 0; j <= bodySteps; j++)
    {
      bodySpline.splinePt((bodyLen * j)/bodySteps, bodyPt);

      mgVertexTA* v = &points[i*(bodySteps+1)+j];
      mgPoint3 pt(lenScale * (ht * bodyScale * bodyPt.x), 
                  lenScale * (lenPt.z + ht * bodyScale * bodyPt.y), 
                  lenScale * lenPt.x);
      xform.mapPt(pt, xpt);
      v->setPoint(xpt.x, xpt.y, xpt.z);

      v->setTexture(2*j/(double) bodySteps, 2*i/(double) lenSteps, texture);
    }
  }

  // set all the normals
  setNormals(points, lenSteps+1, bodySteps+1, outwards);

  int vertexBase = m_vertexes->getLength();
  for (int i = 0; i < (lenSteps+1)*(bodySteps+1); i++)
    m_vertexes->addVertex(&points[i]);

  m_indexes->addGrid(vertexBase, bodySteps+1, lenSteps, bodySteps, outwards);

  delete points;
}
Пример #16
0
void Terrain::heighten(int y){
    int scaleFact = .1;
    if(y<0){
        scaleFact *= -1;
    }
    max_height = 0;
    
    
    for(int w = 0; w < width; w++){
        for(int h = 0; h< height; h++){
            (coords[w][h])[1] += height_map[3*(w*width+h)+1]*scaleFact;
            if((coords[w][h])[1] > max_height)
                max_height = (coords[w][h])[1];
        }
    }
    setNormals();
}
Пример #17
0
    void ModelMD2::prepareFrame() {
#ifdef DEBUG
        static bool isFirst = true;
        if (isFirst) {
            printf("Call ModelMD2::prepareFrame()...\n");
            isFirst = false;
        }
#endif
        if (m_actionIdx == -1)
            return;

        float *uvs = (float *) malloc(m_header.numTriangles * 6 * sizeof(float));
        float *vertices = (float *) malloc(m_header.numTriangles * 9 * sizeof(float));
        float *normals = (float *) malloc(m_header.numTriangles * 9 * sizeof(float));
        int i, j, uvIdx = 0, vertexIdx = 0, normalIdx = 0;

        md2_frame_t *f = &m_frames[m_frameIdx];

        for (i = 0; i < m_header.numTriangles; i++) {
            md2_triangle_t *t = &m_triangles[i];
            for (j = 0; j < 3; j++) {
                //set uvs
                uvs[uvIdx++] = (float) m_texCoords[t->textureIndices[j]].s / (float) m_header.skinWidth;
                uvs[uvIdx++] = 1.0f - (float) m_texCoords[t->textureIndices[j]].t / (float) m_header.skinHeight;
                //set vertices & normals
                vertices[vertexIdx++] = f->vertices[t->vertexIndices[j]].vertex[0];
                vertices[vertexIdx++] = f->vertices[t->vertexIndices[j]].vertex[1];
                vertices[vertexIdx++] = f->vertices[t->vertexIndices[j]].vertex[2];

                normals[normalIdx++] = f->vertices[t->vertexIndices[j]].normal[0];
                normals[normalIdx++] = f->vertices[t->vertexIndices[j]].normal[2];
                normals[normalIdx++] = f->vertices[t->vertexIndices[j]].normal[1];
            }
        }
        setVertices(vertices, m_header.numTriangles * 9 * sizeof(float));
        setNormals(normals, m_header.numTriangles * 9 * sizeof(float));
        setUvs(uvs, m_header.numTriangles * 6 * sizeof(float));

        FREEANDNULL(vertices);
        FREEANDNULL(normals);
        FREEANDNULL(uvs);

        m_frameIdx++;
        if (m_frameIdx > m_actions[m_actionIdx].max_idx)
            m_frameIdx = m_isLooped ? m_actions[m_actionIdx].min_idx : m_actions[m_actionIdx].max_idx;
    }
Пример #18
0
//-----------------------------------------------------------------------------------------
//
void ofApp::setup()
{
	fontSmall.loadFont("Fonts/DIN.otf", 8 );
	
	// Give us a starting point for the camera
	camera.setNearClip(0.01f);
	camera.setPosition( 0, 4, 40 );
	camera.setMovementMaxSpeed( 0.1f );
    
    h = 30; // initializing height for the height of the mesh
    w = 30; // initializing width for the width of the mesh
    // sets up vertices and colors of each mesh at i
    for(int i=0; i<number; i++) {
        for(int y=0; y<h; y++) {
            for(int x=0; x<w; x++) {
                mesh[i].addVertex(ofPoint((x-w/2), (y-h/2), 0));
                mesh[i].addColor(ofColor(255, 255, 255));
            }
        }
        // sets up the indices of triangles to make a grid of triangles
        for(int y=0; y<h-1; y++) {
            for(int x=0; x<w-1; x++) {
                
                int index1 = x + w * y;
                int index2 = x+1 + w * y;
                int index3 = x + w * (y+1);
                int index4 = x+1 + w * (y+1);
                
                mesh[i].addTriangle(index1, index2, index3);
                mesh[i].addTriangle(index2, index4, index3);
            }
        }
        
            setNormals(mesh[i]); // sets normals to surface
    }
   
    

    
    
    light1.enable(); // enables light
    
    
	
}
Пример #19
0
//--------------------------------------------------------------
void testApp::setup(){
    //Set up vertices and colors
    for (int y=0; y<H; y++) {
        for (int x=0; x<W; x++) {
            mesh.addVertex(
                           ofPoint( (x - W/2) * 12*4, (y - H/2) * 12*4, 0 ) );
            mesh.addColor( ofColor( 0, 255, 0 ) );
        }
    }
    //Set up triangles' indices
    for (int y=0; y<H-1; y++) {
        for (int x=0; x<W-1; x++) {
            int i1 = x + W * y;
            int i2 = x+1 + W * y;
            int i3 = x + W * (y+1);
            int i4 = x+1 + W * (y+1);
            mesh.addTriangle( i1, i2, i3 );
            mesh.addTriangle( i3, i1, i2 );
        }
    }
    setNormals( mesh );		//Set normals
//    light.enable();			//Enable lighting
    
    
    
    // listen on the given port
    //**********************************************
    //**********************************************
//    cout << "listening for osc messages on port " << PORT << "\n";
    receiver.setup(PORT);
    
    ofBackground(30, 30, 130);
    
    nBandsToUse = 1024;
    receivedFft = new float[nBandsToUse];
    for (int i = 0; i < nBandsToUse; i++){
        receivedFft[i] = 0;
    }
    //**********************************************
    //**********************************************
    


}
Пример #20
0
//-----------------------------------------------------------------------------
// create ring
void Wreck::createRing(
  mgMatrix4& xform,
  int ringSteps,
  int circleSteps)
{
  mgBezier ringSpline;
  ringSpline.addVertex(mgPoint3(  0.0,  4.0,  0.0),     mgPoint3(  0.0+13,  4.0,       0.0));
  ringSpline.addVertex(mgPoint3( 13.0,  0.0,  0.0),     mgPoint3( 13.0,     0.0+4,     0.0));
  ringSpline.addVertex(mgPoint3(  0.0, -4.0,  0.0),     mgPoint3(  0.0+13, -4.0,       0.0));

  double ringLen = ringSpline.getLength();

  mgVertexTA* points = new mgVertexTA[(ringSteps+1) * (circleSteps+1)];

  mgPoint3 ringPt, xpt;
  for (int i = 0; i <= circleSteps; i++)
  {
    double angle = (i*2*PI)/circleSteps;
    for (int j = 0; j <= ringSteps; j++)
    {
      ringSpline.splinePt((ringLen * j)/ringSteps, ringPt);

      mgVertexTA* v = &points[i*(ringSteps+1)+j];
      mgPoint3 pt(cos(angle) * ringPt.x, 
                  sin(angle) * ringPt.x,
                  ringPt.y);
      xform.mapPt(pt, xpt);
      v->setPoint(xpt.x, xpt.y, xpt.z);

      v->setTexture(xpt.z/100 + 2*j/(double) ringSteps, 2*i/(double) circleSteps, 0);
    }
  }

  // set all the normals
  setNormals(points, circleSteps+1, ringSteps+1, true);

  int vertexBase = m_vertexes->getLength();
  for (int i = 0; i < (circleSteps+1)*(ringSteps+1); i++)
    m_vertexes->addVertex(&points[i]);

  m_indexes->addGrid(vertexBase, ringSteps+1, circleSteps, ringSteps, true);

  delete points;
}
Пример #21
0
void PyramidBrush::setup() {
    parameters.setName("PyramidBrush");
    parameters.add(historyMax.set("historyMax", 2000, 100, 10000));
    parameters.add(brushType.set("type line", 0, 0, 1));
    parameters.add(size.set("size", 1, 0, 2));
    parameters.add(opacity.set("opacity", 20, 0, 255));
    parameters.add(lineWidth.set("lineWidth", 0.2, 0., 5.));
    parameters.add(swatch.set("swatch", 0, 0, 12));
    parameters.add(bgColor.set("bgColor", ofColor(0, 0), ofColor(0, 0), ofColor(255, 255)));
    parameters.add(activeColor.set("activeColor", ofColor(0, 0), ofColor(0, 0), ofColor(255, 255)));
    parameters.add(col1.set("col1", ofColor(0, 0), ofColor(0, 0), ofColor(255, 255)));
    parameters.add(col2.set("col2", ofColor(0, 0), ofColor(0, 0), ofColor(255, 255)));
    parameters.add(col3.set("col3", ofColor(0, 0), ofColor(0, 0), ofColor(255, 255)));
    
    ofPoint v0 = ofPoint( -200, -100, 0 );
    ofPoint v1 = ofPoint( 200, -100, 0 );
    ofPoint v2 = ofPoint( 0, 200, 0 );
    //Pyramid's top vertex
    ofPoint v3 = ofPoint( 0, 0, 500 );
    //Add triangles by its vertices
    mesh.addVertex( v3 ); mesh.addVertex( v2 );
    mesh.addVertex( v0 ); mesh.addVertex( v3 );
    mesh.addVertex( v1 ); mesh.addVertex( v2 );
    mesh.addVertex( v3 ); mesh.addVertex( v0 );
    mesh.addVertex( v1 );
    
    mesh.setupIndicesAuto(); //Set up indices
   setNormals(mesh);
   //light.enable();
    
    mesh.addTexCoord( ofPoint( 100, 100 ) );  //v3
    mesh.addTexCoord( ofPoint( 10, 300 ) );   //v2
    mesh.addTexCoord( ofPoint( 10, 10 ) );    //v0
    mesh.addTexCoord( ofPoint( 100, 100 ) );  //v3
    mesh.addTexCoord( ofPoint( 300, 10 ) );   //v1
    mesh.addTexCoord( ofPoint( 10, 300 ) );   //v2
    mesh.addTexCoord( ofPoint( 100, 100 ) );   //v3
    mesh.addTexCoord( ofPoint( 10, 10 ) );     //v0
    mesh.addTexCoord( ofPoint( 300, 10 ) );    //v1
    ofLoadImage(meshTex, "knife.jpg");
    
    return;
}
Пример #22
0
//--------------------------------------------------------------
void testApp::setup(){
	//Pyramid's base vertices
	ofPoint v0 = ofPoint( -200, -100, 0 );
	ofPoint v1 = ofPoint( 200, -100, 0 );
	ofPoint v2 = ofPoint(  0, 200, 0 );
	//Pyramid's top vertex
	ofPoint v3 = ofPoint( 0, 0, 100 );

	//Add triangles by its vertices
	mesh.addVertex( v3 ); mesh.addVertex( v2 ); mesh.addVertex( v0 );
	mesh.addVertex( v3 ); mesh.addVertex( v1 ); mesh.addVertex( v2 );
	mesh.addVertex( v3 ); mesh.addVertex( v0 ); mesh.addVertex( v1 );
	mesh.setupIndicesAuto();	//Set up indices

	setNormals( mesh );			//Set normals to the surface
	//Note, setNormals is our function, 
	//which is declared 

	//Enabling light source
	light.enable();
}
Пример #23
0
bool Terrain::init(const char * ppmFile){
    height_map = Texture::loadPPM(ppmFile, width, height);
    /*
     Create a 1024*1024 array of vertex coordinates (Vector3). Populate the
     array as follows: the x values should correspond to the array's x index,
     the z values to the y index. For example: Vector3[x][y].x = x,
     Vector3[x][y].z = y. The y value should be the corresponding value from
     the height map array (Vector3[x][y].y = heightmap[x][y]).
     */
    for(int x = 0; x < width; x++){
        for(int y = 0; y < height; y++){
            coords[x][y] = Vector3(x, height_map[3*(x*height + y)], y);
            if((coords[x][y])[1] > max_height)
                max_height = (coords[x][y])[1];
        }
    }
    
    setNormals();
    update_levels(0);
    return true;
}
Пример #24
0
//--------------------------------------------------------------
void ofApp::update(){
    float time = ofGetElapsedTimef();	//Get time
	//Change vertices
	for (int y=0; y<gridHeight; y++) {
		for (int x=0; x<gridWidth; x++) {
			int i = x + gridWidth * y;			//Vertex index
			ofPoint p = myMesh.getVertex( i );
            
			//Get Perlin noise value
			float value = ofNoise( x * 0.05, y * 0.05, time * 0.5 );
            
			//Change z-coordinate of vertex
			p.z = value * 100;
			myMesh.setVertex( i, p );
            
			//Change color of vertex
			myMesh.setColor( i, ofColor( value*255, value * 255, 255 ) );
		}
	}
	setNormals( myMesh );	//Update the normals
    
}
Пример #25
0
//-----------------------------------------------------------------------------------------
//
void ofApp::setup()
{
	fontSmall.loadFont("Fonts/DIN.otf", 8 );
	circ = ofVec3f (0, 0, 0); //used for animation
	radius = 2; //used for animation //change this to zero if you want to have movement that gains momentum over time
		
	// Give us a starting point for the camera
	camera.setNearClip(0.01f);
	camera.setPosition( 0, 4, 10 );
	camera.setMovementMaxSpeed( 0.1f );

	H = 30; //height for mesh
	W = 30; //width for mesh
	color = ofColor(100, 50, 200); //starting color
	
    //sets up the mesh's vertices and color
	for (int y = 0; y < H; y++){ //as long as y is less than 30
		for (int x = 0; x < W; x++){ //and x is less than 30
			mesh.addVertex(ofVec3f((x - W/2), (y - H/2), 0)); //add a vertex along each of these x and y points
			mesh.addColor(color); //puts the color in
		}
	}

	//sets up the triangle indices
    for (int y=0; y<H-1; y++) { //as long as y is less than the height-1
        for (int x=0; x<W-1; x++) { //and x is less than the width-1
            int i1 = x + W * y; //0 is the first index
            int i2 = x+1 + W * y; //1 is the second
            int i3 = x + W * (y+1); //30 is the third
            int i4 = x+1 + W * (y+1); //31 is the fourth
            mesh.addTriangle( i1, i2, i3 ); //0, 1, 30
            mesh.addTriangle( i2, i4, i3 ); //1, 31, 30
        }
    }

	setNormals(mesh); //sets the normals to the mesh (function down below)
	
}
Пример #26
0
//--------------------------------------------------------------
void ofxOcean::update(){

    // z = sin(y)
    
    int W = width/gridSize;
    int H = height/gridSize;
    float time = ofGetElapsedTimef();
    //Change vertices
    for (int y=0; y<H; y++) {
        
        //float waveZ = sin(y * waveAmplitude + time * waveSpeed) * waveHeight;
        
        for (int x=0; x<W; x++) {
        
            float waveZ = sin((y*waveDirection.y + x*waveDirection.x)  * waveAmplitude + time * waveSpeed) * waveHeight;
            waveZ += sin((y*waveDirection2.y + x*waveDirection2.x)  * waveAmplitude2 + time * waveSpeed2) * waveHeight2;
            
            int i = x + W * y;       //Vertex index
            ofPoint p = mesh.getVertex( i );
            //Get Perlin noise value
            float value =
            ofNoise( x * gridSize * noiseAmp * 0.001, y * gridSize * noiseAmp * 0.001, time * noiseSpeed * 0.2 ); // 0.2
            //Change z-coordinate of vertex
            p.z = value * noiseHeight; //25
        
            p.z += waveZ;
            
            mesh.setVertex( i, p );
            //Change color of vertex
            mesh.setColor( i, color);
                    }
        
    }
    setNormals( mesh );  //Update the normals
    
    
}
Пример #27
0
//-----------------------------------------------------------------------------------------
//
void ofApp::update()
{
	float time = ofGetElapsedTimef(); //our time variable for animation

	//radius += 0.001; //uncomment this if you want to have movement that gains momentum
	
	for (int y=0; y<H; y++) { //for as long as y is less than the height
        for (int x=0; x<W; x++) { //and x is less than the width
            int i = x + W * y;	//our vertex index will equal x plus the width times y
            ofPoint v = mesh.getVertex( i ); //gets the vertices along all the points 
			circ.x = x + radius * cos(time);
			circ.y = y + radius * sin(time);
			circ.z = circ.x * circ.y;

            float move = ofNoise( circ.x * 0.05, circ.y * 0.05, circ.z * 0.05 ); //noise value for animation
			v.z = move; //changes the z values of the mesh points using the noise value
			
            mesh.setVertex( i, v ); //updates the mesh vertices
            mesh.setColor( i, ofColor( move*180, move * 50, 220 ) ); //changes the color based on z movement
        }
    }
    setNormals( mesh );	//updates the normals
	
}
Пример #28
0
//--------------------------------------------------------------
void testApp::update(){
    
    keyValue = receivedFft[50]*15;
    keyValue = ofMap(keyValue, 0.0, 1.0, 0.0, 8.0);
    keyValue *= 0.95;
//    cout << "keyValue: "<< keyValue<< endl;
    
    float time = ofGetElapsedTimef();	//Get time
    //Change vertices
    for (int y=0; y<H; y++) {
        for (int x=0; x<W; x++) {
            int i = x + W * y;			//Vertex index
            ofPoint p = mesh.getVertex( i );
            
            //Get Perlin noise value
            float value =
            ofNoise( x * 0.1, y * 0.1, time * 1 );

            //Change z-coordinate of vertex
            p.z = value *100*keyValue;
            //            p.x = x+100 * smoothedVol;
            mesh.setVertex( i, p );
            
            //Change color of vertex
            mesh.setColor( i,
                          ofColor( 255, 0, 255, 100 ) );
        }
    }
    setNormals( mesh );	//Update the normals
    
    
    
    //audio**********************************************
    //**********************************************
    //// hide old messages
    for(int i = 0; i < NUM_MSG_STRINGS; i++){
        if(timers[i] < ofGetElapsedTimef()){
            msg_strings[i] = "";
        }
    }
    
    // check for waiting messages
    while(receiver.hasWaitingMessages()){
        // get the next message
        ofxOscMessage m;
        receiver.getNextMessage(&m);
        
        if(m.getAddress() == "/channel_01/FFT"){
            int index = m.getArgAsInt32(0);
            float val = m.getArgAsFloat(1);
            receivedFft[index] = val;
            //cout << "recvd: " << index << " :\t"<<val<<endl;
        }
        
        else {
            string msg_string;
            msg_string = m.getAddress();
            cout << "unrecognized message" << msg_string << endl;
        }
    }
    //**********************************************
    //**********************************************
    


}
void SkeletonBlendedGeometry::changed(ConstFieldMaskArg whichField, 
                                      UInt32            origin,
                                      BitVector         details)
{
    Inherited::changed(whichField, origin, details);

    if((whichField & BaseGeometryFieldMask) &&
            getBaseGeometry() != NULL)
    {
        if(getBaseGeometry()->getTypes() != NULL)
        {
            setTypes(getBaseGeometry()->getTypes());
        }
        if(getBaseGeometry()->getLengths() != NULL)
        {
            setLengths(getBaseGeometry()->getLengths());
        }
        if(getBaseGeometry()->getPositions() != NULL)
        {
            GeoPropertyUnrecPtr Pos(getBaseGeometry()->getPositions()->clone());
            setPositions(dynamic_pointer_cast<GeoVectorProperty>(Pos));
        }
        if(getBaseGeometry()->getNormals() != NULL)
        {
            GeoPropertyUnrecPtr Norm(getBaseGeometry()->getNormals()->clone());
            setNormals(dynamic_pointer_cast<GeoVectorProperty>(Norm));
        }
        if(getBaseGeometry()->getColors() != NULL)
        {
            setColors(getBaseGeometry()->getColors());
        }
        if(getBaseGeometry()->getSecondaryColors() != NULL)
        {
            setSecondaryColors(getBaseGeometry()->getSecondaryColors());
        }
        if(getBaseGeometry()->getTexCoords() != NULL)
        {
            setTexCoords(getBaseGeometry()->getTexCoords());
        }
        if(getBaseGeometry()->getTexCoords1() != NULL)
        {
            setTexCoords1(getBaseGeometry()->getTexCoords1());
        }
        if(getBaseGeometry()->getTexCoords2() != NULL)
        {
            setTexCoords2(getBaseGeometry()->getTexCoords2());
        }
        if(getBaseGeometry()->getTexCoords3() != NULL)
        {
            setTexCoords3(getBaseGeometry()->getTexCoords3());
        }
        if(getBaseGeometry()->getTexCoords4() != NULL)
        {
            setTexCoords4(getBaseGeometry()->getTexCoords4());
        }
        if(getBaseGeometry()->getTexCoords5() != NULL)
        {
            setTexCoords5(getBaseGeometry()->getTexCoords5());
        }
        if(getBaseGeometry()->getTexCoords6() != NULL)
        {
            setTexCoords6(getBaseGeometry()->getTexCoords6());
        }
        if(getBaseGeometry()->getTexCoords7() != NULL)
        {
            setTexCoords7(getBaseGeometry()->getTexCoords7());
        }
        if(getBaseGeometry()->getIndices() != NULL)
        {
            setIndices(getBaseGeometry()->getIndices());
        }
        setMaterial(getBaseGeometry()->getMaterial());
    }

    if( (whichField & InternalJointsFieldMask) ||
        (whichField & InternalWeightIndexesFieldMask) ||
        (whichField & InternalWeightsFieldMask))
    {
        calculatePositions();
    }
}
Пример #30
0
//-----------------------------------------------------------------------------
// create shell of tower
void Tower::createShell()
{
  int vertexCount = (APT_STEPS+1) * (FLOOR_STEPS+1);
  int indexCount = 6*APT_STEPS*FLOOR_STEPS;
  int glassIndexCount = 6*FLOORS * FLOOR_STEPS;

  m_shellVertexes = mgVertex::newBuffer(vertexCount);
  m_shellIndexes = mgDisplay->newIndexBuffer(indexCount);
  m_glassIndexes = mgDisplay->newIndexBuffer(glassIndexCount);

  mgVertex* points = new mgVertex[(FLOOR_STEPS+1) * (APT_STEPS+1)];

  mgPoint3 aptPt, floorPt;
  for (int i = 0; i <= APT_STEPS; i++)
  {
    m_aptSpline.splinePt(m_floorDists[i], aptPt);
    double ht = aptPt.y - aptPt.z;
    for (int j = 0; j <= FLOOR_STEPS; j++)
    {
      m_floorSpline.splinePt((m_floorLen * j)/FLOOR_STEPS, floorPt);

      mgVertex* v = &points[i*(FLOOR_STEPS+1)+j];
      mgPoint3 pt(APT_SCALE * (ht * FLOOR_SCALE * floorPt.x), 
                  APT_SCALE * (aptPt.z + ht * FLOOR_SCALE * floorPt.y), 
                  APT_SCALE * aptPt.x);
      v->setPoint(pt.x, pt.y, pt.z);

      v->setTexture(2*j/(double) FLOOR_STEPS, 2*i/(double) APT_STEPS);
//      v->setTexture((pt.x+pt.y)/40, pt.z/40);
    }
  }

  // set all the normals
  setNormals(points, APT_STEPS+1, FLOOR_STEPS+1, false);

  int vertexBase = m_shellVertexes->getLength();
  for (int i = 0; i < (APT_STEPS+1)*(FLOOR_STEPS+1); i++)
    m_shellVertexes->addVertex(&points[i]);

  int rowSize = FLOOR_STEPS+1;
  for (int i = 0; i < APT_STEPS; i++)
  {
    for (int j = 0; j < FLOOR_STEPS; j++)
    {
      int index = vertexBase + i*rowSize+j;

      // if a window row/col
      if (i > 15 && i < 15+FLOORS*3 && (i-15)%3 != 0 && 
          ((j > 62 && j < 88) || (j > 12 && j < 38)))
      {
        m_glassIndexes->addIndex(index);  // tl
        m_glassIndexes->addIndex(index+rowSize);  // bl
        m_glassIndexes->addIndex(index+1);  // tr

        m_glassIndexes->addIndex(index+rowSize);  // bl
        m_glassIndexes->addIndex(index+rowSize+1);  // br
        m_glassIndexes->addIndex(index+1);  // tr
      }
      else
      {
        m_shellIndexes->addIndex(index);  // tl
        m_shellIndexes->addIndex(index+rowSize);  // bl
        m_shellIndexes->addIndex(index+1);  // tr

        m_shellIndexes->addIndex(index+rowSize);  // bl
        m_shellIndexes->addIndex(index+rowSize+1);  // br
        m_shellIndexes->addIndex(index+1);  // tr
      }
    }
  }

  delete points;
}