bool QgsMeshLayerRenderer::render()
{
renderMesh( mNativeMeshSymbol, mNativeMesh.faces ); // native mesh
renderMesh( mTriangularMeshSymbol, mTriangularMesh.triangles() ); // triangular mesh
return true;
}
void SceneGalaxy::Render()
{
// Render VBO here
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Temp variables
Mtx44 translate, rotate, scale;
Mtx44 MVP;
//These will be replaced by matrix stack soon
Mtx44 model;
Mtx44 view;
Mtx44 projection;
//Set all matrices to identity
translate.SetToIdentity();
rotate.SetToIdentity();
scale.SetToIdentity();
model.SetToIdentity();
//Set view matrix using camera settings
viewStack.LoadIdentity();
viewStack.LookAt(
camera.position.x, camera.position.y, camera.position.z,
camera.target.x, camera.target.y, camera.target.z,
camera.up.x, camera.up.y, camera.up.z
);
//Set projection matrix to perspective mode
projection.SetToPerspective(45.0f, 4.0f / 3.0f, 0.1f, 10000.0f); //FOV, Aspect Ratio, Near plane, Far plane
modelStack.PushMatrix();
modelStack.Translate(light[0].position.x, light[0].position.y, light[0].position.z);
modelStack.Scale(0.1f, 0.1f, 0.1f);
renderMesh(meshList[GEO_LIGHTBALL], false);
modelStack.PopMatrix();
/*modelStack.PushMatrix();
renderMesh(meshList[GEO_AXES], false);
modelStack.PopMatrix();*/
modelStack.PushMatrix();
modelStack.Translate(0, 496.9f, 0);
RenderSkybox();
modelStack.PopMatrix();
RenderXwing();
RenderAsteroid();
RenderMissile();
QuestDetail();
RenderTextOnScreen(meshList[GEO_TEXT], "+", Color(0, 1, 0), 3, 13.1, 9);
std::stringstream playerPos;
playerPos << "X = " << camPosX << " Y = " << camPosY << " Z = " << camPosz;
//RenderTextOnScreen(meshList[GEO_TEXT], playerPos.str(), Color(1, 0, 0), 2, 0, 18);
std::stringstream ss;
ss << "FPS:" << fps << " " << playerPos.str();
RenderTextOnScreen(meshList[GEO_TEXT], ss.str(), Color(0, 1, 0), 3, 0, 19);
}
void SceneGalaxy::QuestDetail()
{
if (QuestDetailShown == false)
{
Mtx44 ortho;
glDisable(GL_DEPTH_TEST);
ortho.SetToOrtho(0, 80, 0, 60, -10, 10); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Translate(37.5, 27.5, -2);
modelStack.Scale(30, 50, 10);
modelStack.Rotate(90, 1, 0, 0);
renderMesh(meshList[GEO_BLACKSCREEN], false);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
if (Application::IsKeyPressed('E'))
{
QuestDetailShown = true;
}
}
}
void
ObjGlWidget::renderAll()
{
if (mMesh != nullptr) {
renderMesh(*mMesh);
}
}
void StandardRenderer::render(ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext, GameObject* gameObject)
{
// simplest possible renderer
// get world matrix
XMMATRIX worldMatrix = gameObject->transformMatrix;
// only supports one parent at moment
if (gameObject->parent)
{
// for some reason it breaks if you remove this line...
// it could be something to do with the warning C4316
XMMATRIX parentTransform = gameObject->parent->transformMatrix;
worldMatrix *= parentTransform;
}
GameContext * gameContext = gameObject->gameContext;
XMMATRIX viewMatrix = gameContext->renderingContext->primaryCamera->viewMatrix;
XMMATRIX projectionMatrix = gameContext->renderingContext->projectionMatrix;
XMMATRIX matWorldViewProjection = worldMatrix * viewMatrix * projectionMatrix;
// update constant buffers
gameObject->shaderPair->updateBuffersPerObject(pd3dImmediateContext, worldMatrix, matWorldViewProjection, XMFLOAT4(1, 1, 1, 1));
setMesh(pd3dImmediateContext, gameObject->sharedMesh);
renderMesh(pd3dImmediateContext, gameObject->sharedMesh);
}
void Character::render(float framerate) {
//move internal animation timer forward
updateTime(framerate);
renderMesh((ResourceManager::get())->getMesh("spirit"),
(ResourceManager::get())->getCharacterShader());
}
void Mesh::render() {
glUseProgram(program);
if (program != 0) {
//glUniform1i(glGetUniformLocation(program, "samplerd"), 2);
}
for (int i = 0; i < meshes.size(); i++) {
/*if (program != 0) {
if (hasTexture(i)) {
glUniform1i(glGetUniformLocation(program, "hasTex"), 1);
GV_CHECK_GL_ERROR();
} else {
glUniform1i(glGetUniformLocation(program, "hasTex"), 0);
}
glUniform3f(glGetUniformLocation(program, "lightPos"), lightPos[0], lightPos[1], lightPos[2]);
GV_CHECK_GL_ERROR();
glUniform4f(glGetUniformLocation(program, "ambientLight"), meshes[i].ambient[0], meshes[i].ambient[1], meshes[i].ambient[2], meshes[i].ambient[3]);
GV_CHECK_GL_ERROR();
glUniform4f(glGetUniformLocation(program, "specularColor"), meshes[i].specular[0], meshes[i].specular[1], meshes[i].specular[2], meshes[i].ambient[3]);
GV_CHECK_GL_ERROR();
glUniform1f(glGetUniformLocation(program, "shininess"), meshes[i].shininess);
} */
GV_CHECK_GL_ERROR();
renderMesh(i);
GV_CHECK_GL_ERROR();
}
glUseProgram(0);
GV_CHECK_GL_ERROR();
}
void Model::onRender()
{
// set global OpenGL states
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
//// DEBUG: CLOTH SIM
/*
static CalVector spherePosition;
spherePosition.set(Sphere.x, Sphere.y, Sphere.z);
static float sphereRadius = 15.0f;
// m_calModel->getSpringSystem()->setSphere(spherePosition.x, spherePosition.y, spherePosition.z, sphereRadius);
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_STRIP);
glVertex3f(spherePosition.x + sphereRadius, spherePosition.y, spherePosition.z);
glVertex3f(spherePosition.x, spherePosition.y + sphereRadius, spherePosition.z);
glVertex3f(spherePosition.x - sphereRadius, spherePosition.y, spherePosition.z);
glVertex3f(spherePosition.x, spherePosition.y - sphereRadius, spherePosition.z);
glVertex3f(spherePosition.x + sphereRadius, spherePosition.y, spherePosition.z);
glVertex3f(spherePosition.x, spherePosition.y, spherePosition.z + sphereRadius);
glVertex3f(spherePosition.x - sphereRadius, spherePosition.y, spherePosition.z);
glVertex3f(spherePosition.x, spherePosition.y, spherePosition.z - sphereRadius);
glVertex3f(spherePosition.x + sphereRadius, spherePosition.y, spherePosition.z);
glVertex3f(spherePosition.x, spherePosition.y + sphereRadius, spherePosition.z);
glVertex3f(spherePosition.x, spherePosition.y, spherePosition.z + sphereRadius);
glVertex3f(spherePosition.x, spherePosition.y - sphereRadius, spherePosition.z);
glVertex3f(spherePosition.x, spherePosition.y, spherePosition.z - sphereRadius);
glVertex3f(spherePosition.x, spherePosition.y + sphereRadius, spherePosition.z);
glEnd();
*/
//// DEBUG END
//CalSkeleton *pCalSkeleton = m_calModel->getSkeleton();
// Note :
// You have to call coreSkeleton.calculateBoundingBoxes(calCoreModel)
// during the initialisation (before calModel.create(calCoreModel))
// if you want to use bounding boxes.
//m_calModel->getSkeleton()->calculateBoundingBoxes();
// Note:
// Uncomment the next lines if you want to test the experimental collision system.
// Also remember that you need to call calculateBoundingBoxes()
//m_calModel->getSpringSystem()->setForceVector(CalVector(0.0f,0.0f,0.0f));
//m_calModel->getSpringSystem()->setCollisionDetection(true);
renderMesh(theMenu.isWireframe(), theMenu.isLight());
// clear global OpenGL states
glDisable(GL_DEPTH_TEST);
}
void Camera::renderMeshes(World *w, Surface *s) {
for(int i = 0; i < w->meshes.size(); i++) {
//Skip nulls
if(!w->meshes[i])
continue;
renderMesh(w->meshes[i], s);
}
}
void HdrApp::renderRgb()
{
// Render the skybow and the mesh
rtRgb->beginCapture();
getRenderer()->clearBuffer();
cam->useLeft();
getRenderer()->renderSkyBox(cubeMapRgb);
renderMesh(textureRgb, cubeMapRgb);
rtRgb->endCapture();
}
void Table::draw(VSShaderLib shader, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId)
{
loadMesh(_meshes.at(0), shader);
pushMatrix(MODEL);
translate(MODEL, _position.getX(), _position.getY(), _position.getZ());
scale(MODEL, 9.0f, 0.0000001f, 9.0f);
renderMesh(_meshes.at(0), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
}
void Cup::draw(VSShaderLib shader, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId)
{
pushMatrix(MODEL);
translate(MODEL, _position.getX(), _position.getY(), _position.getZ());
loadMesh(_meshes.at(0), shader);
pushMatrix(MODEL);
scale(MODEL,0.5f, 10.0f, 0.5f);
renderMesh(_meshes.at(0), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
loadMesh(_meshes.at(1), shader);
pushMatrix(MODEL);
translate(MODEL, 0.0,-0.5,0.0);
scale(MODEL, 0.5f, 0.01f, 0.5f);
renderMesh(_meshes.at(1), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
popMatrix(MODEL);
}
void Pause::draw(VSShaderLib shader, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId)
{
GameObject::drawTextures();
loadMesh(_meshes.at(0), shader);
pushMatrix(MODEL);
translate(MODEL, _position.getX(), _position.getY(), _position.getZ());
scale(MODEL, 5.0f, 5.0f, 1.0f);
renderMesh(_meshes.at(0), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
}
void Renderer::renderRenderData(RenderState& rstate, RenderData* render_data) {
if (!(rstate.render_mask & render_data->render_mask()))
return;
// Set the states
setRenderStates(render_data, rstate);
if (render_data->mesh() != 0) {
GL(renderMesh(rstate, render_data));
}
// Restoring to Default.
// TODO: There's a lot of redundant state changes. If on every render face culling is being set there's no need to
// restore defaults. Possibly later we could add a OpenGL state wrapper to avoid redundant api calls.
restoreRenderStates(render_data);
}
/* Render this model. Depending on mode, different render functions are called. */
void ModelGL::Render () {
if (_renderMode == OFF) return;
for (int g = 0; g < _nrGeosets; g ++) {
if (_geosets[g].enabled) {
switch (_renderMode) {
case DIRECT : renderDirect (_geosets[g]); break;
case POINTS : renderPoints (_geosets[g]); break;
case MESH : renderMesh (_geosets[g]); break;
case VBO : renderVBO (_VBOs[g]); break;
}
}
}
}
void SceneGalaxy::RenderXwing()
{
if (renderXWing == true)
{
modelStack.PushMatrix();
modelStack.Translate(XWing.x, XWing.y, XWing.z);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Rotate(rotateXWing, 0, 0, 1);
modelStack.Rotate(camera.rotateChar, 0, 1, 0);
modelStack.Scale(2.2f, 2.2f, 2.2f);
renderMesh(meshList[GEO_XWING], true);
modelStack.PopMatrix();
}
}
void Broccoli::draw(VSShaderLib shader, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId)
{
GameObject::drawTextures();
loadMesh(_meshes.at(0), shader);
pushMatrix(MODEL);
translate(MODEL, _position.getX(), _position.getY(), _position.getZ());
rotate(MODEL, _angle, _dir.getX(), _dir.getY(), _dir.getZ());
translate(MODEL, -0.5, 0, 0);
scale(MODEL, 1.0f, 1.0f, 0.0001f);
renderMesh(_meshes.at(0), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
}
void ModelRendererGl::render(Model *model,int renderMode) {
//assertions
assert(rendering);
assertGl();
//if(model->getIsStaticModel()) printf("In [%s::%s Line: %d] filename [%s] is static about to render...\n",__FILE__,__FUNCTION__,__LINE__,model->getFileName().c_str());
//render every mesh
//if(model->getIsStaticModel() == true) {
for(uint32 i = 0; i < model->getMeshCount(); ++i) {
renderMesh(model->getMeshPtr(i),renderMode);
}
//}
//assertions
assertGl();
}
void SceneGalaxy::RenderSkybox()
{
if (renderSkybox == true)
{
modelStack.PushMatrix();
modelStack.Translate(0, 0, -498);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_GALAXYBACK], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 498, 0);
modelStack.Rotate(-90, 0, 1, 0);
modelStack.Rotate(180, 1, 0, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_GALAXYTOP], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-498, 0, 0);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Rotate(90, 0, 1, 0);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_GALAXYLEFT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(498, 0, 0);
modelStack.Rotate(90, 0, 0, 1);
modelStack.Rotate(90, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_GALAXYFRONT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, -498, 0);
modelStack.Rotate(-90, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_GALAXYBOTTOM], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 0, 498);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_GALAXYRIGHT], false);
modelStack.PopMatrix();
}
}
void SceneGalaxy::RenderMissile()
{
if (shootMissile == true)
{
for (int i = 0; i < missile.Missiles; i++)
{
modelStack.PushMatrix();
missilePos = missile.Capacity[i].getPositionOfMissile();
modelStack.Translate((missilePos.x) , (missilePos.y), (missilePos.z));
modelStack.Scale(4.f, 4.f, 4.f);
modelStack.Rotate(camera.rotateChar, 0, 1, 0);
renderMesh(meshList[GEO_MISSILE], true);
modelStack.PopMatrix();
}
}
}
void Renderer::renderRenderData(RenderState& rstate, RenderData* render_data) {
if (!rstate.render_mask || !render_data->render_mask())
return;
if (render_data->offset()) {
GL(glEnable (GL_POLYGON_OFFSET_FILL));
GL(glPolygonOffset(render_data->offset_factor(),
render_data->offset_units()));
}
if (!render_data->depth_test()) {
GL(glDisable (GL_DEPTH_TEST));
}
if (!render_data->alpha_blend()) {
GL(glDisable (GL_BLEND));
}
if( render_data->alpha_to_coverage()) {
GL(glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE));
GL(glSampleCoverage(render_data->sample_coverage(),render_data->invert_coverage_mask()));
}
if (render_data->mesh() != 0) {
GL(renderMesh(rstate, render_data));
}
// Restoring to Default.
// TODO: There's a lot of redundant state changes. If on every render face culling is being set there's no need to
// restore defaults. Possibly later we could add a OpenGL state wrapper to avoid redundant api calls.
if (render_data->cull_face() != RenderData::CullBack) {
GL(glEnable (GL_CULL_FACE));
GL(glCullFace (GL_BACK));
}
if (render_data->offset()) {
GL(glDisable (GL_POLYGON_OFFSET_FILL));
}
if (!render_data->depth_test()) {
GL(glEnable (GL_DEPTH_TEST));
}
if (!render_data->alpha_blend()) {
GL(glEnable (GL_BLEND));
}
if (render_data->alpha_to_coverage()) {
GL(glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE));
}
}
void Assignment3::RenderSkybox()
{
modelStack.PushMatrix();
modelStack.Translate(0, 0, -498);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_FRONT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 498, 0);
modelStack.Rotate(-90, 0, 1, 0);
modelStack.Rotate(180, 1, 0, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_TOP], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-498, 0, 0);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Rotate(90, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_LEFT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(498, 0, 0);
modelStack.Rotate(90, 0, 0, 1);
modelStack.Rotate(-90, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_RIGHT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, -498, 0);
modelStack.Rotate(-90, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_BOTTOM], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 0, 498);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Scale(1000, 1000, 1000);
renderMesh(meshList[GEO_BACK], false);
modelStack.PopMatrix();
}
//------------------------------------------------------------------------------
const RenderMesh* RenderMeshManager::CreateRenderMesh(PolygonType polygonType, const VertexFormat& vertexFormat, IndexFormat indexFormat, u32 numVertices, u32 numIndices, const Sphere& boundingSphere,
std::unique_ptr<const u8[]> vertexData, u32 vertexDataSize, std::unique_ptr<const u8[]> indexData, u32 indexDataSize, bool shouldBackupData,
std::vector<Matrix4> inverseBindPoseMatrices) noexcept
{
RenderMeshUPtr renderMesh(new RenderMesh(polygonType, vertexFormat, indexFormat, numVertices, numIndices, boundingSphere, shouldBackupData, std::move(inverseBindPoseMatrices)));
auto rawRenderMesh = renderMesh.get();
PendingLoadCommand loadCommand;
loadCommand.m_renderMesh = rawRenderMesh;
loadCommand.m_vertexData = std::move(vertexData);
loadCommand.m_vertexDataSize = vertexDataSize;
loadCommand.m_indexData = std::move(indexData);
loadCommand.m_indexDataSize = indexDataSize;
std::unique_lock<std::mutex> lock(m_mutex);
m_renderMeshes.push_back(std::move(renderMesh));
m_pendingLoadCommands.push_back(std::move(loadCommand));
return rawRenderMesh;
}
void Model::onRender()
{
/*
glClearDepth(1.0f);
core->resize3D();
*/
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glShadeModel(GL_SMOOTH);
// check if we need to render the mesh
renderMesh(false, false);
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
}
void VRMeshEditor::display(GLContextData& contextData) const
{
/* Retrieve context entry: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Render mesh: */
glPushAttrib(GL_ENABLE_BIT|GL_POLYGON_BIT);
switch(renderMode)
{
case SHADED:
glEnable(GL_LIGHTING);
glEnable(GL_NORMALIZE);
glDisable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
glMaterial(GLMaterialEnums::FRONT,meshMaterial);
renderMesh(dataItem);
break;
case WIREFRAME:
glDisable(GL_LIGHTING);
glColor3f(0.0f,1.0f,0.0f);
renderMeshWireframe(*mesh,1.0f,0.0f);
break;
}
glPopAttrib();
/* Render all draggers: */
for(DraggerList::const_iterator dIt=draggers.begin(); dIt!=draggers.end(); ++dIt)
(*dIt)->glRenderAction(contextData);
/* Render the morph box: */
if(morphBox!=0)
morphBox->glRenderAction(contextData);
}
void AssetRenderer::renderMesh(const mat4f &cameraPerspective, const ml::D3D11TriMesh &mesh, const vec3f &color)
{
renderMesh(cameraPerspective, mat4f::identity(), mesh, color);
}
void AssetRenderer::renderCylinder(const mat4f &cameraPerspective, const vec3f &p0, const vec3f &p1, const vec3f &color)
{
renderMesh(cameraPerspective, mat4f::translation(p0) * mat4f::face(vec3f::eZ, p1 - p0) * mat4f::scale(1.0f, 1.0f, vec3f::dist(p0, p1)), m_cylinder, color);
}
void GameState::renderModel(RenderContext *render_context, ModelWrapper *model, Vec3 position, Vec3 scale, Vec4 color, float roughness, float metallic) {
for(u32 i = 0; i < model->mesh_count; i++) {
renderMesh(render_context, &model->meshes[i], position, scale, color * model->meshes[i].color, roughness, metallic);
}
}
void AssetRenderer::renderBox(const mat4f &cameraPerspective, const vec3f ¢er, float radius, const vec3f &color)
{
renderMesh(cameraPerspective, mat4f::translation(center) * mat4f::scale(radius), m_box, color);
}
void GameState::renderGeometry(PlatformWindow *window, RenderContext *render_context, InputManager *input, Assets *assets, Platform *platform, f32 delta, bool can_override_shader) {
render_context->bindTexture2D(&assets->debug, 0);
for(u32 z = 0; z < 30; z++) {
for(u32 x = 0; x < 30; x++) {
Vec3 position = world_offset + Vec3(CHUNK_SIZE * x, -1.0f * x, CHUNK_SIZE * z) + Vec3(CHUNK_SIZE *0.5f, 0.0f, CHUNK_SIZE * 0.5f);
Vec4 color = Vec4((f32)x / 3.0f, 0.0f, (f32)z / 3.0f, 1.0f);
// renderMesh(render_context, &test_cube_mesh, position, Vec3(CHUNK_SIZE * 0.5f, 1.0f, CHUNK_SIZE * 0.5f), color, 1.0f, 0.0f);
}
}
renderMesh(render_context, &terrain_mesh, Vec3() + world_offset, Vec3(1.0f), Vec4(1.0f), 1.0f, 0.0f);
// renderMesh(render_context, &test_cube_mesh, Vec3(0.0f, 0.0f, 0.0f), Vec3(6.0f, 3.0f, 6.0f), Vec4(0.0f, 1.0f, 0.0f, 1.0f), 1.0f, 0.0f);
int sphere_count = 10;
for(int y = 0; y < sphere_count; y++) {
float metallic = y * (1.0f / (f32)sphere_count);
for(int x = 0; x < sphere_count; x++) {
float roughness = x * (1.0f / (f32)sphere_count);
// renderMesh(render_context, &test_sphere_mesh, Vec3(x * 2.0f, y * 2.0f, 0.0f), Vec3(1.0f), Vec4(1.0f), roughness, metallic);
}
}
Vec3 model_position = Vec3(0.0f, 4.0f, 0.0f);
for(u32 i = 0; i < assets->chr_old.voxel_count; i++) {
Voxel &voxel = assets->chr_old.voxels[i];
Vec4 color = Vec4();
u32 palette_color = assets->chr_old.palette[voxel.color_index];
f32 d = 1.0f / 255.0f;
for(int b = 0; b < 4; b++) {
color.xyzw[b] = (f32)GetByte(b, palette_color) * d;
}
// renderMesh(render_context, &test_cube_mesh, model_position + Vec3(voxel.x, voxel.z, voxel.y), Vec3(0.5f), color, 1.0f, 0.0f);
}
// for(u32 z = 0; z < MAP_SIZE; z++) {
// for(u32 x = 0; x < MAP_SIZE; x++) {
// u8 y = g_map[z][x];
// Vec3 position = Vec3(x, y, z);
// renderMesh(render_context, &test_cube_mesh, position, Vec3(0.5f), g_color_lookups[y], 1.0f, 0.0f);
// }
// }
// renderModel(render_context, &assets->model, Vec3(-5.0f, 0.0f, 0.0f), Vec3(0.01f), Vec4(1.0f), 1.0f, 0.0f);
// renderModel(render_context, &assets->tree2, Vec3(-10.0f, 0.0f, 0.0f), Vec3(0.1f), Vec4(1.0f), 1.0f, 0.0f);
// renderModel(render_context, &assets->trees, Vec3(-10.0f, 0.0f, 0.0f), Vec3(0.1f), Vec4(1.0f), 1.0f, 0.0f);
// for(int i = 0; i < 4; i++)
// for(int j = 0; j < 4; j++)
// renderModel(render_context, &assets->well, Vec3(-10.0f + (j * 2), -0.9f, i * 2), Vec3(1.0f), Vec4(1.0f), 1.0f, 0.0f);
// renderMesh(render_context, &test_cube_mesh, Vec3(0.0f, -1.0f, 0.0f), Vec3(30.0f, 1.0f, 30.0f), Vec4(1.0f), 1.0f, 0.0f);
if(can_override_shader)
render_context->bindShader(&assets->shaders.statics);
// renderStaticMesh(render_context, &assets->test_static, draw_position, Vec3(1.0f), Vec4(1.0f), 1.0f, 0.0f);
for(u32 i = 0; i < static_mesh_reference_count; i++) {
StaticMeshReference &reference = static_mesh_references[i];
StaticMeshData *data = &assets->static_meshes.meshes[reference.index];
// renderStaticMesh(render_context, data, reference.transform, Vec4(1.0f), 1.0f, 0.0f);
}
if(can_override_shader)
render_context->bindShader(&assets->shaders.skinned);
renderSkinnedMesh(render_context, &assets->skel_dude, npc_position, Vec3(0.025f), Vec4(1.0f), 1.0f, 0.0f);
}
