static Mesh* createPointsMesh()
{
    float scale = 0.2f;
    unsigned int vertexCount = 100;

    std::vector<float> vertices;
    vertices.reserve(vertexCount * 6);
    for (unsigned int i = 0; i < vertexCount; ++i)
    {
        // x, y, z, r, g, b
        vertices.push_back(MATH_RANDOM_MINUS1_1() * scale);
        vertices.push_back(MATH_RANDOM_MINUS1_1() * scale);
        vertices.push_back(MATH_RANDOM_MINUS1_1() * scale);
        vertices.push_back(MATH_RANDOM_0_1());
        vertices.push_back(MATH_RANDOM_0_1());
        vertices.push_back(MATH_RANDOM_0_1()); 
    }
    
    VertexFormat::Element elements[] =
    {
        VertexFormat::Element(VertexFormat::POSITION, 3),
        VertexFormat::Element(VertexFormat::COLOR, 3)
    };
    Mesh* mesh = Mesh::createMesh(VertexFormat(elements, 2), vertexCount, false);
    if (mesh == NULL)
    {
        GP_ERROR("Failed to create mesh.");
        return NULL;
    }
    mesh->setPrimitiveType(Mesh::POINTS);
    mesh->setVertexData(&vertices[0], 0, vertexCount);
    return mesh;
}
Esempio n. 2
0
void BillboardSample::loadBillboards()
{
	Mesh* mesh = Mesh::createQuad(-(BILLBOARD_WIDTH / 2.0f), -(BILLBOARD_HEIGHT / 2.0f), BILLBOARD_WIDTH, BILLBOARD_HEIGHT);
	mesh->setBoundingSphere(BoundingSphere(Vector3::zero(), BILLBOARD_HEIGHT));

    Effect* effect = Effect::createFromFile("res/shaders/textured.vert", "res/shaders/textured.frag", "TEXTURE_DISCARD_ALPHA");

	// Create the model and node and bind the material
    for ( unsigned int i = 0; i < BILLBOARD_COUNT; i++ ) 
    {   
		Node* node = Node::create();
		Model* model = Model::create(mesh);
		node->setDrawable(model);
		_scene->addNode(node);
        
		Material* material = Material::create(effect); 
		material->getStateBlock()->setDepthTest(true);
		material->getStateBlock()->setBlend(false);
		material->getParameter("u_diffuseTexture")->setValue("res/png/grass.png" , true);
		material->setParameterAutoBinding("u_worldViewProjectionMatrix", RenderState::WORLD_VIEW_PROJECTION_MATRIX);
		model->setMaterial(material);
		SAFE_RELEASE(model);
		SAFE_RELEASE(material);

		// Randomly postiion within the domain
        float tx = MATH_RANDOM_0_1() * GROUND_WIDTH - (GROUND_WIDTH / 2.0f);
		float tz = MATH_RANDOM_0_1() * GROUND_HEIGHT - (GROUND_HEIGHT / 2.0f);
        node->translate(tx, (BILLBOARD_HEIGHT / 2.0f), tz);

        _billboards.push_back(node);
    }
	SAFE_RELEASE(effect);
	SAFE_RELEASE(mesh);
}
static Mesh* createTriangleStripMesh()
{
    float scale = 0.02f;
    unsigned int vertexCount = 20;

    std::vector<float> vertices;
    vertices.reserve(vertexCount * 6);

    float x = -0.2f;
    float y = -0.05f;

    float step = fabs(x) * 2.0f / (float)vertexCount;

    for (unsigned int i = 0; i < vertexCount; ++i)
    {
        // x, y, z, r, g, b
        vertices.push_back(x);
        vertices.push_back(y + MATH_RANDOM_MINUS1_1() * scale);
        vertices.push_back(MATH_RANDOM_MINUS1_1() * scale * 2); 
        vertices.push_back(MATH_RANDOM_0_1()); 
        vertices.push_back(MATH_RANDOM_0_1()); 
        vertices.push_back(MATH_RANDOM_0_1()); 
        x += step;
        y *= -1.0f;
    }
    
    VertexFormat::Element elements[] =
    {
        VertexFormat::Element(VertexFormat::POSITION, 3),
        VertexFormat::Element(VertexFormat::COLOR, 3)
    };
    Mesh* mesh = Mesh::createMesh(VertexFormat(elements, 2), vertexCount, false);
    if (mesh == NULL)
    {
        GP_ERROR("Failed to create mesh.");
        return NULL;
    }
    mesh->setPrimitiveType(Mesh::TRIANGLE_STRIP);
    // 
    mesh->setVertexData(&vertices[0], 0, vertexCount);
    return mesh;
}
Esempio n. 4
0
void PostProcessSample::update(float elapsedTime)
{
    _modelNode->rotateY(elapsedTime * MATH_DEG_TO_RAD(0.25f));

    // Only the last sample will check live updating of material parameters
    if (_compositorIndex == _compositors.size() - 1)
    {
        Compositor* compositor = _compositors[_compositorIndex];
        MaterialParameter* elapsedParam  = compositor->getMaterial()->getParameter("u_elapsedTime");
        if (elapsedParam)
            elapsedParam->setValue(elapsedTime);
        MaterialParameter* randomParam = compositor->getMaterial()->getParameter("u_random");
        if (randomParam)
            randomParam->setValue(MATH_RANDOM_0_1());
    }
}
float ParticleEmitter::generateScalar(float min, float max)
{
    return min + (max - min) * MATH_RANDOM_0_1();
}