void test_initMaterial(void)
{
// Initialised material should have expected defaults.
int i;
tinyobj_material_t material;
initMaterial(&material);
TEST_CHECK(material.name == NULL);
TEST_CHECK(material.ambient_texname == NULL);
TEST_CHECK(material.diffuse_texname == NULL);
TEST_CHECK(material.specular_texname == NULL);
TEST_CHECK(material.specular_highlight_texname == NULL);
TEST_CHECK(material.bump_texname == NULL);
TEST_CHECK(material.displacement_texname == NULL);
TEST_CHECK(material.alpha_texname == NULL);
for (i = 0; i < 3; i++) {
TEST_CHECK(material.ambient[i] == 0.f);
TEST_CHECK(material.diffuse[i] == 0.f);
TEST_CHECK(material.specular[i] == 0.f);
TEST_CHECK(material.transmittance[i] == 0.f);
TEST_CHECK(material.emission[i] == 0.f);
}
TEST_CHECK(material.illum == 0);
TEST_CHECK(material.dissolve == 1.f);
TEST_CHECK(material.shininess == 1.f);
TEST_CHECK(material.ior == 1.f);
}
// 加载 model
bool StaticMesh::loadModelFromFile(const std::string& filepath)
{
Assimp::Importer importer;
const aiScene* scene = importer.ReadFile(filepath, m_FlipUVs ? (aiProcessPreset_TargetRealtime_Quality | aiProcess_FlipUVs)
: aiProcessPreset_TargetRealtime_Quality);
if (!scene)
{
std::cout << "Couldn't load model, Error Importing Asset :" << filepath << std::endl;
Log::Instance()->OutputError("Couldn't load model, Error Importing Asset : %s", filepath.c_str());
return false;
}
m_MeshEntries.resize(scene->mNumMeshes);
m_Textures.resize(scene->mNumMaterials);
initMesh(scene, scene->mRootNode); // init mesh
// 加载所有 texture
if (scene->mNumMaterials > 0)
{
if (!initMaterial(scene, filepath))
{
std::cout << "Material 加载不完整" << std::endl;
m_IsLoaded = false;
return false;
}
}
m_IsLoaded = true;
return true;
}
bool DestroyMaterial(const EString &name) {
initMaterial();
MaterialIter iter = GMaterials->find(name);
if (iter != GMaterials->end())
SafeDelete(iter->second);
GMaterials->erase(iter);
return true;
}
EMaterial *GetMaterail(const EString &name){
initMaterial();
MaterialIter iter = GMaterials->find(name);
if (iter == GMaterials->end())
return NULL;
else
return iter->second;
}
void MeshViewer::initScene(InitialCameraData &camera_data)
{
initContext();
initLights();
initMaterial();
initGeometry();
initCamera( camera_data );
preprocess();
}
bool CharacterGame::initScene(Node* node, void* cookie)
{
Model* model = node->getModel();
if (model)
{
if (model->getMaterial())
{
initMaterial(_scene, node, model->getMaterial());
}
for (unsigned int i = 0; i < model->getMeshPartCount(); ++i)
{
if (model->hasMaterial(i))
{
initMaterial(_scene, node, model->getMaterial(i));
}
}
}
return true;
}
ObjFile* createObjFile(const char* filename)
{
// creates and inits an ObjFile
// error checking
if (strlen(filename) >= MAX_STRING_LENGTH)
{
return NULL;
}
ObjFile* objFile = (ObjFile*)malloc(sizeof(ObjFile));
if (NULL == objFile)
{
return NULL;
}
// initialize
strcpy(objFile->name, filename);
objFile->positions = NULL;
objFile->normals = NULL;
objFile->texCoords = NULL;
objFile->objects = NULL;
objFile->groups = NULL;
objFile->faces = NULL;
objFile->materials = NULL;
objFile->numPositions = 0;
objFile->numNormals = 0;
objFile->numTexCoords = 0;
objFile->numObjects = 0;
objFile->numGroups = 0;
objFile->numFaces = 0;
objFile->numMaterials = 0;
objFile->materials = (ObjMaterial*)malloc(sizeof(ObjMaterial));
objFile->numMaterials = 1;
initMaterial(&objFile->materials[0]);
return objFile;
}
void readMaterials(ObjFile* file, FILE* f)
{
rewind(f);
char line[MAX_STRING_LENGTH];
char* tline;
// first material is a default material
initMaterial(&file->materials[0]);
file->numMaterials = 1;
while (NULL != fgets(line, MAX_STRING_LENGTH, f))
{
tline = trimBeginning(line);
char name[MAX_STRING_LENGTH];
// read in the material name
if (strstr(tline, "newmtl") == tline)
{
file->numMaterials++;
// initialize the new material
initMaterial(&file->materials[file->numMaterials - 1]);
// copy the name from the tline
if (sscanf(tline, "newmtl %s", name) == 1)
{
strcpy(file->materials[file->numMaterials - 1].name, name);
}
}
// read in ambient
if (strstr(tline, "Ka") == tline)
{
ObjVector3F ambient;
int n = sscanf(
tline,
"Ka %f %f %f",
&ambient.x,
&ambient.y,
&ambient.z
);
if (n == 3)
{
file->materials[file->numMaterials - 1].ambient = ambient;
}
}
// read diffuse
if (strstr(tline, "Kd") == tline)
{
ObjVector3F diffuse;
int n = sscanf(
tline,
"Kd %f %f %f",
&diffuse.x,
&diffuse.y,
&diffuse.z
);
if (n == 3)
{
file->materials[file->numMaterials - 1].diffuse = diffuse;
}
}
// read specular
if (strstr(tline, "Ks") == tline)
{
ObjVector3F specular;
int n = sscanf(
tline,
"Ks %f %f %f",
&specular.x,
&specular.y,
&specular.z
);
if (n == 3)
{
file->materials[file->numMaterials - 1].specular = specular;
}
}
// read shininess
if (strstr(tline, "Ns") == tline)
{
float shininess;
if (sscanf(tline, "Ns %f", &shininess) == 1)
{
file->materials[file->numMaterials - 1].shininess = shininess;
}
}
// read ambient tex
if (strstr(tline, "map_Ka") == tline)
{
char name[MAX_STRING_LENGTH];
if (sscanf(tline, "map_Ka %s", name) == 1)
{
strcpy(
file->materials[file->numMaterials - 1].ambientTex,
name
);
}
}
// read diffuse tex
if (strstr(tline, "map_Kd") == tline)
{
char name[MAX_STRING_LENGTH];
if (sscanf(tline, "map_Kd %s", name) == 1)
{
strcpy(
file->materials[file->numMaterials - 1].diffuseTex,
name
);
}
}
// read specular tex
if (strstr(tline, "map_Ks") == tline)
{
char name[MAX_STRING_LENGTH];
if (sscanf(tline, "map_Ks %s", name) == 1)
{
strcpy(
file->materials[file->numMaterials - 1].specularTex,
name
);
}
}
}
}
void WaterPlane::innerRender( SceneRenderState *state )
{
GFXDEBUGEVENT_SCOPE( WaterPlane_innerRender, ColorI( 255, 0, 0 ) );
const Point3F &camPosition = state->getCameraPosition();
Point3F rvec, fvec, uvec, pos;
const MatrixF &objMat = getTransform(); //getRenderTransform();
const MatrixF &camMat = state->getCameraTransform();
MatrixF renderMat( true );
camMat.getColumn( 1, &fvec );
uvec.set( 0, 0, 1 );
rvec = mCross( fvec, uvec );
rvec.normalize();
fvec = mCross( uvec, rvec );
pos = camPosition;
pos.z = objMat.getPosition().z;
renderMat.setColumn( 0, rvec );
renderMat.setColumn( 1, fvec );
renderMat.setColumn( 2, uvec );
renderMat.setColumn( 3, pos );
setRenderTransform( renderMat );
// Setup SceneData
SceneData sgData = setupSceneGraphInfo( state );
// set the material
S32 matIdx = getMaterialIndex( camPosition );
if ( !initMaterial( matIdx ) )
return;
BaseMatInstance *mat = mMatInstances[matIdx];
WaterMatParams matParams = mMatParamHandles[matIdx];
// render the geometry
if ( mat )
{
// setup proj/world transform
mMatrixSet->restoreSceneViewProjection();
mMatrixSet->setWorld(getRenderTransform());
setShaderParams( state, mat, matParams );
while( mat->setupPass( state, sgData ) )
{
mat->setSceneInfo(state, sgData);
mat->setTransforms(*mMatrixSet, state, sgData);
setCustomTextures( matIdx, mat->getCurPass(), matParams );
// set vert/prim buffer
GFX->setVertexBuffer( mVertBuff );
GFX->setPrimitiveBuffer( mPrimBuff );
GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, mVertCount, 0, mPrimCount );
}
}
}
/*
* Written by Robert "Chip" Senkbeil
* Uses -lglut, -lGLU, and -lGL to compile on Linux.
*/
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(0, 0);
glutInitWindowSize(640, 640);
glutCreateWindow(argv[0]);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
//glutReshapeFunc(/* ... */);
glutSpecialFunc(arrowPress);
glutKeyboardFunc(keyPress);
glutMouseFunc(mouseEvent);
glutMotionFunc(mouseMoveEvent);
glutDisplayFunc(render);
glutIdleFunc(idleEvent);
// Build and attach the menu
buildPopupMenu();
glutAttachMenu(GLUT_RIGHT_BUTTON);
// Allocate memory for a new robot
printf("Allocating new robot...\n");
robot = new Robot();
// Add robot initial keyframe to animation clip
{
Keyframe k_;
k_.getKeyframeFromRobot(robot);
aClip.addKeyframeAtCurrent(k_);
}
printf("Setting up the camera...\n");
camera.setCameraMaxDistance(4.0f);
//camera.lock();
// Set default fps
framesPerSecond = DEFAULT_FRAMES_PER_SECOND;
isPlaying = 0;
playingForward = 1;
playingBackward = 0;
currentTime = 0;
baseTime = 0;
frames = 0;
framesTotal = 0;
// Set termination callback
atexit(terminate_prog);
// Enable lighting
setupLight();
// Setup a global material
initMaterial();
// Enable texture
glEnable(GL_TEXTURE_2D);
robot->loadTexture("texture/CorrugatedSharp.png");
// Start the main loop
glutMainLoop();
// Exit program
return 0;
}
RenderingCoreInterlaced::RenderingCoreInterlaced(
IrrlichtDevice *_device, Client *_client, Hud *_hud)
: RenderingCoreStereo(_device, _client, _hud)
{
initMaterial();
}
bool SetMaterial(const EString &name, EMaterial *material) {
initMaterial();
GMaterials->insert(std::make_pair(name, material));
return true;
}
