int lua_TextureSampler_addRef(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
Texture::Sampler* instance = getInstance(state);
instance->addRef();
return 0;
}
lua_pushstring(state, "lua_TextureSampler_addRef - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
void Form::setNode(Node* node)
{
// If the user wants a custom node then we need to create a 3D quad
if (node && node != _node)
{
// Set this Form up to be 3D by initializing a quad.
float x2 = _bounds.width;
float y2 = _bounds.height;
float vertices[] =
{
0, y2, 0, 0, _v1,
0, 0, 0, 0, 0,
x2, y2, 0, _u2, _v1,
x2, 0, 0, _u2, 0
};
VertexFormat::Element elements[] =
{
VertexFormat::Element(VertexFormat::POSITION, 3),
VertexFormat::Element(VertexFormat::TEXCOORD0, 2)
};
Mesh* mesh = Mesh::createMesh(VertexFormat(elements, 2), 4, false);
GP_ASSERT(mesh);
mesh->setPrimitiveType(Mesh::TRIANGLE_STRIP);
mesh->setVertexData(vertices, 0, 4);
_nodeQuad = Model::create(mesh);
SAFE_RELEASE(mesh);
GP_ASSERT(_nodeQuad);
// Create the effect and material
Effect* effect = createEffect();
GP_ASSERT(effect);
_nodeMaterial = Material::create(effect);
GP_ASSERT(_nodeMaterial);
_nodeQuad->setMaterial(_nodeMaterial);
_nodeMaterial->release();
node->setModel(_nodeQuad);
_nodeQuad->release();
// Bind the WorldViewProjection matrix.
_nodeMaterial->setParameterAutoBinding("u_worldViewProjectionMatrix", RenderState::WORLD_VIEW_PROJECTION_MATRIX);
// Bind the texture from the framebuffer and set the texture to clamp
Texture::Sampler* sampler = Texture::Sampler::create(_frameBuffer->getRenderTarget()->getTexture());
GP_ASSERT(sampler);
sampler->setWrapMode(Texture::CLAMP, Texture::CLAMP);
_nodeMaterial->getParameter("u_texture")->setValue(sampler);
sampler->release();
RenderState::StateBlock* rsBlock = _nodeMaterial->getStateBlock();
rsBlock->setDepthWrite(true);
rsBlock->setBlend(true);
rsBlock->setBlendSrc(RenderState::BLEND_SRC_ALPHA);
rsBlock->setBlendDst(RenderState::BLEND_ONE_MINUS_SRC_ALPHA);
}
_node = node;
}
int lua_TextureSampler_getTexture(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
Texture::Sampler* instance = getInstance(state);
void* returnPtr = (void*)instance->getTexture();
if (returnPtr)
{
ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject));
object->instance = returnPtr;
object->owns = false;
luaL_getmetatable(state, "Texture");
lua_setmetatable(state, -2);
}
else
{
lua_pushnil(state);
}
return 1;
}
else
{
lua_pushstring(state, "lua_TextureSampler_getTexture - Failed to match the given parameters to a valid function signature.");
lua_error(state);
}
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
void Form::initializeQuad(Mesh* mesh)
{
// Release current model.
SAFE_RELEASE(_quad);
// Create the model
_quad = Model::create(mesh);
// Create the material
Material* material = _quad->setMaterial("res/shaders/textured.vsh", "res/shaders/textured.fsh");
// Set the common render state block for the material
RenderState::StateBlock* stateBlock = _theme->getSpriteBatch()->getStateBlock();
stateBlock->setDepthWrite(true);
material->setStateBlock(stateBlock);
// Bind the WorldViewProjection matrix
material->setParameterAutoBinding("u_worldViewProjectionMatrix", RenderState::WORLD_VIEW_PROJECTION_MATRIX);
// Create a FrameBuffer if necessary.
if (!_frameBuffer)
{
_frameBuffer = FrameBuffer::create(_id.c_str());
}
// Use the FrameBuffer to texture the quad.
if (!_frameBuffer->getRenderTarget())
{
RenderTarget* rt = RenderTarget::create(_id.c_str(), _bounds.width, _bounds.height);
_frameBuffer->setRenderTarget(rt);
SAFE_RELEASE(rt);
}
Texture::Sampler* sampler = Texture::Sampler::create(_frameBuffer->getRenderTarget()->getTexture());
sampler->setWrapMode(Texture::CLAMP, Texture::CLAMP);
material->getParameter("u_texture")->setValue(sampler);
material->getParameter("u_textureRepeat")->setValue(Vector2::one());
material->getParameter("u_textureTransform")->setValue(Vector2::zero());
SAFE_RELEASE(sampler);
}
int lua_TextureSampler_setWrapMode(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 3:
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL) &&
(lua_type(state, 3) == LUA_TSTRING || lua_type(state, 3) == LUA_TNIL))
{
// Get parameter 1 off the stack.
Texture::Wrap param1 = (Texture::Wrap)lua_enumFromString_TextureWrap(luaL_checkstring(state, 2));
// Get parameter 2 off the stack.
Texture::Wrap param2 = (Texture::Wrap)lua_enumFromString_TextureWrap(luaL_checkstring(state, 3));
Texture::Sampler* instance = getInstance(state);
instance->setWrapMode(param1, param2);
return 0;
}
else
{
lua_pushstring(state, "lua_TextureSampler_setWrapMode - Failed to match the given parameters to a valid function signature.");
lua_error(state);
}
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 3).");
lua_error(state);
break;
}
}
return 0;
}
int lua_TextureSampler_setFilterMode(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 3:
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
lua_type(state, 2) == LUA_TNUMBER &&
lua_type(state, 3) == LUA_TNUMBER)
{
// Get parameter 1 off the stack.
Texture::Filter param1 = (Texture::Filter)luaL_checkint(state, 2);
// Get parameter 2 off the stack.
Texture::Filter param2 = (Texture::Filter)luaL_checkint(state, 3);
Texture::Sampler* instance = getInstance(state);
instance->setFilterMode(param1, param2);
return 0;
}
lua_pushstring(state, "lua_TextureSampler_setFilterMode - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 3).");
lua_error(state);
break;
}
}
return 0;
}
void LightSample::setUnlitMaterialTexture(Model* model, const char* texturePath, bool mipmap)
{
Material* material = model->setMaterial("res/shaders/textured.vert", "res/shaders/textured.frag", "DIRECTIONAL_LIGHT_COUNT 1");
material->setParameterAutoBinding("u_worldViewProjectionMatrix", "WORLD_VIEW_PROJECTION_MATRIX");
// Load the texture from file.
Texture::Sampler* sampler = material->getParameter("u_diffuseTexture")->setValue(texturePath, mipmap);
if (mipmap)
{
sampler->setFilterMode(Texture::LINEAR_MIPMAP_LINEAR, Texture::LINEAR);
}
else
{
sampler->setFilterMode(Texture::LINEAR, Texture::LINEAR);
}
sampler->setWrapMode(Texture::CLAMP, Texture::CLAMP);
material->getStateBlock()->setCullFace(true);
material->getStateBlock()->setDepthTest(true);
material->getStateBlock()->setDepthWrite(true);
material->getStateBlock()->setBlend(true);
material->getStateBlock()->setBlendSrc(RenderState::BLEND_SRC_ALPHA);
material->getStateBlock()->setBlendDst(RenderState::BLEND_ONE_MINUS_SRC_ALPHA);
}
void BillboardSample::loadGround()
{
// Just a basic plane for this sample
Mesh* mesh = Mesh::createQuad(-(GROUND_WIDTH / 2.0f), -(GROUND_HEIGHT / 2.0f), GROUND_WIDTH, GROUND_HEIGHT);
Node* node = Node::create();
_ground = Model::create(mesh);
SAFE_RELEASE(mesh);
node->setDrawable(_ground);
_scene->addNode(node);
node->rotateX(MATH_DEG_TO_RAD(90));
Effect* effect = Effect::createFromFile("res/shaders/textured.vert", "res/shaders/textured.frag", "TEXTURE_REPEAT");
Material* material = Material::create(effect);
material->getStateBlock()->setDepthTest(true);
material->getStateBlock()->setBlend(false);
Texture::Sampler* sampler = material->getParameter("u_diffuseTexture")->setValue("res/png/dirt.png", true);
sampler->setFilterMode(Texture::LINEAR_MIPMAP_LINEAR, Texture::LINEAR);
material->getParameter("u_textureRepeat")->setValue(Vector2(GROUND_REPEAT_TEXTURE, GROUND_REPEAT_TEXTURE));
material->setParameterAutoBinding("u_worldViewProjectionMatrix", RenderState::WORLD_VIEW_PROJECTION_MATRIX);
_ground->setMaterial(material);
SAFE_RELEASE(material);
SAFE_RELEASE(effect)
SAFE_RELEASE(node);
}
int lua_TextureSampler_getRefCount(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
Texture::Sampler* instance = getInstance(state);
unsigned int result = instance->getRefCount();
// Push the return value onto the stack.
lua_pushunsigned(state, result);
return 1;
}
else
{
lua_pushstring(state, "lua_TextureSampler_getRefCount - Failed to match the given parameters to a valid function signature.");
lua_error(state);
}
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
void CreateSceneSample::initialize()
{
// Create the font for drawing the framerate.
_font = Font::create("res/ui/arial.gpb");
// Create a new empty scene.
_scene = Scene::create();
// Create the camera.
Camera* camera = Camera::createPerspective(45.0f, getAspectRatio(), 1.0f, 10.0f);
Node* cameraNode = _scene->addNode("camera");
// Attach the camera to a node. This determines the position of the camera.
cameraNode->setCamera(camera);
// Make this the active camera of the scene.
_scene->setActiveCamera(camera);
SAFE_RELEASE(camera);
// Move the camera to look at the origin.
cameraNode->translate(0, 1, 5);
cameraNode->rotateX(MATH_DEG_TO_RAD(-11.25f));
// Create a white light.
Light* light = Light::createDirectional(0.75f, 0.75f, 0.75f);
Node* lightNode = _scene->addNode("light");
lightNode->setLight(light);
// Release the light because the node now holds a reference to it.
SAFE_RELEASE(light);
lightNode->rotateX(MATH_DEG_TO_RAD(-45.0f));
// Create the cube mesh and model.
Mesh* cubeMesh = createCubeMesh();
Model* cubeModel = Model::create(cubeMesh);
// Release the mesh because the model now holds a reference to it.
SAFE_RELEASE(cubeMesh);
// Create the material for the cube model and assign it to the first mesh part.
Material* material = cubeModel->setMaterial("res/shaders/textured.vert", "res/shaders/textured.frag", "DIRECTIONAL_LIGHT_COUNT 1");
// These parameters are normally set in a .material file but this example sets them programmatically.
// Bind the uniform "u_worldViewProjectionMatrix" to use the WORLD_VIEW_PROJECTION_MATRIX from the scene's active camera and the node that the model belongs to.
material->setParameterAutoBinding("u_worldViewProjectionMatrix", "WORLD_VIEW_PROJECTION_MATRIX");
material->setParameterAutoBinding("u_inverseTransposeWorldViewMatrix", "INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX");
// Set the ambient color of the material.
material->getParameter("u_ambientColor")->setValue(Vector3(0.2f, 0.2f, 0.2f));
// Bind the light's color and direction to the material.
material->getParameter("u_directionalLightColor[0]")->setValue(lightNode->getLight()->getColor());
material->getParameter("u_directionalLightDirection[0]")->bindValue(lightNode, &Node::getForwardVectorWorld);
// Load the texture from file.
Texture::Sampler* sampler = material->getParameter("u_diffuseTexture")->setValue("res/png/crate.png", true);
sampler->setFilterMode(Texture::LINEAR_MIPMAP_LINEAR, Texture::LINEAR);
material->getStateBlock()->setCullFace(true);
material->getStateBlock()->setDepthTest(true);
material->getStateBlock()->setDepthWrite(true);
_cubeNode = _scene->addNode("cube");
_cubeNode->setModel(cubeModel);
_cubeNode->rotateY(MATH_PIOVER4);
SAFE_RELEASE(cubeModel);
}
ActiveTexture::ActiveTexture(const GLuint u, Texture::Sampler& s)
: ActiveObject(*s.GetTexture()), unit(u), samplerObject(&s), ownsSampler(false)
{
samplerObject->Bind(unit);
}
void Material::loadRenderState(RenderState* renderState, Properties* properties)
{
GP_ASSERT(renderState);
GP_ASSERT(properties);
// Rewind the properties to start reading from the start.
properties->rewind();
const char* name;
while ((name = properties->getNextProperty()))
{
if (isMaterialKeyword(name))
continue; // keyword - skip
switch (properties->getType())
{
case Properties::NUMBER:
GP_ASSERT(renderState->getParameter(name));
renderState->getParameter(name)->setValue(properties->getFloat());
break;
case Properties::VECTOR2:
{
Vector2 vector2;
if (properties->getVector2(NULL, &vector2))
{
GP_ASSERT(renderState->getParameter(name));
renderState->getParameter(name)->setValue(vector2);
}
}
break;
case Properties::VECTOR3:
{
Vector3 vector3;
if (properties->getVector3(NULL, &vector3))
{
GP_ASSERT(renderState->getParameter(name));
renderState->getParameter(name)->setValue(vector3);
}
}
break;
case Properties::VECTOR4:
{
Vector4 vector4;
if (properties->getVector4(NULL, &vector4))
{
GP_ASSERT(renderState->getParameter(name));
renderState->getParameter(name)->setValue(vector4);
}
}
break;
case Properties::MATRIX:
{
Matrix matrix;
if (properties->getMatrix(NULL, &matrix))
{
GP_ASSERT(renderState->getParameter(name));
renderState->getParameter(name)->setValue(matrix);
}
}
break;
default:
{
// Assume this is a parameter auto-binding.
renderState->setParameterAutoBinding(name, properties->getString());
}
break;
}
}
// Iterate through all child namespaces searching for samplers and render state blocks.
Properties* ns;
while ((ns = properties->getNextNamespace()))
{
if (strcmp(ns->getNamespace(), "sampler") == 0)
{
// Read the texture uniform name.
name = ns->getId();
if (strlen(name) == 0)
{
GP_ERROR("Texture sampler is missing required uniform name.");
continue;
}
// Get the texture path.
const char* path = ns->getString("path");
if (path == NULL || strlen(path) == 0)
{
GP_ERROR("Texture sampler '%s' is missing required image file path.", name);
continue;
}
// Read texture state (booleans default to 'false' if not present).
bool mipmap = ns->getBool("mipmap");
Texture::Wrap wrapS = parseTextureWrapMode(ns->getString("wrapS"), Texture::REPEAT);
Texture::Wrap wrapT = parseTextureWrapMode(ns->getString("wrapT"), Texture::REPEAT);
Texture::Filter minFilter = parseTextureFilterMode(ns->getString("minFilter"), mipmap ? Texture::NEAREST_MIPMAP_LINEAR : Texture::LINEAR);
Texture::Filter magFilter = parseTextureFilterMode(ns->getString("magFilter"), Texture::LINEAR);
// Set the sampler parameter.
GP_ASSERT(renderState->getParameter(name));
Texture::Sampler* sampler = renderState->getParameter(name)->setValue(path, mipmap);
if (sampler)
{
sampler->setWrapMode(wrapS, wrapT);
sampler->setFilterMode(minFilter, magFilter);
}
}
else if (strcmp(ns->getNamespace(), "renderState") == 0)
{
while ((name = ns->getNextProperty()))
{
GP_ASSERT(renderState->getStateBlock());
renderState->getStateBlock()->setState(name, ns->getString());
}
}
}
}
Texture* ParticleEmitter::getTexture() const
{
Texture::Sampler* sampler = _spriteBatch ? _spriteBatch->getSampler() : NULL;
return sampler? sampler->getTexture() : NULL;
}