Ejemplo n.º 1
0
void CGraphic::DrawSkyBoard( const CFRect& rt, uint32 Color, ITexture* pTexture, const float& uoffset, const float& voffset, ERenderStyle rs, float z )
{
	if ( Color == 0 )
		return;

	float x1 = (float)rt.left;
	float y1 = (float)rt.top;
	float x2 = (float)rt.right;
	float y2 = (float)rt.bottom;

	if ( pTexture )
	{
		Vertex2D* pVB;
		GetRenderStack( rs, pTexture, NULL, PT_TRIANGLESTRIP, 4, 2,
			Vertex2D::Format, sizeof(Vertex2D), (void**)&pVB, NULL );

		float u1 = 0.00001f+uoffset;
		float v1 = 0.00001f+voffset;
		float u2 = 1.00001f+uoffset;
		float v2 = 1.00001f+voffset;

		pVB[0] = Vertex2D( x1, y2, z, Color, u1, v2 ); //对点写数据
		pVB[1] = Vertex2D( x1, y1, z, Color, u1, v1 );
		pVB[2] = Vertex2D( x2, y2, z, Color, u2, v2 );
		pVB[3] = Vertex2D( x2, y1, z, Color, u2, v1 );
	}
}
Ejemplo n.º 2
0
// this function draws the shape of the object with a black outline (no solid fill)
// only used in the editor and not the game
//
// this is called after the grid lines have been drawn on the map.  draws a solid
// outline over the grid lines
//
void DispReel::Render(Sur * const psur)
{
   if (!GetPTable()->GetEMReelsEnabled()) return;

   psur->SetBorderColor(RGB(0, 0, 0), false, 0);
   psur->SetFillColor(-1);
   psur->SetObject(this);
   psur->SetObject(NULL);

   // draw background box
   psur->Rectangle(m_d.m_v1.x, m_d.m_v1.y, m_d.m_v2.x, m_d.m_v2.y);

   // draw n reels in the box
   for (int i = 0; i < m_d.m_reelcount; ++i)
   {
      // set up top corner point
      const float fi = (float)i;
      const float x = m_d.m_v1.x + fi*(m_d.m_width + m_d.m_reelspacing) + m_d.m_reelspacing;
      const float y = m_d.m_v1.y + m_d.m_reelspacing;
      const float x2 = x + m_d.m_width;
      const float y2 = y + m_d.m_height;

      // set up points (clockwise)
      const Vertex2D rgv[4] = { Vertex2D(x, y), Vertex2D(x2, y), Vertex2D(x2, y2), Vertex2D(x, y2) };
      psur->Polygon(rgv, 4);
   }
}
Ejemplo n.º 3
0
// this function draws the shape of the object with a solid fill
// only used in the editor and not the game
//
// this is called before the grid lines are drawn on the map
//
void DispReel::PreRender(Sur * const psur)
{
   psur->SetBorderColor(-1, false, 0);
   psur->SetFillColor(m_d.m_backcolor);
   psur->SetObject(this);

   // draw background box
   psur->Rectangle(m_d.m_v1.x, m_d.m_v1.y, m_d.m_v2.x, m_d.m_v2.y);

   // draw n reels in the box (in blue)
   psur->SetFillColor(RGB(0, 0, 255));
   for (int i = 0; i < m_d.m_reelcount; ++i)
   {
      // set up top corner point
      const float fi = (float)i;
      const float x = m_d.m_v1.x + fi*(m_d.m_width + m_d.m_reelspacing) + m_d.m_reelspacing;
      const float y = m_d.m_v1.y + m_d.m_reelspacing;
      const float x2 = x + m_d.m_width;
      const float y2 = y + m_d.m_height;

      // set up points (clockwise)
      const Vertex2D rgv[4] = { Vertex2D(x, y), Vertex2D(x2, y), Vertex2D(x2, y2), Vertex2D(x, y2) };
      psur->Polygon(rgv, 4);
   }
}
Ejemplo n.º 4
0
void Spinner::GetHitShapes(vector<HitObject*> &pvho)
{
   const float height = m_ptable->GetSurfaceHeight(m_d.m_szSurface, m_d.m_vCenter.x, m_d.m_vCenter.y);
   const float h = m_d.m_height + 30.0f;

   const float angleMin = min(m_d.m_angleMin, m_d.m_angleMax); // correct angle inversions
   const float angleMax = max(m_d.m_angleMin, m_d.m_angleMax);

   m_d.m_angleMin = angleMin;
   m_d.m_angleMax = angleMax;

   HitSpinner * const phitspinner = new HitSpinner(this, height);
   m_phitspinner = phitspinner;

   pvho.push_back(phitspinner);

   if (m_d.m_fShowBracket)
   {
      /*add a hit shape for the bracket if shown, just in case if the bracket spinner height is low enough so the ball can hit it*/
      const float halflength = m_d.m_length * 0.5f + (m_d.m_length*0.1875f);
      const float radangle = ANGTORAD(m_d.m_rotation);
      const float sn = sinf(radangle);
      const float cs = cosf(radangle);

      HitCircle *phitcircle;
      phitcircle = new HitCircle(Vertex2D(m_d.m_vCenter.x + cs*halflength, m_d.m_vCenter.y + sn*halflength), m_d.m_length*0.075f, height + m_d.m_height, height + h);
      pvho.push_back(phitcircle);

      phitcircle = new HitCircle(Vertex2D(m_d.m_vCenter.x - cs*halflength, m_d.m_vCenter.y - sn*halflength), m_d.m_length*0.075f, height + m_d.m_height, height + h);
      pvho.push_back(phitcircle);
   }
}
Ejemplo n.º 5
0
void CGraphic::DrawRect( const CFRect& rt, uint32 Color, ITexture* pTexture, const CFRect* rtText, ERenderStyle RS, float z )
{
	if ( Color == 0 )
		return;

	float x1 = (float)rt.left;
	float y1 = (float)rt.top;
	float x2 = (float)rt.right;
	float y2 = (float)rt.bottom;

	if ( pTexture )
	{
		Vertex2D* pVB;
		GetRenderStack( RS, pTexture, NULL, PT_TRIANGLESTRIP, 4, 2,
			Vertex2D::Format, sizeof(Vertex2D), (void**)&pVB, NULL );

		float u1 = 0.00001f;
		float v1 = 0.00001f;
		float u2 = 1.00001f;
		float v2 = 1.00001f;
		if ( rtText )
		{
			u1 = ( rtText->left + 0.25f )/pTexture->GetWidth();
			v1 = ( rtText->top + 0.25f )/pTexture->GetHeight();
			u2 = ( rtText->right + 0.25f )/pTexture->GetWidth();
			v2 = ( rtText->bottom + 0.25f )/pTexture->GetHeight();
		}

		pVB[0] = Vertex2D( x1, y2, z, Color, u1, v2 ); //对点写数据
		pVB[1] = Vertex2D( x1, y1, z, Color, u1, v1 );
		pVB[2] = Vertex2D( x2, y2, z, Color, u2, v2 );
		pVB[3] = Vertex2D( x2, y1, z, Color, u2, v1 );
	}
	else
	{
		VerColor2D* pVB;
		GetRenderStack( RS, NULL, NULL, PT_TRIANGLESTRIP, 4, 2,
			VerColor2D::Format, sizeof(VerColor2D), (void**)&pVB, NULL );

		pVB[0] = VerColor2D( x1, y2, z, Color );
		pVB[1] = VerColor2D( x1, y1, z, Color );
		pVB[2] = VerColor2D( x2, y2, z, Color );
		pVB[3] = VerColor2D( x2, y1, z, Color );
	}
}
Ejemplo n.º 6
0
void CGraphic::DrawRect( const CFRect& rt, uint32 Color, ITexture* pTexture, const CPosRect& rtText, ERenderStyle RS, float z )
{
	if ( Color == 0 )
		return;
	float x1 = rt.left;
	float y1 = rt.top;
	float x2 = rt.right;
	float y2 = rt.bottom;

	if ( pTexture )
	{
		Vertex2D* pVB;
		GetRenderStack( RS, pTexture, NULL, PT_TRIANGLESTRIP, 4, 2,
			Vertex2D::Format, sizeof(Vertex2D), (void**)&pVB, NULL );

		float uLT = ( rtText.ptLT.x + 0.25f )/pTexture->GetWidth();
		float vLT = ( rtText.ptLT.y + 0.25f )/pTexture->GetHeight();
		float uRT = ( rtText.ptRT.x + 0.25f )/pTexture->GetWidth();
		float vRT = ( rtText.ptRT.y + 0.25f )/pTexture->GetHeight();
		float uLB = ( rtText.ptLB.x + 0.25f )/pTexture->GetWidth();
		float vLB = ( rtText.ptLB.y + 0.25f )/pTexture->GetHeight();
		float uRB = ( rtText.ptRB.x + 0.25f )/pTexture->GetWidth();
		float vRB = ( rtText.ptRB.y + 0.25f )/pTexture->GetHeight();

		pVB[0] = Vertex2D( x1, y2, z, Color, uLB, vLB );
		pVB[1] = Vertex2D( x1, y1, z, Color, uLT, vLT );
		pVB[2] = Vertex2D( x2, y2, z, Color, uRB, vRB );
		pVB[3] = Vertex2D( x2, y1, z, Color, uRT, vRT );
	}
	else
	{
		VerColor2D* pVB;
		GetRenderStack( RS, NULL, NULL, PT_TRIANGLESTRIP, 4, 2,
			VerColor2D::Format, sizeof(VerColor2D), (void**)&pVB, NULL );

		pVB[0] = VerColor2D( x1, y2, z, Color );
		pVB[1] = VerColor2D( x1, y1, z, Color );
		pVB[2] = VerColor2D( x2, y2, z, Color );
		pVB[3] = VerColor2D( x2, y1, z, Color );
	}
}
Ejemplo n.º 7
0
 Image::Image()
 {
     // Initialize Vertex and Index buffer
     vBuffer = 0;
     iBuffer = 0;
     int j;
     int i;
     for(i = 0; i < 4; i++)
         verts[i] = Vertex2D(VertexPos2D(0, 0), TexCoord(0, 0));
     for(i = 0; i < 4; i++)
         indices[i] = 0;
 }
Ejemplo n.º 8
0
    void Image::initVBO()
    {
        if(vBuffer != 0)
            glDeleteBuffers(1, &vBuffer);
        if(iBuffer != 0)
            glDeleteBuffers(1, &iBuffer);

        vBuffer = 0;
        iBuffer = 0;

        // Assign vertices
        verts[0] = Vertex2D(VertexPos2D(0, 0),
                            TexCoord(1.0f, 0.0f));
        verts[1] = Vertex2D(VertexPos2D((GLfloat)tex.width(), 0),
                            TexCoord(0.0f, 0.0f));
        verts[2] = Vertex2D(VertexPos2D((GLfloat)tex.width(), (GLfloat)tex.height()),
                            TexCoord(0.0f, 1.0f));
        verts[3] = Vertex2D(VertexPos2D(0, (GLfloat)tex.height()),
                            TexCoord(1.0f, 1.0f));

        // Initialize indices
        indices[0] = 0;
        indices[1] = 1;
        indices[2] = 2;
        indices[3] = 3;

        // Create VBO
        glGenBuffers(1, &vBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, vBuffer);
        glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(Vertex2D), verts, GL_DYNAMIC_DRAW);

        // Create IBO
        glGenBuffers(1, &iBuffer);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iBuffer);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * sizeof(GLuint), indices, GL_DYNAMIC_DRAW);

        // Unbind Buffers
        glBindBuffer(GL_ARRAY_BUFFER, NULL);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL);
    }
Ejemplo n.º 9
0
void SuperShape2D::fillVertexBuffer()
{
	float radius = 0;
	float p = 2*M_PI /(float) v_points;
	int i = 0;
	for( float y = 0; y < 2*M_PI; y += p)
	{
		radius = evaluateR(y);
		float xC = 5*radius * cos(y);
		float yC = 5*radius * sin(y);
		int c = 0xff0000;
		vertexBuffer[i] = Vertex2D(xC,yC, c);
		i++;
	}

}
Ejemplo n.º 10
0
void Scene::loadRoom(XMLDocument& doc){

	XMLElement *room = doc.FirstChildElement("scene")->FirstChildElement("room");

 	std::unique_ptr<glimac::Image> wallTexture = glimac::loadImage(room->FirstChildElement("walls")->GetText());
    std::unique_ptr<glimac::Image> floorTexture = glimac::loadImage(room->FirstChildElement("floor")->GetText());
    std::unique_ptr<glimac::Image> roofTexture = glimac::loadImage(room->FirstChildElement("roof")->GetText());

    if (wallTexture == NULL || floorTexture ==  NULL || roofTexture ==  NULL)
    {
        std::cerr << "Erreur lors du chargement de l'image" << std::endl;
    }


    _width = atof(room->FirstChildElement("width")->GetText());
    _height = atof(room->FirstChildElement("height")->GetText());
    _depth = atof(room->FirstChildElement("depth")->GetText());

    _wallLimits.x = atof(room->FirstChildElement("xmax")->GetText());
    _wallLimits.y = atof(room->FirstChildElement("xmin")->GetText());
    _wallLimits.z = atof(room->FirstChildElement("zmax")->GetText());
    _wallLimits.w = atof(room->FirstChildElement("zmin")->GetText());
    

    // Create an array of texture and bind each texture
    
    glGenTextures(3, _texturesArray);

    glBindTexture(GL_TEXTURE_2D, _texturesArray[0]);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, wallTexture->getWidth(), wallTexture->getHeight(), 0, GL_RGBA, GL_FLOAT, wallTexture->getPixels());
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D,0);

    glBindTexture(GL_TEXTURE_2D, _texturesArray[1]);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, floorTexture->getWidth(), floorTexture->getHeight(), 0, GL_RGBA, GL_FLOAT, floorTexture->getPixels());
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D,0);

    glBindTexture(GL_TEXTURE_2D, _texturesArray[2]);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, roofTexture->getWidth(), roofTexture->getHeight(), 0, GL_RGBA, GL_FLOAT, roofTexture->getPixels());
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D,0);

    glGenBuffers (1, &_vbo);

    glBindBuffer(GL_ARRAY_BUFFER, _vbo);

    // Quad (wall) coordonates
    // TODO hardcoded, pass it as a parameter to the function ?
    Vertex2D vertices[] = {
        Vertex2D(glm::vec3(0, 0,0),  glm::vec2(4, 0)), // Sommet 0
        Vertex2D(glm::vec3(_width, 0,0), glm::vec2(0, 0)), // Sommet 1
        Vertex2D(glm::vec3(_width, _height,0), glm::vec2(0, 4)), // Sommet 2
        Vertex2D(glm::vec3(0, _height,0),  glm::vec2(4, 4)) // Sommet 3
    };

    glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(Vertex2D), vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER, 0);

    GLuint ibo;
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

    uint32_t indices[] = {
        0, 1, 2, 0, 2, 3
    };

    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(uint32_t), indices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    glGenVertexArrays(1, &_vao);

    glBindVertexArray(_vao);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

    const GLuint VERTEX_ATTR_POSITION = 0;
    const GLuint VERTEX_ATTR_COLOR = 1;
    glEnableVertexAttribArray(VERTEX_ATTR_POSITION);
    glEnableVertexAttribArray(VERTEX_ATTR_COLOR);
    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
    glVertexAttribPointer(VERTEX_ATTR_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (const GLvoid*) offsetof(Vertex2D, position));
    glVertexAttribPointer(VERTEX_ATTR_COLOR, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (const GLvoid*) offsetof(Vertex2D, texture));
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);
}
Ejemplo n.º 11
0
void CRenderTarget::Flip()
{
	m_matPreDeltaView = m_matCurDeltaView;
	m_matCurDeltaView.Identity();

	CGraphic* pGph = CGraphic::GetInst();

	for ( int i = 0; i < m_nNearCount; i++ )
	{
		Vertex2D* pVB;
		RenderState* pRS;
		if( pGph->GetRenderStack( RS_DEFAULT, m_NearFilter[i].pText, NULL, PT_TRIANGLESTRIP, 4, 2,
			Vertex2D::Format, sizeof(Vertex2D), (void**)&pVB, NULL, (void**)&pRS ) )
		{
			if ( m_NearFilter[i].bRatio )
			{
				pVB[0] = Vertex2D( float(m_rcViewPort.left),float(m_rcViewPort.bottom),	0.99999994f, m_NearFilter[i].dwColor, m_NearFilter[i].cTexRt.left, m_NearFilter[i].cTexRt.bottom );
				pVB[1] = Vertex2D( float(m_rcViewPort.left),float(m_rcViewPort.top),	0.99999994f, m_NearFilter[i].dwColor, m_NearFilter[i].cTexRt.left, m_NearFilter[i].cTexRt.top );
				pVB[2] = Vertex2D( float(m_rcViewPort.right),float(m_rcViewPort.bottom),0.99999994f, m_NearFilter[i].dwColor, m_NearFilter[i].cTexRt.right, m_NearFilter[i].cTexRt.bottom );
				pVB[3] = Vertex2D( float(m_rcViewPort.right),float(m_rcViewPort.top),	0.99999994f, m_NearFilter[i].dwColor, m_NearFilter[i].cTexRt.right, m_NearFilter[i].cTexRt.top );

				pRS->m_UAddr_S0 = m_NearFilter[i].eSamp;
				pRS->m_VAddr_S0 = m_NearFilter[i].eSamp;
			}
			else
			{
				pVB[0] = Vertex2D( float(m_rcViewPort.left),float(m_rcViewPort.bottom),	0.99999994f, m_NearFilter[i].dwColor, 0, 1 );
				pVB[1] = Vertex2D( float(m_rcViewPort.left),float(m_rcViewPort.top),	0.99999994f, m_NearFilter[i].dwColor, 0, 0 );
				pVB[2] = Vertex2D( float(m_rcViewPort.right),float(m_rcViewPort.bottom),0.99999994f, m_NearFilter[i].dwColor, 1, 1 );
				pVB[3] = Vertex2D( float(m_rcViewPort.right),float(m_rcViewPort.top),	0.99999994f, m_NearFilter[i].dwColor, 1, 0 );
			}
			if(m_NearFilter[i].pText == NULL)
			{
				pRS->m_TexOP_S0		= TOP_SELECTARG2;
				pRS->m_AlpOP_S0		= TOP_SELECTARG2;
			}
			else
				pRS->m_AlpOP_S0		= TOP_MODULATE;
			pRS->m_LightEnable = FALSE;
			if ( !m_NearFilter[i].bMulti )
				pRS->m_DestBlend = BLEND_ONE;
		}
	}
	m_nNearCount = 0;
	
	for ( int i = 0; i < m_nFarCount; i++ )
	{
		Vertex2D* pVB;
		RenderState* pRS;
		if( pGph->GetRenderStack( RS_DEFAULT, m_FarFilter[i].pText, NULL, PT_TRIANGLESTRIP, 4, 2,
			Vertex2D::Format, sizeof(Vertex2D), (void**)&pVB, NULL, (void**)&pRS ) )
		{
			if ( m_FarFilter[i].bRatio )
			{
				pVB[0] = Vertex2D( float(m_rcViewPort.left),float(m_rcViewPort.bottom),	0.000018f, m_FarFilter[i].dwColor, m_FarFilter[i].cTexRt.left, m_FarFilter[i].cTexRt.bottom );
				pVB[1] = Vertex2D( float(m_rcViewPort.left),float(m_rcViewPort.top),	0.000018f, m_FarFilter[i].dwColor, m_FarFilter[i].cTexRt.left, m_FarFilter[i].cTexRt.top );
				pVB[2] = Vertex2D( float(m_rcViewPort.right),float(m_rcViewPort.bottom),0.000018f, m_FarFilter[i].dwColor, m_FarFilter[i].cTexRt.right, m_FarFilter[i].cTexRt.bottom );
				pVB[3] = Vertex2D( float(m_rcViewPort.right),float(m_rcViewPort.top),	0.000018f, m_FarFilter[i].dwColor, m_FarFilter[i].cTexRt.right, m_FarFilter[i].cTexRt.top );

				pRS->m_UAddr_S0 = m_FarFilter[i].eSamp;
				pRS->m_VAddr_S0 = m_FarFilter[i].eSamp;
			}
			else
			{
				pVB[0] = Vertex2D( float(m_rcViewPort.left),float(m_rcViewPort.bottom),	0.000018f, m_FarFilter[i].dwColor, 0, 1 );
				pVB[1] = Vertex2D( float(m_rcViewPort.left),float(m_rcViewPort.top),	0.000018f, m_FarFilter[i].dwColor, 0, 0 );
				pVB[2] = Vertex2D( float(m_rcViewPort.right),float(m_rcViewPort.bottom),0.000018f, m_FarFilter[i].dwColor, 1, 1 );
				pVB[3] = Vertex2D( float(m_rcViewPort.right),float(m_rcViewPort.top),	0.000018f, m_FarFilter[i].dwColor, 1, 0 );
			}
			if(m_FarFilter[i].pText == NULL)
			{
				pRS->m_TexOP_S0		= TOP_SELECTARG2;
				pRS->m_AlpOP_S0		= TOP_SELECTARG2;
			}
			else
				pRS->m_AlpOP_S0		= TOP_MODULATE;
			pRS->m_LightEnable	= FALSE;
			if ( !m_FarFilter[i].bMulti )
				pRS->m_DestBlend = BLEND_ONE;
		}
	}
	m_nFarCount = 0;

	for ( int i = 0; i < m_nPostCount; i++ )
	{
		m_PostFilter[i]->RenderFilter();
	}
	m_nPostCount = 0;
}
void OpenGlBox::initialiseQuads()
{
	//Screen quad
	mQuad.quad[0] = Vertex2D(-1.f, -1.f, 0.f, 0.f);
	mQuad.quad[1] = Vertex2D(1.f, -1.f, 1.f, 0.f);
	mQuad.quad[2] = Vertex2D(-1.f, 1.f, 0.f, 1.f);
	mQuad.quad[3] = Vertex2D(-1.f, 1.f, 0.f, 1.f);
	mQuad.quad[4] = Vertex2D(1.f, -1.f, 1.f, 0.f);
	mQuad.quad[5] = Vertex2D(1.f, 1.f, 1.f, 1.f);
	mQuad.VBO = ~0u;
	glGenBuffers(1, &mQuad.VBO);
	glBindBuffer(GL_ARRAY_BUFFER, mQuad.VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex2D) * 6, mQuad.quad, GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), NULL);

	mHistQuad.quad[0] = Vertex2D(-1.f, -1.f, 0.f, 0.f);
	mHistQuad.quad[1] = Vertex2D(1.f, -1.f, 1.f, 0.f);
	mHistQuad.quad[2] = Vertex2D(-1.f, 1.f, 0.f, 1.f);
	mHistQuad.quad[3] = Vertex2D(-1.f, 1.f, 0.f, 1.f);
	mHistQuad.quad[4] = Vertex2D(1.f, -1.f, 1.f, 0.f);
	mHistQuad.quad[5] = Vertex2D(1.f, 1.f, 1.f, 1.f);

	mHistQuad.VBO = ~0u;
	glGenBuffers(1, &mHistQuad.VBO);
	glBindBuffer(GL_ARRAY_BUFFER, mHistQuad.VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex2D) * 6, mHistQuad.quad, GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), NULL);
}
Ejemplo n.º 13
0
void LineLight(RenderContext* render, Vertex2D from, Vertex2D to)
{
	if (from.IsUVNormal() && to.IsUVNormal())
	{
		Vec2i size(render->bmp->bmp_width, render->bmp->bmp_height);
		from.ToRealUV(size);
		to.ToRealUV(size);
	}
	int x, y, remain = 0;

	Vec3i color;
	Vec3f ratio_c;
	Vec2f textc, ratio_tc;
	float distance = (to.p - from.p).Length();
	ratio_c.x = (to.c.x - from.c.x) / distance;
	ratio_c.y = (to.c.y - from.c.y) / distance;
	ratio_c.z = (to.c.z - from.c.z) / distance;
	ratio_tc.x = (to.tc.x - from.tc.x) / distance;
	ratio_tc.y = (to.tc.y - from.tc.y) / distance;

	float length;

	if (from.p.x == to.p.x && from.p.y == to.p.y)
	{
		render->LightPixel(Vertex2D(from.p, to.c, to.tc));
	}
	else if (from.p.x == to.p.x)
	{
		int inc = (from.p.y <= to.p.y) ? 1 : -1;
		for (y = from.p.y; y != to.p.y; y += inc)
		{
			length = abs(y - from.p.y);
			color = Interpolate(from.c, length, ratio_c);
			textc = Interpolate(from.tc, length, ratio_tc);
			render->LightPixel(Vertex2D({ from.p.x, y }, color, textc));
		}
		render->LightPixel(Vertex2D(to.p,to.c, to.tc));
	}
	else if (from.p.y == to.p.y)
	{
		int inc = (from.p.x <= to.p.x) ? 1 : -1;
		for (x = from.p.x; x != to.p.x; x += inc)
		{
			length = abs(x - from.p.x);
			color = Interpolate(from.c, length, ratio_c);
			textc = Interpolate(from.tc, length, ratio_tc);
			render->LightPixel(Vertex2D({ x, from.p.y }, color, textc));
		}
		render->LightPixel(Vertex2D(to.p, to.c,to.tc));
	}
	else
	{
		int dx = (from.p.x < to.p.x) ? to.p.x - from.p.x : from.p.x - to.p.x;
		int dy = (from.p.y < to.p.y) ? to.p.y - from.p.y : from.p.y - to.p.y;
		if (dx >= dy)
		{
			if (to.p.x < from.p.x) x = from.p.x, y = from.p.y, from.p.x = to.p.x, from.p.y = to.p.y, to.p.x = x, to.p.y = y;
			for (x = from.p.x, y = from.p.y; x <= to.p.x; x++)
			{
				length = (Vec2i(x, y) - from.p).Length();
				color = Interpolate(from.c, length, ratio_c);
				textc = Interpolate(from.tc, length, ratio_tc);
				render->LightPixel(Vertex2D({ x, y }, color, textc));
				remain += dy;
				if (remain >= dx)
				{
					remain -= dx;
					y += (to.p.y >= from.p.y) ? 1 : -1;
					length = (Vec2i(x, y) - from.p).Length();
					color = Interpolate(from.c, length, ratio_c);
					textc = Interpolate(from.tc, length, ratio_tc);
					render->LightPixel(Vertex2D({ x, y }, color, textc));
				}
			}
			render->LightPixel(Vertex2D(to.p, to.c,to.tc));
		}
		else
		{
			if (to.p.y < from.p.y) x = from.p.x, y = from.p.y, from.p.x = to.p.x, from.p.y = to.p.y, to.p.x = x, to.p.y = y;
			for (x = from.p.x, y = from.p.y; y <= to.p.y; y++)
			{
				length = (Vec2i(x, y) - from.p).Length();
				color = Interpolate(from.c, length, ratio_c);
				textc = Interpolate(from.tc, length, ratio_tc);
				render->LightPixel(Vertex2D({ x, y }, color, textc));
				remain += dx;
				if (remain >= dy) 
				{
					remain -= dy;
					x += (to.p.x >= from.p.x) ? 1 : -1;
					length = (Vec2i(x, y) - from.p).Length();
					color = Interpolate(from.c, length, ratio_c);
					textc = Interpolate(from.tc, length, ratio_tc);
					render->LightPixel(Vertex2D({ x, y }, color, textc));
				}
			}
			render->LightPixel(Vertex2D(to.p, to.c,to.tc));
		}
	}
}
Ejemplo n.º 14
0
void LineInterpolate(RenderContext* render, Vertex2D from, Vertex2D to)
{
	int x, y, rem = 0;
	Vec3i color;
	float distance = (to.p - from.p).Length();
	Vec3f ratio;
	ratio.x = (to.c.x - from.c.x) / distance;
	ratio.y = (to.c.y - from.c.y) / distance;
	ratio.z = (to.c.z - from.c.z) / distance;
	float length;
	if (from.p.x == to.p.x && from.p.y == to.p.y)
	{
		render->SetPixel(Vertex2D(from.p, to.c));
	}
	else if (from.p.x == to.p.x)
	{
		int inc = (from.p.y <= to.p.y) ? 1 : -1;
		for (y = from.p.y; y != to.p.y; y += inc)
		{
			length = abs(y - from.p.y);
			color = Interpolate(from.c, length, ratio);
			render->SetPixel(Vertex2D({ from.p.x, y }, color));
		}
		render->SetPixel(Vertex2D(to.p, to.c));
	}
	else if (from.p.y == to.p.y)
	{
		int inc = (from.p.x <= to.p.x) ? 1 : -1;
		for (x = from.p.x; x != to.p.x; x += inc)
		{
			length = abs(x - from.p.x);
			color = Interpolate(from.c, length, ratio);
			render->SetPixel(Vertex2D({ x, from.p.y }, color));
		}
		render->SetPixel(Vertex2D(to.p, to.c));
	}
	else
	{
		int dx = (from.p.x < to.p.x) ? to.p.x - from.p.x : from.p.x - to.p.x;
		int dy = (from.p.y < to.p.y) ? to.p.y - from.p.y : from.p.y - to.p.y;
		if (dx >= dy)
		{
			if (to.p.x < from.p.x) x = from.p.x, y = from.p.y, from.p.x = to.p.x, from.p.y = to.p.y, to.p.x = x, to.p.y = y;
			for (x = from.p.x, y = from.p.y; x <= to.p.x; x++)
			{
				length = (Vec2i(x, y) - from.p).Length();
				color = Interpolate(from.c, length, ratio);
				render->SetPixel(Vertex2D({ x, y }, color));
				rem += dy;
				if (rem >= dx)
				{
					rem -= dx;
					y += (to.p.y >= from.p.y) ? 1 : -1;
					length = (Vec2i(x, y) - from.p).Length();
					color = Interpolate(from.c, length, ratio);
					render->SetPixel(Vertex2D({ x, y }, color));
				}
			}
			render->SetPixel(Vertex2D(to.p, to.c));
		}
		else
		{
			if (to.p.y < from.p.y) x = from.p.x, y = from.p.y, from.p.x = to.p.x, from.p.y = to.p.y, to.p.x = x, to.p.y = y;
			for (x = from.p.x, y = from.p.y; y <= to.p.y; y++)
			{
				length = (Vec2i(x, y) - from.p).Length();
				color = Interpolate(from.c, length, ratio);
				render->SetPixel(Vertex2D({ x, y }, color));
				rem += dx;
				if (rem >= dy) {
					rem -= dy;
					x += (to.p.x >= from.p.x) ? 1 : -1;
					length = (Vec2i(x, y) - from.p).Length();
					color = Interpolate(from.c, length, ratio);
					render->SetPixel(Vertex2D({ x, y }, color));
				}
			}
			render->SetPixel(Vertex2D(to.p, to.c));
		}
	}
}