kraken_engine/kraken
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Auto format C++ source

Browse Source
This commit is contained in:
Kearwood Gilbert
2022-08-08 01:07:26 -07:00
parent c5a640e22d
commit 7433d54c16
155 changed files with 17259 additions and 16879 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
kraken/KRAmbientZone.cpp
View File

@@ -42,7 +42,7 @@ void KRAmbientZone::InitNodeInfo(KrNodeInfo* nodeInfo)
nodeInfo->ambient_zone.sample = -1; nodeInfo->ambient_zone.sample = -1;
} }
KRAmbientZone::KRAmbientZone(KRScene &scene, std::string name) : KRNode(scene, name) KRAmbientZone::KRAmbientZone(KRScene& scene, std::string name) : KRNode(scene, name)
{ {
m_ambient = ""; m_ambient = "";
m_ambient_gain = 1.0f; m_ambient_gain = 1.0f;
@@ -52,16 +52,16 @@ KRAmbientZone::KRAmbientZone(KRScene &scene, std::string name) : KRNode(scene, n
} }
KRAmbientZone::~KRAmbientZone() KRAmbientZone::~KRAmbientZone()
{ {}
}
std::string KRAmbientZone::getElementName() { std::string KRAmbientZone::getElementName()
{
return "ambient_zone"; return "ambient_zone";
} }
tinyxml2::XMLElement *KRAmbientZone::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRAmbientZone::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
e->SetAttribute("zone", m_zone.c_str()); e->SetAttribute("zone", m_zone.c_str());
e->SetAttribute("sample", m_ambient.c_str()); e->SetAttribute("sample", m_ambient.c_str());
e->SetAttribute("gain", m_ambient_gain); e->SetAttribute("gain", m_ambient_gain);
@@ -69,21 +69,21 @@ tinyxml2::XMLElement *KRAmbientZone::saveXML( tinyxml2::XMLNode *parent)
return e; return e;
} }
void KRAmbientZone::loadXML(tinyxml2::XMLElement *e) void KRAmbientZone::loadXML(tinyxml2::XMLElement* e)
{ {
KRNode::loadXML(e); KRNode::loadXML(e);
m_zone = e->Attribute("zone"); m_zone = e->Attribute("zone");
m_gradient_distance = 0.25f; m_gradient_distance = 0.25f;
if(e->QueryFloatAttribute("gradient", &m_gradient_distance) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("gradient", &m_gradient_distance) != tinyxml2::XML_SUCCESS) {
m_gradient_distance = 0.25f; m_gradient_distance = 0.25f;
} }
m_ambient = e->Attribute("sample"); m_ambient = e->Attribute("sample");
m_ambient_gain = 1.0f; m_ambient_gain = 1.0f;
if(e->QueryFloatAttribute("gain", &m_ambient_gain) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("gain", &m_ambient_gain) != tinyxml2::XML_SUCCESS) {
m_ambient_gain = 1.0f; m_ambient_gain = 1.0f;
} }
} }
@@ -93,7 +93,7 @@ std::string KRAmbientZone::getAmbient()
return m_ambient; return m_ambient;
} }
void KRAmbientZone::setAmbient(const std::string &ambient) void KRAmbientZone::setAmbient(const std::string& ambient)
{ {
m_ambient = ambient; m_ambient = ambient;
} }
@@ -113,20 +113,20 @@ std::string KRAmbientZone::getZone()
return m_zone; return m_zone;
} }
void KRAmbientZone::setZone(const std::string &zone) void KRAmbientZone::setZone(const std::string& zone)
{ {
m_zone = zone; m_zone = zone;
} }
void KRAmbientZone::render(RenderInfo& ri) void KRAmbientZone::render(RenderInfo& ri)
{ {
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRNode::render(ri); KRNode::render(ri);
bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_SIREN_AMBIENT_ZONES; bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_SIREN_AMBIENT_ZONES;
if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) { if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere"); KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) { if (sphereModel) {
@@ -144,7 +144,7 @@ void KRAmbientZone::render(RenderInfo& ri)
info.modelFormat = sphereModel->getModelFormat(); info.modelFormat = sphereModel->getModelFormat();
info.vertexAttributes = sphereModel->getVertexAttributes(); info.vertexAttributes = sphereModel->getVertexAttributes();
KRPipeline *pPipeline = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pPipeline = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pPipeline->bind(ri.commandBuffer, *ri.camera, ri.viewport, sphereModelMatrix, &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pPipeline->bind(ri.commandBuffer, *ri.camera, ri.viewport, sphereModelMatrix, &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);
sphereModel->renderNoMaterials(ri.commandBuffer, ri.renderPass, getName(), "visualize_overlay", 1.0f); sphereModel->renderNoMaterials(ri.commandBuffer, ri.renderPass, getName(), "visualize_overlay", 1.0f);
@@ -163,22 +163,23 @@ void KRAmbientZone::setGradientDistance(float gradient_distance)
m_gradient_distance = gradient_distance; m_gradient_distance = gradient_distance;
} }
AABB KRAmbientZone::getBounds() { AABB KRAmbientZone::getBounds()
{
// Ambient zones always have a -1, -1, -1 to 1, 1, 1 bounding box // Ambient zones always have a -1, -1, -1 to 1, 1, 1 bounding box
return AABB::Create(-Vector3::One(), Vector3::One(), getModelMatrix()); return AABB::Create(-Vector3::One(), Vector3::One(), getModelMatrix());
} }
float KRAmbientZone::getContainment(const Vector3 &pos) float KRAmbientZone::getContainment(const Vector3& pos)
{ {
AABB bounds = getBounds(); AABB bounds = getBounds();
if(bounds.contains(pos)) { if (bounds.contains(pos)) {
Vector3 size = bounds.size(); Vector3 size = bounds.size();
Vector3 diff = pos - bounds.center(); Vector3 diff = pos - bounds.center();
diff = diff * 2.0f; diff = diff * 2.0f;
diff = Vector3::Create(diff.x / size.x, diff.y / size.y, diff.z / size.z); diff = Vector3::Create(diff.x / size.x, diff.y / size.y, diff.z / size.z);
float d = diff.magnitude(); float d = diff.magnitude();
if(m_gradient_distance <= 0.0f) { if (m_gradient_distance <= 0.0f) {
// Avoid division by zero // Avoid division by zero
d = d > 1.0f ? 0.0f : 1.0f; d = d > 1.0f ? 0.0f : 1.0f;
} else { } else {

15
kraken/KRAmbientZone.h
View File

@@ -35,33 +35,34 @@
#include "KRNode.h" #include "KRNode.h"
#include "KRTexture.h" #include "KRTexture.h"
class KRAmbientZone : public KRNode { class KRAmbientZone : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRAmbientZone(KRScene &scene, std::string name); KRAmbientZone(KRScene& scene, std::string name);
virtual ~KRAmbientZone(); virtual ~KRAmbientZone();
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
void render(RenderInfo& ri); void render(RenderInfo& ri);
std::string getZone(); std::string getZone();
void setZone(const std::string &zone); void setZone(const std::string& zone);
float getGradientDistance(); float getGradientDistance();
void setGradientDistance(float gradient_distance); void setGradientDistance(float gradient_distance);
std::string getAmbient(); std::string getAmbient();
void setAmbient(const std::string &ambient); void setAmbient(const std::string& ambient);
float getAmbientGain(); float getAmbientGain();
void setAmbientGain(float ambient_gain); void setAmbientGain(float ambient_gain);
virtual AABB getBounds(); virtual AABB getBounds();
float getContainment(const Vector3 &pos); float getContainment(const Vector3& pos);
private: private:
std::string m_zone; std::string m_zone;

134
kraken/KRAnimation.cpp
View File

@@ -35,7 +35,7 @@
#include "KRAnimationCurve.h" #include "KRAnimationCurve.h"
#include "KREngine-common.h" #include "KREngine-common.h"
KRAnimation::KRAnimation(KRContext &context, std::string name) : KRResource(context, name) KRAnimation::KRAnimation(KRContext& context, std::string name) : KRResource(context, name)
{ {
m_auto_play = false; m_auto_play = false;
m_loop = false; m_loop = false;
@@ -46,122 +46,124 @@ KRAnimation::KRAnimation(KRContext &context, std::string name) : KRResource(cont
} }
KRAnimation::~KRAnimation() KRAnimation::~KRAnimation()
{ {
for(unordered_map<std::string, KRAnimationLayer *>::iterator itr = m_layers.begin(); itr != m_layers.end(); ++itr){ for (unordered_map<std::string, KRAnimationLayer*>::iterator itr = m_layers.begin(); itr != m_layers.end(); ++itr) {
delete (*itr).second; delete (*itr).second;
} }
} }
std::string KRAnimation::getExtension() { std::string KRAnimation::getExtension()
{
return "kranimation"; return "kranimation";
} }
void KRAnimation::addLayer(KRAnimationLayer *layer) void KRAnimation::addLayer(KRAnimationLayer* layer)
{ {
m_layers[layer->getName()] = layer; m_layers[layer->getName()] = layer;
} }
bool KRAnimation::save(KRDataBlock &data) { bool KRAnimation::save(KRDataBlock& data)
{
tinyxml2::XMLDocument doc; tinyxml2::XMLDocument doc;
tinyxml2::XMLElement *animation_node = doc.NewElement( "animation" ); tinyxml2::XMLElement* animation_node = doc.NewElement("animation");
doc.InsertEndChild(animation_node); doc.InsertEndChild(animation_node);
animation_node->SetAttribute("loop", m_loop ? "true" : "false"); animation_node->SetAttribute("loop", m_loop ? "true" : "false");
animation_node->SetAttribute("auto_play", m_auto_play ? "true" : "false"); animation_node->SetAttribute("auto_play", m_auto_play ? "true" : "false");
animation_node->SetAttribute("duration", m_duration); animation_node->SetAttribute("duration", m_duration);
animation_node->SetAttribute("start_time", m_start_time); animation_node->SetAttribute("start_time", m_start_time);
for(unordered_map<std::string, KRAnimationLayer *>::iterator itr = m_layers.begin(); itr != m_layers.end(); ++itr){ for (unordered_map<std::string, KRAnimationLayer*>::iterator itr = m_layers.begin(); itr != m_layers.end(); ++itr) {
(*itr).second->saveXML(animation_node); (*itr).second->saveXML(animation_node);
} }
tinyxml2::XMLPrinter p; tinyxml2::XMLPrinter p;
doc.Print(&p); doc.Print(&p);
data.append((void *)p.CStr(), strlen(p.CStr())+1); data.append((void*)p.CStr(), strlen(p.CStr()) + 1);
return true; return true;
} }
KRAnimation *KRAnimation::Load(KRContext &context, const std::string &name, KRDataBlock *data) KRAnimation* KRAnimation::Load(KRContext& context, const std::string& name, KRDataBlock* data)
{ {
std::string xml_string = data->getString(); std::string xml_string = data->getString();
tinyxml2::XMLDocument doc; tinyxml2::XMLDocument doc;
doc.Parse(xml_string.c_str()); doc.Parse(xml_string.c_str());
KRAnimation *new_animation = new KRAnimation(context, name); KRAnimation* new_animation = new KRAnimation(context, name);
tinyxml2::XMLElement *animation_node = doc.RootElement(); tinyxml2::XMLElement* animation_node = doc.RootElement();
if(animation_node->QueryFloatAttribute("duration", &new_animation->m_duration) != tinyxml2::XML_SUCCESS) { if (animation_node->QueryFloatAttribute("duration", &new_animation->m_duration) != tinyxml2::XML_SUCCESS) {
new_animation->m_duration = 0.0f; // Default value new_animation->m_duration = 0.0f; // Default value
} }
if(animation_node->QueryFloatAttribute("start_time", &new_animation->m_start_time) != tinyxml2::XML_SUCCESS) { if (animation_node->QueryFloatAttribute("start_time", &new_animation->m_start_time) != tinyxml2::XML_SUCCESS) {
new_animation->m_start_time = 0.0f; // Default value new_animation->m_start_time = 0.0f; // Default value
} }
if(animation_node->QueryBoolAttribute("loop", &new_animation->m_loop) != tinyxml2::XML_SUCCESS) { if (animation_node->QueryBoolAttribute("loop", &new_animation->m_loop) != tinyxml2::XML_SUCCESS) {
new_animation->m_loop = false; // Default value new_animation->m_loop = false; // Default value
} }
if(animation_node->QueryBoolAttribute("auto_play", &new_animation->m_auto_play) != tinyxml2::XML_SUCCESS) { if (animation_node->QueryBoolAttribute("auto_play", &new_animation->m_auto_play) != tinyxml2::XML_SUCCESS) {
new_animation->m_auto_play = false; // Default value new_animation->m_auto_play = false; // Default value
} }
for(tinyxml2::XMLElement *child_element=animation_node->FirstChildElement(); child_element != NULL; child_element = child_element->NextSiblingElement()) { for (tinyxml2::XMLElement* child_element = animation_node->FirstChildElement(); child_element != NULL; child_element = child_element->NextSiblingElement()) {
if(strcmp(child_element->Name(), "layer") == 0) { if (strcmp(child_element->Name(), "layer") == 0) {
KRAnimationLayer *new_layer = new KRAnimationLayer(context); KRAnimationLayer* new_layer = new KRAnimationLayer(context);
new_layer->loadXML(child_element); new_layer->loadXML(child_element);
new_animation->m_layers[new_layer->getName()] = new_layer; new_animation->m_layers[new_layer->getName()] = new_layer;
} }
} }
if(new_animation->m_auto_play) { if (new_animation->m_auto_play) {
new_animation->m_playing = true; new_animation->m_playing = true;
} }
// KRNode *n = KRNode::LoadXML(*new_scene, scene_element->FirstChildElement()); // KRNode *n = KRNode::LoadXML(*new_scene, scene_element->FirstChildElement());
delete data; delete data;
return new_animation; return new_animation;
} }
unordered_map<std::string, KRAnimationLayer *> &KRAnimation::getLayers() unordered_map<std::string, KRAnimationLayer*>& KRAnimation::getLayers()
{ {
return m_layers; return m_layers;
} }
KRAnimationLayer *KRAnimation::getLayer(const char *szName) KRAnimationLayer* KRAnimation::getLayer(const char* szName)
{ {
return m_layers[szName]; return m_layers[szName];
} }
void KRAnimation::update(float deltaTime) void KRAnimation::update(float deltaTime)
{ {
if(m_playing) { if (m_playing) {
m_local_time += deltaTime; m_local_time += deltaTime;
} }
if(m_loop) { if (m_loop) {
while(m_local_time > m_duration) { while (m_local_time > m_duration) {
m_local_time -= m_duration; m_local_time -= m_duration;
} }
} else if(m_local_time > m_duration) { } else if (m_local_time > m_duration) {
m_local_time = m_duration; m_local_time = m_duration;
m_playing = false; m_playing = false;
getContext().getAnimationManager()->updateActiveAnimations(this); getContext().getAnimationManager()->updateActiveAnimations(this);
} }
for(unordered_map<std::string, KRAnimationLayer *>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) { for (unordered_map<std::string, KRAnimationLayer*>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) {
KRAnimationLayer *layer = (*layer_itr).second; KRAnimationLayer* layer = (*layer_itr).second;
for(std::vector<KRAnimationAttribute *>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) { for (std::vector<KRAnimationAttribute*>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) {
KRAnimationAttribute *attribute = *attribute_itr; KRAnimationAttribute* attribute = *attribute_itr;
// TODO - Currently only a single layer supported per animation -- need to either implement combining of multiple layers or ask the FBX sdk to bake all layers into one // TODO - Currently only a single layer supported per animation -- need to either implement combining of multiple layers or ask the FBX sdk to bake all layers into one
KRAnimationCurve *curve = attribute->getCurve(); KRAnimationCurve* curve = attribute->getCurve();
KRNode *target = attribute->getTarget(); KRNode* target = attribute->getTarget();
KRNode::node_attribute_type attribute_type = attribute->getTargetAttribute(); KRNode::node_attribute_type attribute_type = attribute->getTargetAttribute();
if(curve != NULL && target != NULL) { if (curve != NULL && target != NULL) {
target->SetAttribute(attribute_type, curve->getValue(m_local_time + m_start_time)); target->SetAttribute(attribute_type, curve->getValue(m_local_time + m_start_time));
} }
} }
@@ -236,24 +238,24 @@ void KRAnimation::setLooping(bool looping)
KRAnimation *KRAnimation::split(const std::string &name, float start_time, float duration, bool strip_unchanging_attributes, bool clone_curves) KRAnimation* KRAnimation::split(const std::string& name, float start_time, float duration, bool strip_unchanging_attributes, bool clone_curves)
{ {
KRAnimation *new_animation = new KRAnimation(getContext(), name); KRAnimation* new_animation = new KRAnimation(getContext(), name);
new_animation->setStartTime(start_time); new_animation->setStartTime(start_time);
new_animation->setDuration(duration); new_animation->setDuration(duration);
new_animation->m_loop = m_loop; new_animation->m_loop = m_loop;
new_animation->m_auto_play = m_auto_play; new_animation->m_auto_play = m_auto_play;
int new_curve_count = 0; int new_curve_count = 0;
for(unordered_map<std::string, KRAnimationLayer *>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) { for (unordered_map<std::string, KRAnimationLayer*>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) {
KRAnimationLayer *layer = (*layer_itr).second; KRAnimationLayer* layer = (*layer_itr).second;
KRAnimationLayer *new_layer = new KRAnimationLayer(getContext()); KRAnimationLayer* new_layer = new KRAnimationLayer(getContext());
new_layer->setName(layer->getName()); new_layer->setName(layer->getName());
new_layer->setRotationAccumulationMode(layer->getRotationAccumulationMode()); new_layer->setRotationAccumulationMode(layer->getRotationAccumulationMode());
new_layer->setScaleAccumulationMode(layer->getScaleAccumulationMode()); new_layer->setScaleAccumulationMode(layer->getScaleAccumulationMode());
new_layer->setWeight(layer->getWeight()); new_layer->setWeight(layer->getWeight());
new_animation->m_layers[new_layer->getName()] = new_layer; new_animation->m_layers[new_layer->getName()] = new_layer;
for(std::vector<KRAnimationAttribute *>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) { for (std::vector<KRAnimationAttribute*>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) {
KRAnimationAttribute *attribute = *attribute_itr; KRAnimationAttribute* attribute = *attribute_itr;
// Updated Dec 9, 2013 by Peter to change the way that attributes are stripped. // Updated Dec 9, 2013 by Peter to change the way that attributes are stripped.
// //
@@ -268,27 +270,27 @@ KRAnimation *KRAnimation::split(const std::string &name, float start_time, float
if (targetAttribute > 0) { // we have a valid target that fits within a group of 3 if (targetAttribute > 0) { // we have a valid target that fits within a group of 3
targetAttribute--; // this is now group relative 0,1,2 is the first group .. 3,4,5 is the second group, etc. targetAttribute--; // this is now group relative 0,1,2 is the first group .. 3,4,5 is the second group, etc.
KRAnimationCurve *curve = attribute->getCurve(); // this is the curve we are currently handling KRAnimationCurve* curve = attribute->getCurve(); // this is the curve we are currently handling
int placeInGroup = targetAttribute % 3; // this will be 0, 1 or 2 int placeInGroup = targetAttribute % 3; // this will be 0, 1 or 2
static long placeLookup[] = { 1, 2, -1, 1, -2, -1 }; static long placeLookup[] = { 1, 2, -1, 1, -2, -1 };
KRAnimationAttribute *attribute2 = *(attribute_itr + placeLookup[placeInGroup*2]); KRAnimationAttribute* attribute2 = *(attribute_itr + placeLookup[placeInGroup * 2]);
KRAnimationAttribute *attribute3 = *(attribute_itr + placeLookup[placeInGroup*2+1]); KRAnimationAttribute* attribute3 = *(attribute_itr + placeLookup[placeInGroup * 2 + 1]);
KRAnimationCurve *curve2 = attribute2->getCurve(); KRAnimationCurve* curve2 = attribute2->getCurve();
KRAnimationCurve *curve3 = attribute3->getCurve(); KRAnimationCurve* curve3 = attribute3->getCurve();
bool include_attribute = true; bool include_attribute = true;
if(strip_unchanging_attributes) { if (strip_unchanging_attributes) {
include_attribute = curve->valueChanges(start_time, duration) | include_attribute = curve->valueChanges(start_time, duration) |
curve2->valueChanges(start_time, duration) | curve2->valueChanges(start_time, duration) |
curve3->valueChanges(start_time, duration); curve3->valueChanges(start_time, duration);
} }
if(include_attribute) { if (include_attribute) {
KRAnimationAttribute *new_attribute = new KRAnimationAttribute(getContext()); KRAnimationAttribute* new_attribute = new KRAnimationAttribute(getContext());
KRAnimationCurve *new_curve = curve; KRAnimationCurve* new_curve = curve;
if(clone_curves) { if (clone_curves) {
std::string new_curve_name = name + "_curve" + std::to_string(++new_curve_count); std::string new_curve_name = name + "_curve" + std::to_string(++new_curve_count);
new_curve = curve->split(new_curve_name, start_time, duration); new_curve = curve->split(new_curve_name, start_time, duration);
} }
@@ -308,10 +310,10 @@ KRAnimation *KRAnimation::split(const std::string &name, float start_time, float
void KRAnimation::deleteCurves() void KRAnimation::deleteCurves()
{ {
for(unordered_map<std::string, KRAnimationLayer *>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) { for (unordered_map<std::string, KRAnimationLayer*>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) {
KRAnimationLayer *layer = (*layer_itr).second; KRAnimationLayer* layer = (*layer_itr).second;
for(std::vector<KRAnimationAttribute *>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) { for (std::vector<KRAnimationAttribute*>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) {
KRAnimationAttribute *attribute = *attribute_itr; KRAnimationAttribute* attribute = *attribute_itr;
attribute->deleteCurve(); attribute->deleteCurve();
} }
} }
@@ -319,12 +321,12 @@ void KRAnimation::deleteCurves()
void KRAnimation::_lockData() void KRAnimation::_lockData()
{ {
for(unordered_map<std::string, KRAnimationLayer *>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) { for (unordered_map<std::string, KRAnimationLayer*>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) {
KRAnimationLayer *layer = (*layer_itr).second; KRAnimationLayer* layer = (*layer_itr).second;
for(std::vector<KRAnimationAttribute *>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) { for (std::vector<KRAnimationAttribute*>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) {
KRAnimationAttribute *attribute = *attribute_itr; KRAnimationAttribute* attribute = *attribute_itr;
KRAnimationCurve *curve = attribute->getCurve(); KRAnimationCurve* curve = attribute->getCurve();
if(curve) { if (curve) {
curve->_lockData(); curve->_lockData();
} }
} }
@@ -333,12 +335,12 @@ void KRAnimation::_lockData()
void KRAnimation::_unlockData() void KRAnimation::_unlockData()
{ {
for(unordered_map<std::string, KRAnimationLayer *>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) { for (unordered_map<std::string, KRAnimationLayer*>::iterator layer_itr = m_layers.begin(); layer_itr != m_layers.end(); layer_itr++) {
KRAnimationLayer *layer = (*layer_itr).second; KRAnimationLayer* layer = (*layer_itr).second;
for(std::vector<KRAnimationAttribute *>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) { for (std::vector<KRAnimationAttribute*>::iterator attribute_itr = layer->getAttributes().begin(); attribute_itr != layer->getAttributes().end(); attribute_itr++) {
KRAnimationAttribute *attribute = *attribute_itr; KRAnimationAttribute* attribute = *attribute_itr;
KRAnimationCurve *curve = attribute->getCurve(); KRAnimationCurve* curve = attribute->getCurve();
if(curve) { if (curve) {
curve->_unlockData(); curve->_unlockData();
} }
} }

19
kraken/KRAnimation.h
View File

@@ -38,20 +38,21 @@
#include "KRAnimationLayer.h" #include "KRAnimationLayer.h"
class KRAnimation : public KRResource { class KRAnimation : public KRResource
{
public: public:
KRAnimation(KRContext &context, std::string name); KRAnimation(KRContext& context, std::string name);
virtual ~KRAnimation(); virtual ~KRAnimation();
virtual std::string getExtension(); virtual std::string getExtension();
virtual bool save(KRDataBlock &data); virtual bool save(KRDataBlock& data);
static KRAnimation *Load(KRContext &context, const std::string &name, KRDataBlock *data); static KRAnimation* Load(KRContext& context, const std::string& name, KRDataBlock* data);
void addLayer(KRAnimationLayer *layer); void addLayer(KRAnimationLayer* layer);
unordered_map<std::string, KRAnimationLayer *> &getLayers(); unordered_map<std::string, KRAnimationLayer*>& getLayers();
KRAnimationLayer *getLayer(const char *szName); KRAnimationLayer* getLayer(const char* szName);
bool getAutoPlay() const; bool getAutoPlay() const;
void setAutoPlay(bool auto_play); void setAutoPlay(bool auto_play);
bool getLooping() const; bool getLooping() const;
@@ -67,14 +68,14 @@ public:
void setStartTime(float start_time); void setStartTime(float start_time);
bool isPlaying(); bool isPlaying();
KRAnimation *split(const std::string &name, float start_time, float duration, bool strip_unchanging_attributes = true, bool clone_curves = true); KRAnimation* split(const std::string& name, float start_time, float duration, bool strip_unchanging_attributes = true, bool clone_curves = true);
void deleteCurves(); void deleteCurves();
void _lockData(); void _lockData();
void _unlockData(); void _unlockData();
private: private:
unordered_map<std::string, KRAnimationLayer *> m_layers; unordered_map<std::string, KRAnimationLayer*> m_layers;
bool m_auto_play; bool m_auto_play;
bool m_loop; bool m_loop;
bool m_playing; bool m_playing;

90
kraken/KRAnimationAttribute.cpp
View File

@@ -35,7 +35,7 @@
#include "KRAnimationCurveManager.h" #include "KRAnimationCurveManager.h"
KRAnimationAttribute::KRAnimationAttribute(KRContext &context) : KRContextObject(context) KRAnimationAttribute::KRAnimationAttribute(KRContext& context) : KRContextObject(context)
{ {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE;
m_target = NULL; m_target = NULL;
@@ -47,15 +47,15 @@ KRAnimationAttribute::~KRAnimationAttribute()
} }
tinyxml2::XMLElement *KRAnimationAttribute::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRAnimationAttribute::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLDocument *doc = parent->GetDocument(); tinyxml2::XMLDocument* doc = parent->GetDocument();
tinyxml2::XMLElement *e = doc->NewElement("attribute"); tinyxml2::XMLElement* e = doc->NewElement("attribute");
parent->InsertEndChild(e); parent->InsertEndChild(e);
e->SetAttribute("curve", m_curve_name.c_str()); e->SetAttribute("curve", m_curve_name.c_str());
e->SetAttribute("target", m_target_name.c_str()); e->SetAttribute("target", m_target_name.c_str());
const char *szAttribute = "none"; const char* szAttribute = "none";
switch(m_node_attribute) { switch (m_node_attribute) {
case KRNode::KRENGINE_NODE_ATTRIBUTE_NONE: case KRNode::KRENGINE_NODE_ATTRIBUTE_NONE:
szAttribute = "none"; szAttribute = "none";
break; break;
@@ -149,7 +149,7 @@ tinyxml2::XMLElement *KRAnimationAttribute::saveXML( tinyxml2::XMLNode *parent)
return e; return e;
} }
void KRAnimationAttribute::loadXML(tinyxml2::XMLElement *e) void KRAnimationAttribute::loadXML(tinyxml2::XMLElement* e)
{ {
m_target = NULL; m_target = NULL;
m_curve = NULL; m_curve = NULL;
@@ -159,62 +159,62 @@ void KRAnimationAttribute::loadXML(tinyxml2::XMLElement *e)
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE;
const char *szAttribute = e->Attribute("attribute"); const char* szAttribute = e->Attribute("attribute");
if(strcmp(szAttribute, "none") == 0) { if (strcmp(szAttribute, "none") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE;
} else if(strcmp(szAttribute, "translate_x") == 0) { } else if (strcmp(szAttribute, "translate_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_X; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_X;
} else if(strcmp(szAttribute, "translate_y") == 0) { } else if (strcmp(szAttribute, "translate_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Y; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Y;
} else if(strcmp(szAttribute, "translate_z") == 0) { } else if (strcmp(szAttribute, "translate_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Z; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Z;
} else if(strcmp(szAttribute, "rotate_x") == 0) { } else if (strcmp(szAttribute, "rotate_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_X; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_X;
} else if(strcmp(szAttribute, "rotate_y") == 0) { } else if (strcmp(szAttribute, "rotate_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_Y; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_Y;
} else if(strcmp(szAttribute, "rotate_z") == 0) { } else if (strcmp(szAttribute, "rotate_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_Z; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_Z;
} else if(strcmp(szAttribute, "scale_x") == 0) { } else if (strcmp(szAttribute, "scale_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_X; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_X;
} else if(strcmp(szAttribute, "scale_y") == 0) { } else if (strcmp(szAttribute, "scale_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_Y; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_Y;
} else if(strcmp(szAttribute, "scale_z") == 0) { } else if (strcmp(szAttribute, "scale_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_Z; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_Z;
} else if(strcmp(szAttribute, "pre_rotate_x") == 0) { } else if (strcmp(szAttribute, "pre_rotate_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_X; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_X;
} else if(strcmp(szAttribute, "pre_rotate_y") == 0) { } else if (strcmp(szAttribute, "pre_rotate_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_Y; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_Y;
} else if(strcmp(szAttribute, "pre_rotate_z") == 0) { } else if (strcmp(szAttribute, "pre_rotate_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_Z; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_PRE_ROTATION_Z;
} else if(strcmp(szAttribute, "post_rotate_x") == 0) { } else if (strcmp(szAttribute, "post_rotate_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_X; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_X;
} else if(strcmp(szAttribute, "post_rotate_y") == 0) { } else if (strcmp(szAttribute, "post_rotate_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_Y; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_Y;
} else if(strcmp(szAttribute, "post_rotate_z") == 0) { } else if (strcmp(szAttribute, "post_rotate_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_Z; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_POST_ROTATION_Z;
} else if(strcmp(szAttribute, "rotate_pivot_x") == 0) { } else if (strcmp(szAttribute, "rotate_pivot_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_X; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_X;
} else if(strcmp(szAttribute, "rotate_pivot_y") == 0) { } else if (strcmp(szAttribute, "rotate_pivot_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_Y; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_Y;
} else if(strcmp(szAttribute, "rotate_pivot_z") == 0) { } else if (strcmp(szAttribute, "rotate_pivot_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_Z; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATION_PIVOT_Z;
} else if(strcmp(szAttribute, "scale_pivot_x") == 0) { } else if (strcmp(szAttribute, "scale_pivot_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_X; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_X;
} else if(strcmp(szAttribute, "scale_pivot_y") == 0) { } else if (strcmp(szAttribute, "scale_pivot_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_Y; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_Y;
} else if(strcmp(szAttribute, "scale_pivot_z") == 0) { } else if (strcmp(szAttribute, "scale_pivot_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_Z; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_SCALE_PIVOT_Z;
} else if(strcmp(szAttribute, "rotate_offset_x") == 0) { } else if (strcmp(szAttribute, "rotate_offset_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_X; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_X;
} else if(strcmp(szAttribute, "rotate_offset_y") == 0) { } else if (strcmp(szAttribute, "rotate_offset_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_Y; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_Y;
} else if(strcmp(szAttribute, "rotate_offset_z") == 0) { } else if (strcmp(szAttribute, "rotate_offset_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_Z; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_ROTATE_OFFSET_Z;
} else if(strcmp(szAttribute, "scale_offset_x") == 0) { } else if (strcmp(szAttribute, "scale_offset_x") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_X; m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_X;
} else if(strcmp(szAttribute, "scale_offset_y") == 0) { } else if (strcmp(szAttribute, "scale_offset_y") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_Y; m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_Y;
} else if(strcmp(szAttribute, "scale_offset_z") == 0) { } else if (strcmp(szAttribute, "scale_offset_z") == 0) {
m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_Z; m_node_attribute = KRNode::KRENGINE_NODE_SCALE_OFFSET_Z;
} else { } else {
m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE; m_node_attribute = KRNode::KRENGINE_NODE_ATTRIBUTE_NONE;
@@ -236,7 +236,7 @@ std::string KRAnimationAttribute::getTargetName() const
return m_target_name; return m_target_name;
} }
void KRAnimationAttribute::setTargetName(const std::string &target_name) void KRAnimationAttribute::setTargetName(const std::string& target_name)
{ {
m_target_name = target_name; m_target_name = target_name;
m_target = NULL; m_target = NULL;
@@ -247,26 +247,26 @@ std::string KRAnimationAttribute::getCurveName() const
return m_curve_name; return m_curve_name;
} }
void KRAnimationAttribute::setCurveName(const std::string &curve_name) void KRAnimationAttribute::setCurveName(const std::string& curve_name)
{ {
m_curve_name = curve_name; m_curve_name = curve_name;
m_curve = NULL; m_curve = NULL;
} }
KRNode *KRAnimationAttribute::getTarget() KRNode* KRAnimationAttribute::getTarget()
{ {
if(m_target == NULL) { if (m_target == NULL) {
m_target = getContext().getSceneManager()->getFirstScene()->getRootNode()->find<KRNode>(m_target_name); // FINDME, HACK! - This won't work with multiple scenes in a context; we should move the animations out of KRAnimationManager and attach them to the parent nodes of the animated KRNode's m_target = getContext().getSceneManager()->getFirstScene()->getRootNode()->find<KRNode>(m_target_name); // FINDME, HACK! - This won't work with multiple scenes in a context; we should move the animations out of KRAnimationManager and attach them to the parent nodes of the animated KRNode's
} }
if(m_target == NULL) { if (m_target == NULL) {
KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Kraken - Animation attribute could not find object: %s", m_target_name.c_str()); KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Kraken - Animation attribute could not find object: %s", m_target_name.c_str());
} }
return m_target; return m_target;
} }
KRAnimationCurve *KRAnimationAttribute::getCurve() KRAnimationCurve* KRAnimationAttribute::getCurve()
{ {
if(m_curve == NULL) { if (m_curve == NULL) {
m_curve = getContext().getAnimationCurveManager()->getAnimationCurve(m_curve_name.c_str()); m_curve = getContext().getAnimationCurveManager()->getAnimationCurve(m_curve_name.c_str());
} }
return m_curve; return m_curve;
@@ -274,8 +274,8 @@ KRAnimationCurve *KRAnimationAttribute::getCurve()
void KRAnimationAttribute::deleteCurve() void KRAnimationAttribute::deleteCurve()
{ {
KRAnimationCurve *curve = getCurve(); KRAnimationCurve* curve = getCurve();
if(curve) { if (curve) {
getContext().getAnimationCurveManager()->deleteAnimationCurve(curve); getContext().getAnimationCurveManager()->deleteAnimationCurve(curve);
m_curve = NULL; m_curve = NULL;
} }

21
kraken/KRAnimationAttribute.h
View File

@@ -36,25 +36,26 @@
#include "KRNode.h" #include "KRNode.h"
#include "KRAnimationCurve.h" #include "KRAnimationCurve.h"
class KRAnimationAttribute : public KRContextObject { class KRAnimationAttribute : public KRContextObject
{
public: public:
KRAnimationAttribute(KRContext &context); KRAnimationAttribute(KRContext& context);
~KRAnimationAttribute(); ~KRAnimationAttribute();
tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
void loadXML(tinyxml2::XMLElement *e); void loadXML(tinyxml2::XMLElement* e);
std::string getCurveName() const; std::string getCurveName() const;
void setCurveName(const std::string &curve_name); void setCurveName(const std::string& curve_name);
std::string getTargetName() const; std::string getTargetName() const;
void setTargetName(const std::string &target_name); void setTargetName(const std::string& target_name);
KRNode::node_attribute_type getTargetAttribute() const; KRNode::node_attribute_type getTargetAttribute() const;
void setTargetAttribute(KRNode::node_attribute_type target_attribute); void setTargetAttribute(KRNode::node_attribute_type target_attribute);
KRNode *getTarget(); KRNode* getTarget();
KRAnimationCurve *getCurve(); KRAnimationCurve* getCurve();
void deleteCurve(); void deleteCurve();
@@ -63,6 +64,6 @@ private:
std::string m_curve_name; std::string m_curve_name;
KRNode::node_attribute_type m_node_attribute; KRNode::node_attribute_type m_node_attribute;
KRNode *m_target; KRNode* m_target;
KRAnimationCurve *m_curve; KRAnimationCurve* m_curve;
}; };

65
kraken/KRAnimationCurve.cpp
View File

@@ -33,12 +33,12 @@
#include "KRAnimationCurve.h" #include "KRAnimationCurve.h"
#include "KRDataBlock.h" #include "KRDataBlock.h"
KRAnimationCurve::KRAnimationCurve(KRContext &context, const std::string &name) : KRResource(context, name) KRAnimationCurve::KRAnimationCurve(KRContext& context, const std::string& name) : KRResource(context, name)
{ {
m_pData = new KRDataBlock(); m_pData = new KRDataBlock();
m_pData->expand(sizeof(animation_curve_header)); m_pData->expand(sizeof(animation_curve_header));
m_pData->lock(); m_pData->lock();
animation_curve_header *header = (animation_curve_header *)m_pData->getStart(); animation_curve_header* header = (animation_curve_header*)m_pData->getStart();
strcpy(header->szTag, "KRCURVE1.0 "); strcpy(header->szTag, "KRCURVE1.0 ");
header->frame_rate = 30.0f; header->frame_rate = 30.0f;
header->frame_start = 0; header->frame_start = 0;
@@ -51,7 +51,7 @@ KRAnimationCurve::~KRAnimationCurve()
m_pData->unload(); m_pData->unload();
delete m_pData; delete m_pData;
} }
bool KRAnimationCurve::load(KRDataBlock *data) bool KRAnimationCurve::load(KRDataBlock* data)
{ {
m_pData->unload(); m_pData->unload();
delete m_pData; delete m_pData;
@@ -59,23 +59,26 @@ bool KRAnimationCurve::load(KRDataBlock *data)
return true; return true;
} }
std::string KRAnimationCurve::getExtension() { std::string KRAnimationCurve::getExtension()
{
return "kranimationcurve"; return "kranimationcurve";
} }
bool KRAnimationCurve::save(const std::string& path) { bool KRAnimationCurve::save(const std::string& path)
{
return m_pData->save(path); return m_pData->save(path);
} }
bool KRAnimationCurve::save(KRDataBlock &data) { bool KRAnimationCurve::save(KRDataBlock& data)
{
data.append(*m_pData); data.append(*m_pData);
return true; return true;
} }
KRAnimationCurve *KRAnimationCurve::Load(KRContext &context, const std::string &name, KRDataBlock *data) KRAnimationCurve* KRAnimationCurve::Load(KRContext& context, const std::string& name, KRDataBlock* data)
{ {
KRAnimationCurve *new_animation_curve = new KRAnimationCurve(context, name); KRAnimationCurve* new_animation_curve = new KRAnimationCurve(context, name);
if(new_animation_curve->load(data)) { if (new_animation_curve->load(data)) {
return new_animation_curve; return new_animation_curve;
} else { } else {
delete new_animation_curve; delete new_animation_curve;
@@ -87,7 +90,7 @@ KRAnimationCurve *KRAnimationCurve::Load(KRContext &context, const std::string &
int KRAnimationCurve::getFrameCount() int KRAnimationCurve::getFrameCount()
{ {
m_pData->lock(); m_pData->lock();
int frame_count = ((animation_curve_header *)m_pData->getStart())->frame_count; int frame_count = ((animation_curve_header*)m_pData->getStart())->frame_count;
m_pData->unlock(); m_pData->unlock();
return frame_count; return frame_count;
@@ -97,17 +100,17 @@ void KRAnimationCurve::setFrameCount(int frame_count)
{ {
m_pData->lock(); m_pData->lock();
int prev_frame_count = getFrameCount(); int prev_frame_count = getFrameCount();
if(frame_count != prev_frame_count) { if (frame_count != prev_frame_count) {
float fill_value = 0.0f; float fill_value = 0.0f;
if(prev_frame_count > 0) { if (prev_frame_count > 0) {
fill_value = getValue(prev_frame_count - 1); fill_value = getValue(prev_frame_count - 1);
} }
m_pData->expand(sizeof(animation_curve_header) + sizeof(float) * frame_count - m_pData->getSize()); m_pData->expand(sizeof(animation_curve_header) + sizeof(float) * frame_count - m_pData->getSize());
float *frame_data = (float *)((char *)m_pData->getStart() + sizeof(animation_curve_header)); float* frame_data = (float*)((char*)m_pData->getStart() + sizeof(animation_curve_header));
for(int frame_number=prev_frame_count; frame_number < frame_count; frame_number++) { for (int frame_number = prev_frame_count; frame_number < frame_count; frame_number++) {
frame_data[frame_number] = fill_value; frame_data[frame_number] = fill_value;
} }
((animation_curve_header *)m_pData->getStart())->frame_count = frame_count; ((animation_curve_header*)m_pData->getStart())->frame_count = frame_count;
} }
m_pData->unlock(); m_pData->unlock();
} }
@@ -115,7 +118,7 @@ void KRAnimationCurve::setFrameCount(int frame_count)
float KRAnimationCurve::getFrameRate() float KRAnimationCurve::getFrameRate()
{ {
m_pData->lock(); m_pData->lock();
float frame_rate =((animation_curve_header *)m_pData->getStart())->frame_rate; float frame_rate = ((animation_curve_header*)m_pData->getStart())->frame_rate;
m_pData->unlock(); m_pData->unlock();
return frame_rate; return frame_rate;
} }
@@ -123,14 +126,14 @@ float KRAnimationCurve::getFrameRate()
void KRAnimationCurve::setFrameRate(float frame_rate) void KRAnimationCurve::setFrameRate(float frame_rate)
{ {
m_pData->lock(); m_pData->lock();
((animation_curve_header *)m_pData->getStart())->frame_rate = frame_rate; ((animation_curve_header*)m_pData->getStart())->frame_rate = frame_rate;
m_pData->unlock(); m_pData->unlock();
} }
int KRAnimationCurve::getFrameStart() int KRAnimationCurve::getFrameStart()
{ {
m_pData->lock(); m_pData->lock();
int frame_start = ((animation_curve_header *)m_pData->getStart())->frame_start; int frame_start = ((animation_curve_header*)m_pData->getStart())->frame_start;
m_pData->unlock(); m_pData->unlock();
return frame_start; return frame_start;
} }
@@ -138,7 +141,7 @@ int KRAnimationCurve::getFrameStart()
void KRAnimationCurve::setFrameStart(int frame_number) void KRAnimationCurve::setFrameStart(int frame_number)
{ {
m_pData->lock(); m_pData->lock();
((animation_curve_header *)m_pData->getStart())->frame_start = frame_number; ((animation_curve_header*)m_pData->getStart())->frame_start = frame_number;
m_pData->unlock(); m_pData->unlock();
} }
@@ -147,12 +150,12 @@ float KRAnimationCurve::getValue(int frame_number)
m_pData->lock(); m_pData->lock();
//printf("frame_number: %i\n", frame_number); //printf("frame_number: %i\n", frame_number);
int clamped_frame = frame_number - getFrameStart(); int clamped_frame = frame_number - getFrameStart();
if(clamped_frame < 0) { if (clamped_frame < 0) {
clamped_frame = 0; clamped_frame = 0;
} else if(clamped_frame >= getFrameCount()) { } else if (clamped_frame >= getFrameCount()) {
clamped_frame = getFrameCount()-1; clamped_frame = getFrameCount() - 1;
} }
float *frame_data = (float *)((char *)m_pData->getStart() + sizeof(animation_curve_header)); float* frame_data = (float*)((char*)m_pData->getStart() + sizeof(animation_curve_header));
float v = frame_data[clamped_frame]; float v = frame_data[clamped_frame];
m_pData->unlock(); m_pData->unlock();
return v; return v;
@@ -162,8 +165,8 @@ void KRAnimationCurve::setValue(int frame_number, float value)
{ {
m_pData->lock(); m_pData->lock();
int clamped_frame = frame_number - getFrameStart(); int clamped_frame = frame_number - getFrameStart();
if(clamped_frame >= 0 && clamped_frame < getFrameCount()) { if (clamped_frame >= 0 && clamped_frame < getFrameCount()) {
float *frame_data = (float *)((char *)m_pData->getStart() + sizeof(animation_curve_header)); float* frame_data = (float*)((char*)m_pData->getStart() + sizeof(animation_curve_header));
frame_data[clamped_frame] = value; frame_data[clamped_frame] = value;
} }
m_pData->unlock(); m_pData->unlock();
@@ -195,8 +198,8 @@ bool KRAnimationCurve::valueChanges(int start_frame, int frame_count)
bool change_found = false; bool change_found = false;
// Range of frames is not inclusive of last frame // Range of frames is not inclusive of last frame
for(int frame_number = start_frame + 1; frame_number < start_frame + frame_count && !change_found; frame_number++) { for (int frame_number = start_frame + 1; frame_number < start_frame + frame_count && !change_found; frame_number++) {
if(getValue(frame_number) != first_value) { if (getValue(frame_number) != first_value) {
change_found = true; change_found = true;
} }
} }
@@ -205,14 +208,14 @@ bool KRAnimationCurve::valueChanges(int start_frame, int frame_count)
return change_found; return change_found;
} }
KRAnimationCurve *KRAnimationCurve::split(const std::string &name, float start_time, float duration) KRAnimationCurve* KRAnimationCurve::split(const std::string& name, float start_time, float duration)
{ {
return split(name, (int)(start_time * getFrameRate()), (int)(duration * getFrameRate())); return split(name, (int)(start_time * getFrameRate()), (int)(duration * getFrameRate()));
} }
KRAnimationCurve *KRAnimationCurve::split(const std::string &name, int start_frame, int frame_count) KRAnimationCurve* KRAnimationCurve::split(const std::string& name, int start_frame, int frame_count)
{ {
KRAnimationCurve *new_curve = new KRAnimationCurve(getContext(), name); KRAnimationCurve* new_curve = new KRAnimationCurve(getContext(), name);
new_curve->setFrameRate(getFrameRate()); new_curve->setFrameRate(getFrameRate());
new_curve->setFrameStart(start_frame); new_curve->setFrameStart(start_frame);
@@ -220,7 +223,7 @@ KRAnimationCurve *KRAnimationCurve::split(const std::string &name, int start_fra
new_curve->m_pData->lock(); new_curve->m_pData->lock();
// Range of frames is not inclusive of last frame // Range of frames is not inclusive of last frame
for(int frame_number = start_frame; frame_number < start_frame + frame_count; frame_number++) { for (int frame_number = start_frame; frame_number < start_frame + frame_count; frame_number++) {
new_curve->setValue(frame_number, getValue(frame_number)); // TODO - MEMCPY here? new_curve->setValue(frame_number, getValue(frame_number)); // TODO - MEMCPY here?
} }
new_curve->m_pData->unlock(); new_curve->m_pData->unlock();

20
kraken/KRAnimationCurve.h
View File

@@ -36,16 +36,17 @@
#include "KRDataBlock.h" #include "KRDataBlock.h"
#include "KRResource.h" #include "KRResource.h"
class KRAnimationCurve : public KRResource { class KRAnimationCurve : public KRResource
{
public: public:
KRAnimationCurve(KRContext &context, const std::string &name); KRAnimationCurve(KRContext& context, const std::string& name);
virtual ~KRAnimationCurve(); virtual ~KRAnimationCurve();
virtual std::string getExtension(); virtual std::string getExtension();
virtual bool save(const std::string& path); virtual bool save(const std::string& path);
virtual bool save(KRDataBlock &data); virtual bool save(KRDataBlock& data);
virtual bool load(KRDataBlock *data); virtual bool load(KRDataBlock* data);
float getFrameRate(); float getFrameRate();
void setFrameRate(float frame_rate); void setFrameRate(float frame_rate);
@@ -58,21 +59,22 @@ public:
void setValue(int frame_number, float value); void setValue(int frame_number, float value);
static KRAnimationCurve *Load(KRContext &context, const std::string &name, KRDataBlock *data); static KRAnimationCurve* Load(KRContext& context, const std::string& name, KRDataBlock* data);
bool valueChanges(float start_time, float duration); bool valueChanges(float start_time, float duration);
bool valueChanges(int start_frame, int frame_count); bool valueChanges(int start_frame, int frame_count);
KRAnimationCurve *split(const std::string &name, float start_time, float duration); KRAnimationCurve* split(const std::string& name, float start_time, float duration);
KRAnimationCurve *split(const std::string &name, int start_frame, int frame_count); KRAnimationCurve* split(const std::string& name, int start_frame, int frame_count);
void _lockData(); void _lockData();
void _unlockData(); void _unlockData();
private: private:
KRDataBlock *m_pData; KRDataBlock* m_pData;
typedef struct { typedef struct
{
char szTag[16]; char szTag[16];
float frame_rate; float frame_rate;
int32_t frame_start; int32_t frame_start;

29
kraken/KRAnimationCurveManager.cpp
View File

@@ -32,18 +32,20 @@
#include "KRAnimationCurveManager.h" #include "KRAnimationCurveManager.h"
#include "KRAnimationCurve.h" #include "KRAnimationCurve.h"
KRAnimationCurveManager::KRAnimationCurveManager(KRContext &context) : KRResourceManager(context) KRAnimationCurveManager::KRAnimationCurveManager(KRContext& context) : KRResourceManager(context)
{ {
} }
KRAnimationCurveManager::~KRAnimationCurveManager() { KRAnimationCurveManager::~KRAnimationCurveManager()
for(unordered_map<std::string, KRAnimationCurve *>::iterator itr = m_animationCurves.begin(); itr != m_animationCurves.end(); ++itr){ {
for (unordered_map<std::string, KRAnimationCurve*>::iterator itr = m_animationCurves.begin(); itr != m_animationCurves.end(); ++itr) {
delete (*itr).second; delete (*itr).second;
} }
} }
void KRAnimationCurveManager::deleteAnimationCurve(KRAnimationCurve *curve) { void KRAnimationCurveManager::deleteAnimationCurve(KRAnimationCurve* curve)
{
m_animationCurves.erase(curve->getName()); m_animationCurves.erase(curve->getName());
delete curve; delete curve;
} }
@@ -63,28 +65,31 @@ KRResource* KRAnimationCurveManager::getResource(const std::string& name, const
return nullptr; return nullptr;
} }
KRAnimationCurve *KRAnimationCurveManager::loadAnimationCurve(const std::string &name, KRDataBlock *data) { KRAnimationCurve* KRAnimationCurveManager::loadAnimationCurve(const std::string& name, KRDataBlock* data)
KRAnimationCurve *pAnimationCurve = KRAnimationCurve::Load(*m_pContext, name, data); {
if(pAnimationCurve) { KRAnimationCurve* pAnimationCurve = KRAnimationCurve::Load(*m_pContext, name, data);
if (pAnimationCurve) {
m_animationCurves[name] = pAnimationCurve; m_animationCurves[name] = pAnimationCurve;
} }
return pAnimationCurve; return pAnimationCurve;
} }
KRAnimationCurve *KRAnimationCurveManager::getAnimationCurve(const std::string &name) { KRAnimationCurve* KRAnimationCurveManager::getAnimationCurve(const std::string& name)
unordered_map<std::string, KRAnimationCurve *>::iterator itr = m_animationCurves.find(name); {
if(itr == m_animationCurves.end()) { unordered_map<std::string, KRAnimationCurve*>::iterator itr = m_animationCurves.find(name);
if (itr == m_animationCurves.end()) {
return NULL; // Not found return NULL; // Not found
} else { } else {
return (*itr).second; return (*itr).second;
} }
} }
unordered_map<std::string, KRAnimationCurve *> &KRAnimationCurveManager::getAnimationCurves() { unordered_map<std::string, KRAnimationCurve*>& KRAnimationCurveManager::getAnimationCurves()
{
return m_animationCurves; return m_animationCurves;
} }
void KRAnimationCurveManager::addAnimationCurve(KRAnimationCurve *new_animation_curve) void KRAnimationCurveManager::addAnimationCurve(KRAnimationCurve* new_animation_curve)
{ {
assert(new_animation_curve != NULL); assert(new_animation_curve != NULL);
m_animationCurves[new_animation_curve->getName()] = new_animation_curve; m_animationCurves[new_animation_curve->getName()] = new_animation_curve;

17
kraken/KRAnimationCurveManager.h
View File

@@ -41,22 +41,23 @@
using std::map; using std::map;
class KRAnimationCurveManager : public KRResourceManager { class KRAnimationCurveManager : public KRResourceManager
{
public: public:
KRAnimationCurveManager(KRContext &context); KRAnimationCurveManager(KRContext& context);
virtual ~KRAnimationCurveManager(); virtual ~KRAnimationCurveManager();
virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
virtual KRResource* getResource(const std::string& name, const std::string& extension) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
KRAnimationCurve *loadAnimationCurve(const std::string &name, KRDataBlock *data); KRAnimationCurve* loadAnimationCurve(const std::string& name, KRDataBlock* data);
KRAnimationCurve *getAnimationCurve(const std::string &name); KRAnimationCurve* getAnimationCurve(const std::string& name);
void addAnimationCurve(KRAnimationCurve *new_animation_curve); void addAnimationCurve(KRAnimationCurve* new_animation_curve);
unordered_map<std::string, KRAnimationCurve *> &getAnimationCurves(); unordered_map<std::string, KRAnimationCurve*>& getAnimationCurves();
void deleteAnimationCurve(KRAnimationCurve *curve); void deleteAnimationCurve(KRAnimationCurve* curve);
private: private:
unordered_map<std::string, KRAnimationCurve *> m_animationCurves; unordered_map<std::string, KRAnimationCurve*> m_animationCurves;
}; };

62
kraken/KRAnimationLayer.cpp
View File

@@ -31,7 +31,7 @@
#include "KRAnimationLayer.h" #include "KRAnimationLayer.h"
KRAnimationLayer::KRAnimationLayer(KRContext &context) : KRContextObject(context) KRAnimationLayer::KRAnimationLayer(KRContext& context) : KRContextObject(context)
{ {
m_name = ""; m_name = "";
m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE; m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE;
@@ -41,7 +41,7 @@ KRAnimationLayer::KRAnimationLayer(KRContext &context) : KRContextObject(context
KRAnimationLayer::~KRAnimationLayer() KRAnimationLayer::~KRAnimationLayer()
{ {
for(std::vector<KRAnimationAttribute *>::iterator itr = m_attributes.begin(); itr != m_attributes.end(); ++itr){ for (std::vector<KRAnimationAttribute*>::iterator itr = m_attributes.begin(); itr != m_attributes.end(); ++itr) {
delete (*itr); delete (*itr);
} }
} }
@@ -51,20 +51,20 @@ std::string KRAnimationLayer::getName() const
return m_name; return m_name;
} }
void KRAnimationLayer::setName(const std::string &name) void KRAnimationLayer::setName(const std::string& name)
{ {
m_name = name; m_name = name;
} }
tinyxml2::XMLElement *KRAnimationLayer::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRAnimationLayer::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLDocument *doc = parent->GetDocument(); tinyxml2::XMLDocument* doc = parent->GetDocument();
tinyxml2::XMLElement *e = doc->NewElement("layer"); tinyxml2::XMLElement* e = doc->NewElement("layer");
tinyxml2::XMLNode *n = parent->InsertEndChild(e); tinyxml2::XMLNode* n = parent->InsertEndChild(e);
e->SetAttribute("name", m_name.c_str()); e->SetAttribute("name", m_name.c_str());
e->SetAttribute("weight", m_weight); e->SetAttribute("weight", m_weight);
switch(m_blend_mode) { switch (m_blend_mode) {
case KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE: case KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE:
e->SetAttribute("blend_mode", "additive"); e->SetAttribute("blend_mode", "additive");
break; break;
@@ -76,7 +76,7 @@ tinyxml2::XMLElement *KRAnimationLayer::saveXML( tinyxml2::XMLNode *parent)
break; break;
} }
switch(m_rotation_accumulation_mode) { switch (m_rotation_accumulation_mode) {
case KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_CHANNEL: case KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_CHANNEL:
e->SetAttribute("rotation_accumulation_mode", "by_channel"); e->SetAttribute("rotation_accumulation_mode", "by_channel");
break; break;
@@ -85,7 +85,7 @@ tinyxml2::XMLElement *KRAnimationLayer::saveXML( tinyxml2::XMLNode *parent)
break; break;
} }
switch(m_scale_accumulation_mode) { switch (m_scale_accumulation_mode) {
case KRENGINE_ANIMATION_SCALE_ACCUMULATION_ADDITIVE: case KRENGINE_ANIMATION_SCALE_ACCUMULATION_ADDITIVE:
e->SetAttribute("scale_accumulation_mode", "additive"); e->SetAttribute("scale_accumulation_mode", "additive");
break; break;
@@ -94,52 +94,52 @@ tinyxml2::XMLElement *KRAnimationLayer::saveXML( tinyxml2::XMLNode *parent)
break; break;
} }
for(std::vector<KRAnimationAttribute *>::iterator itr = m_attributes.begin(); itr != m_attributes.end(); ++itr){ for (std::vector<KRAnimationAttribute*>::iterator itr = m_attributes.begin(); itr != m_attributes.end(); ++itr) {
(*itr)->saveXML(n); (*itr)->saveXML(n);
} }
return e; return e;
} }
void KRAnimationLayer::loadXML(tinyxml2::XMLElement *e) void KRAnimationLayer::loadXML(tinyxml2::XMLElement* e)
{ {
m_name = e->Attribute("name"); m_name = e->Attribute("name");
if(e->QueryFloatAttribute("weight", &m_weight) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("weight", &m_weight) != tinyxml2::XML_SUCCESS) {
m_weight = 1.0f; // default m_weight = 1.0f; // default
} }
const char *szBlendMode = e->Attribute("blend_mode"); const char* szBlendMode = e->Attribute("blend_mode");
if(strcmp(szBlendMode, "additive") == 0) { if (strcmp(szBlendMode, "additive") == 0) {
m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE; m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE;
} else if(strcmp(szBlendMode, "override") == 0) { } else if (strcmp(szBlendMode, "override") == 0) {
m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_OVERRIDE; m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_OVERRIDE;
} else if(strcmp(szBlendMode, "override_passthrough") == 0) { } else if (strcmp(szBlendMode, "override_passthrough") == 0) {
m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_OVERRIDE_PASSTHROUGH; m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_OVERRIDE_PASSTHROUGH;
} else { } else {
m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE; // default m_blend_mode = KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE; // default
} }
const char *szRotationAccumulationMode = e->Attribute("rotation_accumulation_mode"); const char* szRotationAccumulationMode = e->Attribute("rotation_accumulation_mode");
if(strcmp(szRotationAccumulationMode, "by_channel") == 0) { if (strcmp(szRotationAccumulationMode, "by_channel") == 0) {
m_rotation_accumulation_mode = KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_CHANNEL; m_rotation_accumulation_mode = KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_CHANNEL;
} else if(strcmp(szRotationAccumulationMode, "by_layer") == 0) { } else if (strcmp(szRotationAccumulationMode, "by_layer") == 0) {
m_rotation_accumulation_mode = KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_LAYER; m_rotation_accumulation_mode = KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_LAYER;
} else { } else {
m_rotation_accumulation_mode = KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_LAYER; // default m_rotation_accumulation_mode = KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_LAYER; // default
} }
const char *szScaleAccumulationMode = e->Attribute("scale_accumulation_mode"); const char* szScaleAccumulationMode = e->Attribute("scale_accumulation_mode");
if(strcmp(szScaleAccumulationMode, "additive") == 0) { if (strcmp(szScaleAccumulationMode, "additive") == 0) {
m_scale_accumulation_mode = KRENGINE_ANIMATION_SCALE_ACCUMULATION_ADDITIVE; m_scale_accumulation_mode = KRENGINE_ANIMATION_SCALE_ACCUMULATION_ADDITIVE;
} else if(strcmp(szScaleAccumulationMode, "multiply") == 0) { } else if (strcmp(szScaleAccumulationMode, "multiply") == 0) {
m_scale_accumulation_mode = KRENGINE_ANIMATION_SCALE_ACCUMULATION_MULTIPLY; m_scale_accumulation_mode = KRENGINE_ANIMATION_SCALE_ACCUMULATION_MULTIPLY;
} else { } else {
m_scale_accumulation_mode = KRENGINE_ANIMATION_SCALE_ACCUMULATION_MULTIPLY; // default m_scale_accumulation_mode = KRENGINE_ANIMATION_SCALE_ACCUMULATION_MULTIPLY; // default
} }
for(tinyxml2::XMLElement *child_element=e->FirstChildElement(); child_element != NULL; child_element = child_element->NextSiblingElement()) { for (tinyxml2::XMLElement* child_element = e->FirstChildElement(); child_element != NULL; child_element = child_element->NextSiblingElement()) {
if(strcmp(child_element->Name(), "attribute") == 0) { if (strcmp(child_element->Name(), "attribute") == 0) {
KRAnimationAttribute *new_attribute = new KRAnimationAttribute(getContext()); KRAnimationAttribute* new_attribute = new KRAnimationAttribute(getContext());
new_attribute->loadXML(child_element); new_attribute->loadXML(child_element);
m_attributes.push_back(new_attribute); m_attributes.push_back(new_attribute);
} }
@@ -162,7 +162,7 @@ KRAnimationLayer::blend_mode_t KRAnimationLayer::getBlendMode() const
return m_blend_mode; return m_blend_mode;
} }
void KRAnimationLayer::setBlendMode(const KRAnimationLayer::blend_mode_t &blend_mode) void KRAnimationLayer::setBlendMode(const KRAnimationLayer::blend_mode_t& blend_mode)
{ {
m_blend_mode = blend_mode; m_blend_mode = blend_mode;
} }
@@ -172,7 +172,7 @@ KRAnimationLayer::rotation_accumulation_mode_t KRAnimationLayer::getRotationAccu
return m_rotation_accumulation_mode; return m_rotation_accumulation_mode;
} }
void KRAnimationLayer::setRotationAccumulationMode(const KRAnimationLayer::rotation_accumulation_mode_t &rotation_accumulation_mode) void KRAnimationLayer::setRotationAccumulationMode(const KRAnimationLayer::rotation_accumulation_mode_t& rotation_accumulation_mode)
{ {
m_rotation_accumulation_mode = rotation_accumulation_mode; m_rotation_accumulation_mode = rotation_accumulation_mode;
} }
@@ -182,17 +182,17 @@ KRAnimationLayer::scale_accumulation_mode_t KRAnimationLayer::getScaleAccumulati
return m_scale_accumulation_mode; return m_scale_accumulation_mode;
} }
void KRAnimationLayer::setScaleAccumulationMode(const KRAnimationLayer::scale_accumulation_mode_t &scale_accumulation_mode) void KRAnimationLayer::setScaleAccumulationMode(const KRAnimationLayer::scale_accumulation_mode_t& scale_accumulation_mode)
{ {
m_scale_accumulation_mode = scale_accumulation_mode; m_scale_accumulation_mode = scale_accumulation_mode;
} }
void KRAnimationLayer::addAttribute(KRAnimationAttribute *attribute) void KRAnimationLayer::addAttribute(KRAnimationAttribute* attribute)
{ {
m_attributes.push_back(attribute); m_attributes.push_back(attribute);
} }
std::vector<KRAnimationAttribute *> &KRAnimationLayer::getAttributes() std::vector<KRAnimationAttribute*>& KRAnimationLayer::getAttributes()
{ {
return m_attributes; return m_attributes;
} }

36
kraken/KRAnimationLayer.h
View File

@@ -36,51 +36,55 @@
#include "KRAnimationAttribute.h" #include "KRAnimationAttribute.h"
namespace tinyxml2 { namespace tinyxml2 {
class XMLNode; class XMLNode;
class XMLAttribute; class XMLAttribute;
} }
class KRAnimationLayer : public KRContextObject { class KRAnimationLayer : public KRContextObject
{
public: public:
KRAnimationLayer(KRContext &context); KRAnimationLayer(KRContext& context);
~KRAnimationLayer(); ~KRAnimationLayer();
tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
void loadXML(tinyxml2::XMLElement *e); void loadXML(tinyxml2::XMLElement* e);
std::string getName() const; std::string getName() const;
void setName(const std::string &name); void setName(const std::string& name);
float getWeight() const; float getWeight() const;
void setWeight(float weight); void setWeight(float weight);
typedef enum { typedef enum
{
KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE, KRENGINE_ANIMATION_BLEND_MODE_ADDITIVE,
KRENGINE_ANIMATION_BLEND_MODE_OVERRIDE, KRENGINE_ANIMATION_BLEND_MODE_OVERRIDE,
KRENGINE_ANIMATION_BLEND_MODE_OVERRIDE_PASSTHROUGH KRENGINE_ANIMATION_BLEND_MODE_OVERRIDE_PASSTHROUGH
} blend_mode_t; } blend_mode_t;
blend_mode_t getBlendMode() const; blend_mode_t getBlendMode() const;
void setBlendMode(const blend_mode_t &blend_mode); void setBlendMode(const blend_mode_t& blend_mode);
typedef enum { typedef enum
{
KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_LAYER, KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_LAYER,
KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_CHANNEL KRENGINE_ANIMATION_ROTATION_ACCUMULATION_BY_CHANNEL
} rotation_accumulation_mode_t; } rotation_accumulation_mode_t;
rotation_accumulation_mode_t getRotationAccumulationMode() const; rotation_accumulation_mode_t getRotationAccumulationMode() const;
void setRotationAccumulationMode(const rotation_accumulation_mode_t &rotation_accumulation_mode); void setRotationAccumulationMode(const rotation_accumulation_mode_t& rotation_accumulation_mode);
typedef enum { typedef enum
{
KRENGINE_ANIMATION_SCALE_ACCUMULATION_MULTIPLY, KRENGINE_ANIMATION_SCALE_ACCUMULATION_MULTIPLY,
KRENGINE_ANIMATION_SCALE_ACCUMULATION_ADDITIVE KRENGINE_ANIMATION_SCALE_ACCUMULATION_ADDITIVE
} scale_accumulation_mode_t; } scale_accumulation_mode_t;
scale_accumulation_mode_t getScaleAccumulationMode() const; scale_accumulation_mode_t getScaleAccumulationMode() const;
void setScaleAccumulationMode(const scale_accumulation_mode_t &scale_accumulation_mode); void setScaleAccumulationMode(const scale_accumulation_mode_t& scale_accumulation_mode);
void addAttribute(KRAnimationAttribute *attribute); void addAttribute(KRAnimationAttribute* attribute);
std::vector<KRAnimationAttribute *> &getAttributes(); std::vector<KRAnimationAttribute*>& getAttributes();
private: private:
std::string m_name; std::string m_name;
@@ -89,5 +93,5 @@ private:
rotation_accumulation_mode_t m_rotation_accumulation_mode; rotation_accumulation_mode_t m_rotation_accumulation_mode;
scale_accumulation_mode_t m_scale_accumulation_mode; scale_accumulation_mode_t m_scale_accumulation_mode;
std::vector<KRAnimationAttribute *> m_attributes; std::vector<KRAnimationAttribute*> m_attributes;
}; };

47
kraken/KRAnimationManager.cpp
View File

@@ -32,36 +32,37 @@
#include "KRAnimationManager.h" #include "KRAnimationManager.h"
#include "KRAnimation.h" #include "KRAnimation.h"
KRAnimationManager::KRAnimationManager(KRContext &context) : KRResourceManager(context) KRAnimationManager::KRAnimationManager(KRContext& context) : KRResourceManager(context)
{ {
} }
KRAnimationManager::~KRAnimationManager() { KRAnimationManager::~KRAnimationManager()
for(std::set<KRAnimation *>::iterator itr = m_activeAnimations.begin(); itr != m_activeAnimations.end(); itr++) { {
KRAnimation *animation = *itr; for (std::set<KRAnimation*>::iterator itr = m_activeAnimations.begin(); itr != m_activeAnimations.end(); itr++) {
KRAnimation* animation = *itr;
animation->_unlockData(); animation->_unlockData();
} }
for(unordered_map<std::string, KRAnimation *>::iterator itr = m_animations.begin(); itr != m_animations.end(); ++itr){ for (unordered_map<std::string, KRAnimation*>::iterator itr = m_animations.begin(); itr != m_animations.end(); ++itr) {
delete (*itr).second; delete (*itr).second;
} }
} }
void KRAnimationManager::startFrame(float deltaTime) void KRAnimationManager::startFrame(float deltaTime)
{ {
for(std::set<KRAnimation *>::iterator itr = m_animationsToUpdate.begin(); itr != m_animationsToUpdate.end(); itr++) { for (std::set<KRAnimation*>::iterator itr = m_animationsToUpdate.begin(); itr != m_animationsToUpdate.end(); itr++) {
KRAnimation *animation = *itr; KRAnimation* animation = *itr;
std::set<KRAnimation *>::iterator active_animations_itr = m_activeAnimations.find(animation); std::set<KRAnimation*>::iterator active_animations_itr = m_activeAnimations.find(animation);
if(animation->isPlaying()) { if (animation->isPlaying()) {
// Add playing animations to the active animations list // Add playing animations to the active animations list
if(active_animations_itr == m_activeAnimations.end()) { if (active_animations_itr == m_activeAnimations.end()) {
m_activeAnimations.insert(animation); m_activeAnimations.insert(animation);
animation->_lockData(); animation->_lockData();
} }
} else { } else {
// Remove stopped animations from the active animations list // Remove stopped animations from the active animations list
if(active_animations_itr != m_activeAnimations.end()) { if (active_animations_itr != m_activeAnimations.end()) {
m_activeAnimations.erase(active_animations_itr); m_activeAnimations.erase(active_animations_itr);
animation->_unlockData(); animation->_unlockData();
} }
@@ -70,8 +71,8 @@ void KRAnimationManager::startFrame(float deltaTime)
m_animationsToUpdate.clear(); m_animationsToUpdate.clear();
for(std::set<KRAnimation *>::iterator active_animations_itr = m_activeAnimations.begin(); active_animations_itr != m_activeAnimations.end(); active_animations_itr++) { for (std::set<KRAnimation*>::iterator active_animations_itr = m_activeAnimations.begin(); active_animations_itr != m_activeAnimations.end(); active_animations_itr++) {
KRAnimation *animation = *active_animations_itr; KRAnimation* animation = *active_animations_itr;
animation->update(deltaTime); animation->update(deltaTime);
} }
} }
@@ -96,35 +97,37 @@ KRResource* KRAnimationManager::getResource(const std::string& name, const std::
return nullptr; return nullptr;
} }
KRAnimation *KRAnimationManager::loadAnimation(const char *szName, KRDataBlock *data) { KRAnimation* KRAnimationManager::loadAnimation(const char* szName, KRDataBlock* data)
KRAnimation *pAnimation = KRAnimation::Load(*m_pContext, szName, data); {
KRAnimation* pAnimation = KRAnimation::Load(*m_pContext, szName, data);
addAnimation(pAnimation); addAnimation(pAnimation);
return pAnimation; return pAnimation;
} }
KRAnimation *KRAnimationManager::getAnimation(const char *szName) { KRAnimation* KRAnimationManager::getAnimation(const char* szName)
{
return m_animations[szName]; return m_animations[szName];
} }
unordered_map<std::string, KRAnimation *> &KRAnimationManager::getAnimations() { unordered_map<std::string, KRAnimation*>& KRAnimationManager::getAnimations()
{
return m_animations; return m_animations;
} }
void KRAnimationManager::addAnimation(KRAnimation *new_animation) void KRAnimationManager::addAnimation(KRAnimation* new_animation)
{ {
m_animations[new_animation->getName()] = new_animation; m_animations[new_animation->getName()] = new_animation;
updateActiveAnimations(new_animation); updateActiveAnimations(new_animation);
} }
void KRAnimationManager::updateActiveAnimations(KRAnimation *animation) void KRAnimationManager::updateActiveAnimations(KRAnimation* animation)
{ {
m_animationsToUpdate.insert(animation); m_animationsToUpdate.insert(animation);
} }
void KRAnimationManager::deleteAnimation(KRAnimation *animation, bool delete_curves) void KRAnimationManager::deleteAnimation(KRAnimation* animation, bool delete_curves)
{ {
if(delete_curves) if (delete_curves) {
{
animation->deleteCurves(); animation->deleteCurves();
} }
m_animations.erase(animation->getName()); m_animations.erase(animation->getName());

23
kraken/KRAnimationManager.h
View File

@@ -41,28 +41,29 @@
class KRAnimationManager : public KRResourceManager { class KRAnimationManager : public KRResourceManager
{
public: public:
KRAnimationManager(KRContext &context); KRAnimationManager(KRContext& context);
virtual ~KRAnimationManager(); virtual ~KRAnimationManager();
virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
virtual KRResource* getResource(const std::string& name, const std::string& extension) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
KRAnimation *loadAnimation(const char *szName, KRDataBlock *data); KRAnimation* loadAnimation(const char* szName, KRDataBlock* data);
KRAnimation *getAnimation(const char *szName); KRAnimation* getAnimation(const char* szName);
void addAnimation(KRAnimation *new_animation); void addAnimation(KRAnimation* new_animation);
unordered_map<std::string, KRAnimation *> &getAnimations(); unordered_map<std::string, KRAnimation*>& getAnimations();
void deleteAnimation(KRAnimation *animation, bool delete_curves); void deleteAnimation(KRAnimation* animation, bool delete_curves);
void startFrame(float deltaTime); void startFrame(float deltaTime);
void endFrame(float deltaTime); void endFrame(float deltaTime);
void updateActiveAnimations(KRAnimation *animation); void updateActiveAnimations(KRAnimation* animation);
private: private:
unordered_map<std::string, KRAnimation *> m_animations; unordered_map<std::string, KRAnimation*> m_animations;
set<KRAnimation *> m_activeAnimations; set<KRAnimation*> m_activeAnimations;
set<KRAnimation *> m_animationsToUpdate; set<KRAnimation*> m_animationsToUpdate;
}; };

8
kraken/KRAudioBuffer.cpp
View File

@@ -33,7 +33,7 @@
#include "KRAudioManager.h" #include "KRAudioManager.h"
KRAudioBuffer::KRAudioBuffer(KRAudioManager *manager, KRAudioSample *sound, int index, int frameCount, int frameRate, int bytesPerFrame, void (*fn_populate)(KRAudioSample *, int, void *)) KRAudioBuffer::KRAudioBuffer(KRAudioManager* manager, KRAudioSample* sound, int index, int frameCount, int frameRate, int bytesPerFrame, void (*fn_populate)(KRAudioSample*, int, void*))
{ {
m_pSoundManager = manager; m_pSoundManager = manager;
m_frameCount = frameCount; m_frameCount = frameCount;
@@ -53,7 +53,7 @@ KRAudioBuffer::~KRAudioBuffer()
m_pSoundManager->recycleBufferData(m_pData); m_pSoundManager->recycleBufferData(m_pData);
} }
KRAudioSample *KRAudioBuffer::getAudioSample() KRAudioSample* KRAudioBuffer::getAudioSample()
{ {
return m_audioSample; return m_audioSample;
} }
@@ -68,9 +68,9 @@ int KRAudioBuffer::getFrameRate()
return m_frameRate; return m_frameRate;
} }
signed short *KRAudioBuffer::getFrameData() signed short* KRAudioBuffer::getFrameData()
{ {
return (signed short *)m_pData->getStart(); return (signed short*)m_pData->getStart();
} }
int KRAudioBuffer::getIndex() int KRAudioBuffer::getIndex()

12
kraken/KRAudioBuffer.h
View File

@@ -40,23 +40,23 @@ class KRAudioSample;
class KRAudioBuffer class KRAudioBuffer
{ {
public: public:
KRAudioBuffer(KRAudioManager *manager, KRAudioSample *sound, int index, int frameCount, int frameRate, int bytesPerFrame, void (*fn_populate)(KRAudioSample *, int, void *)); KRAudioBuffer(KRAudioManager* manager, KRAudioSample* sound, int index, int frameCount, int frameRate, int bytesPerFrame, void (*fn_populate)(KRAudioSample*, int, void*));
~KRAudioBuffer(); ~KRAudioBuffer();
int getFrameCount(); int getFrameCount();
int getFrameRate(); int getFrameRate();
signed short *getFrameData(); signed short* getFrameData();
KRAudioSample *getAudioSample(); KRAudioSample* getAudioSample();
int getIndex(); int getIndex();
private: private:
KRAudioManager *m_pSoundManager; KRAudioManager* m_pSoundManager;
int m_index; int m_index;
int m_frameCount; int m_frameCount;
int m_frameRate; int m_frameRate;
int m_bytesPerFrame; int m_bytesPerFrame;
KRDataBlock *m_pData; KRDataBlock* m_pData;
KRAudioSample *m_audioSample; KRAudioSample* m_audioSample;
}; };

1201
kraken/KRAudioManager.cpp
View File

File diff suppressed because it is too large Load Diff

99
kraken/KRAudioManager.h
View File

@@ -59,9 +59,9 @@ const int KRENGINE_AUDIO_BLOCK_LOG2N = 7; // 2 ^ KRENGINE_AUDIO_BLOCK_LOG2N =
// 7 is 128 .. NOTE: the hrtf code uses magic numbers everywhere and is hardcoded to 128 samples per frame // 7 is 128 .. NOTE: the hrtf code uses magic numbers everywhere and is hardcoded to 128 samples per frame
const int KRENGINE_AUDIO_BLOCK_LENGTH = 1 << KRENGINE_AUDIO_BLOCK_LOG2N; const int KRENGINE_AUDIO_BLOCK_LENGTH = 1 << KRENGINE_AUDIO_BLOCK_LOG2N;
// Length of one block to process. Determines the latency of the audio system and sets size for FFT's used in HRTF convolution // Length of one block to process. Determines the latency of the audio system and sets size for FFT's used in HRTF convolution
// the AUGraph works in 1024 sample chunks. At 128 we are making 8 consecutive calls to the renderBlock method for each // the AUGraph works in 1024 sample chunks. At 128 we are making 8 consecutive calls to the renderBlock method for each
// render initiated by the AUGraph. // render initiated by the AUGraph.
const int KRENGINE_REVERB_MAX_FFT_LOG2 = 15; const int KRENGINE_REVERB_MAX_FFT_LOG2 = 15;
const int KRENGINE_REVERB_WORKSPACE_SIZE = 1 << KRENGINE_REVERB_MAX_FFT_LOG2; const int KRENGINE_REVERB_WORKSPACE_SIZE = 1 << KRENGINE_REVERB_MAX_FFT_LOG2;
@@ -79,42 +79,45 @@ const int KRENGINE_AUDIO_ANTICLICK_SAMPLES = 64;
class KRAmbientZone; class KRAmbientZone;
class KRReverbZone; class KRReverbZone;
typedef struct { typedef struct
{
float weight; float weight;
KRAmbientZone *ambient_zone; KRAmbientZone* ambient_zone;
KRAudioSample *ambient_sample; KRAudioSample* ambient_sample;
} siren_ambient_zone_weight_info; } siren_ambient_zone_weight_info;
typedef struct { typedef struct
{
float weight; float weight;
KRReverbZone *reverb_zone; KRReverbZone* reverb_zone;
KRAudioSample *reverb_sample; KRAudioSample* reverb_sample;
} siren_reverb_zone_weight_info; } siren_reverb_zone_weight_info;
class KRAudioManager : public KRResourceManager { class KRAudioManager : public KRResourceManager
{
public: public:
KRAudioManager(KRContext &context); KRAudioManager(KRContext& context);
virtual ~KRAudioManager(); virtual ~KRAudioManager();
void destroy(); void destroy();
virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
virtual KRResource* getResource(const std::string& name, const std::string& extension) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
unordered_map<std::string, KRAudioSample *> &getSounds(); unordered_map<std::string, KRAudioSample*>& getSounds();
void add(KRAudioSample *Sound); void add(KRAudioSample* Sound);
KRAudioSample *load(const std::string &name, const std::string &extension, KRDataBlock *data); KRAudioSample* load(const std::string& name, const std::string& extension, KRDataBlock* data);
KRAudioSample *get(const std::string &name); KRAudioSample* get(const std::string& name);
// Listener position and orientation // Listener position and orientation
KRScene *getListenerScene(); KRScene* getListenerScene();
void setListenerScene(KRScene *scene); void setListenerScene(KRScene* scene);
void setListenerOrientation(const Vector3 &position, const Vector3 &forward, const Vector3 &up); void setListenerOrientation(const Vector3& position, const Vector3& forward, const Vector3& up);
void setListenerOrientationFromModelMatrix(const Matrix4 &modelMatrix); void setListenerOrientationFromModelMatrix(const Matrix4& modelMatrix);
Vector3 &getListenerForward(); Vector3& getListenerForward();
Vector3 &getListenerPosition(); Vector3& getListenerPosition();
Vector3 &getListenerUp(); Vector3& getListenerUp();
// Global audio gain / attenuation // Global audio gain / attenuation
@@ -129,15 +132,15 @@ public:
void makeCurrentContext(); void makeCurrentContext();
KRDataBlock *getBufferData(int size); KRDataBlock* getBufferData(int size);
void recycleBufferData(KRDataBlock *data); void recycleBufferData(KRDataBlock* data);
void activateAudioSource(KRAudioSource *audioSource); void activateAudioSource(KRAudioSource* audioSource);
void deactivateAudioSource(KRAudioSource *audioSource); void deactivateAudioSource(KRAudioSource* audioSource);
__int64_t getAudioFrame(); __int64_t getAudioFrame();
KRAudioBuffer *getBuffer(KRAudioSample &audio_sample, int buffer_index); KRAudioBuffer* getBuffer(KRAudioSample& audio_sample, int buffer_index);
static void mute(bool onNotOff); static void mute(bool onNotOff);
void goToSleep(); void goToSleep();
@@ -156,8 +159,8 @@ public:
float getReverbMaxLength(); float getReverbMaxLength();
void setReverbMaxLength(float max_length); void setReverbMaxLength(float max_length);
void _registerOpenAudioSample(KRAudioSample *audioSample); void _registerOpenAudioSample(KRAudioSample* audioSample);
void _registerCloseAudioSample(KRAudioSample *audioSample); void _registerCloseAudioSample(KRAudioSample* audioSample);
private: private:
bool m_enable_audio; bool m_enable_audio;
@@ -165,7 +168,7 @@ private:
bool m_enable_reverb; bool m_enable_reverb;
float m_reverb_max_length; float m_reverb_max_length;
KRScene *m_listener_scene; // For now, only one scene is allowed to have active audio at once KRScene* m_listener_scene; // For now, only one scene is allowed to have active audio at once
float m_global_reverb_send_level; float m_global_reverb_send_level;
float m_global_ambient_gain; float m_global_ambient_gain;
@@ -175,15 +178,15 @@ private:
Vector3 m_listener_forward; Vector3 m_listener_forward;
Vector3 m_listener_up; Vector3 m_listener_up;
unordered_map<std::string, KRAudioSample *> m_sounds; unordered_map<std::string, KRAudioSample*> m_sounds;
std::vector<KRDataBlock *> m_bufferPoolIdle; std::vector<KRDataBlock*> m_bufferPoolIdle;
std::vector<KRAudioBuffer *> m_bufferCache; std::vector<KRAudioBuffer*> m_bufferCache;
std::set<KRAudioSource *> m_activeAudioSources; std::set<KRAudioSource*> m_activeAudioSources;
std::set<KRAudioSample *> m_openAudioSamples; std::set<KRAudioSample*> m_openAudioSamples;
void initAudio(); void initAudio();
void initHRTF(); void initHRTF();
@@ -197,29 +200,29 @@ private:
AUGraph m_auGraph; AUGraph m_auGraph;
AudioUnit m_auMixer; AudioUnit m_auMixer;
static OSStatus renderInput(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData); static OSStatus renderInput(void* inRefCon, AudioUnitRenderActionFlags* ioActionFlags, const AudioTimeStamp* inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList* ioData);
void renderAudio(UInt32 inNumberFrames, AudioBufferList *ioData); void renderAudio(UInt32 inNumberFrames, AudioBufferList* ioData);
#endif #endif
KRDSP::FFTWorkspace m_fft_setup[KRENGINE_REVERB_MAX_FFT_LOG2 - KRENGINE_AUDIO_BLOCK_LOG2N + 1]; KRDSP::FFTWorkspace m_fft_setup[KRENGINE_REVERB_MAX_FFT_LOG2 - KRENGINE_AUDIO_BLOCK_LOG2N + 1];
__int64_t m_audio_frame; // Number of audio frames processed since the start of the application __int64_t m_audio_frame; // Number of audio frames processed since the start of the application
float *m_reverb_input_samples; // Circular-buffered reverb input, single channel float* m_reverb_input_samples; // Circular-buffered reverb input, single channel
int m_reverb_input_next_sample; // Pointer to next sample in reverb buffer int m_reverb_input_next_sample; // Pointer to next sample in reverb buffer
int m_reverb_sequence; int m_reverb_sequence;
KRAudioSample *m_reverb_impulse_responses[KRENGINE_MAX_REVERB_IMPULSE_MIX]; KRAudioSample* m_reverb_impulse_responses[KRENGINE_MAX_REVERB_IMPULSE_MIX];
float m_reverb_impulse_responses_weight[KRENGINE_MAX_REVERB_IMPULSE_MIX]; float m_reverb_impulse_responses_weight[KRENGINE_MAX_REVERB_IMPULSE_MIX];
float *m_output_accumulation; // Interleaved output accumulation buffer float* m_output_accumulation; // Interleaved output accumulation buffer
int m_output_accumulation_block_start; int m_output_accumulation_block_start;
int m_output_sample; int m_output_sample;
float *m_workspace_data; float* m_workspace_data;
KRDSP::SplitComplex m_workspace[3]; KRDSP::SplitComplex m_workspace[3];
float *getBlockAddress(int block_offset); float* getBlockAddress(int block_offset);
void renderBlock(); void renderBlock();
void renderReverb(); void renderReverb();
void renderAmbient(); void renderAmbient();
@@ -229,13 +232,13 @@ private:
void renderLimiter(); void renderLimiter();
std::vector<Vector2> m_hrtf_sample_locations; std::vector<Vector2> m_hrtf_sample_locations;
float *m_hrtf_data; float* m_hrtf_data;
unordered_map<Vector2, KRDSP::SplitComplex> m_hrtf_spectral[2]; unordered_map<Vector2, KRDSP::SplitComplex> m_hrtf_spectral[2];
Vector2 getNearestHRTFSample(const Vector2 &dir); Vector2 getNearestHRTFSample(const Vector2& dir);
void getHRTFMix(const Vector2 &dir, Vector2 &hrtf1, Vector2 &hrtf2, Vector2 &hrtf3, Vector2 &hrtf4, float &mix1, float &mix2, float &mix3, float &mix4); void getHRTFMix(const Vector2& dir, Vector2& hrtf1, Vector2& hrtf2, Vector2& hrtf3, Vector2& hrtf4, float& mix1, float& mix2, float& mix3, float& mix4);
KRAudioSample *getHRTFSample(const Vector2 &hrtf_dir); KRAudioSample* getHRTFSample(const Vector2& hrtf_dir);
KRDSP::SplitComplex getHRTFSpectral(const Vector2 &hrtf_dir, const int channel); KRDSP::SplitComplex getHRTFSpectral(const Vector2& hrtf_dir, const int channel);
unordered_map<std::string, siren_ambient_zone_weight_info> m_ambient_zone_weights; unordered_map<std::string, siren_ambient_zone_weight_info> m_ambient_zone_weights;
float m_ambient_zone_total_weight = 0.0f; // For normalizing zone weights float m_ambient_zone_total_weight = 0.0f; // For normalizing zone weights
@@ -249,7 +252,7 @@ private:
#endif #endif
unordered_multimap<Vector2, std::pair<KRAudioSource *, std::pair<float, float> > > m_mapped_sources, m_prev_mapped_sources; unordered_multimap<Vector2, std::pair<KRAudioSource*, std::pair<float, float> > > m_mapped_sources, m_prev_mapped_sources;
bool m_anticlick_block; bool m_anticlick_block;
bool m_high_quality_hrtf; // If true, 4 HRTF samples will be interpolated; if false, the nearest HRTF sample will be used without interpolation bool m_high_quality_hrtf; // If true, 4 HRTF samples will be interpolated; if false, the nearest HRTF sample will be used without interpolation
}; };

100
kraken/KRAudioSample.cpp
View File

@@ -36,7 +36,7 @@
#include "KRContext.h" #include "KRContext.h"
#include "KRDSP.h" #include "KRDSP.h"
KRAudioSample::KRAudioSample(KRContext &context, std::string name, std::string extension) : KRResource(context, name) KRAudioSample::KRAudioSample(KRContext& context, std::string name, std::string extension) : KRResource(context, name)
{ {
m_pData = new KRDataBlock(); m_pData = new KRDataBlock();
m_extension = extension; m_extension = extension;
@@ -54,7 +54,7 @@ KRAudioSample::KRAudioSample(KRContext &context, std::string name, std::string e
m_last_frame_used = 0; m_last_frame_used = 0;
} }
KRAudioSample::KRAudioSample(KRContext &context, std::string name, std::string extension, KRDataBlock *data) : KRResource(context, name) KRAudioSample::KRAudioSample(KRContext& context, std::string name, std::string extension, KRDataBlock* data) : KRResource(context, name)
{ {
m_pData = data; m_pData = data;
m_extension = extension; m_extension = extension;
@@ -97,11 +97,11 @@ float KRAudioSample::sample(int frame_offset, int frame_rate, int channel)
int c = KRMIN(channel, m_channelsPerFrame - 1); int c = KRMIN(channel, m_channelsPerFrame - 1);
if(frame_offset < 0) { if (frame_offset < 0) {
return 0.0f; // Past the beginning of the recording return 0.0f; // Past the beginning of the recording
} else { } else {
int sample_frame; int sample_frame;
if(m_frameRate == frame_rate) { if (m_frameRate == frame_rate) {
// No resampling required // No resampling required
sample_frame = frame_offset; sample_frame = frame_offset;
} else { } else {
@@ -110,37 +110,37 @@ float KRAudioSample::sample(int frame_offset, int frame_rate, int channel)
} }
int maxFramesPerBuffer = KRENGINE_AUDIO_MAX_BUFFER_SIZE / m_bytesPerFrame; int maxFramesPerBuffer = KRENGINE_AUDIO_MAX_BUFFER_SIZE / m_bytesPerFrame;
int buffer_index = sample_frame / maxFramesPerBuffer; int buffer_index = sample_frame / maxFramesPerBuffer;
if(buffer_index >= m_bufferCount) { if (buffer_index >= m_bufferCount) {
return 0.0f; // Past the end of the recording return 0.0f; // Past the end of the recording
} else { } else {
__int64_t buffer_offset = frame_offset - buffer_index * maxFramesPerBuffer; __int64_t buffer_offset = frame_offset - buffer_index * maxFramesPerBuffer;
KRAudioBuffer *buffer = getContext().getAudioManager()->getBuffer(*this, buffer_index); KRAudioBuffer* buffer = getContext().getAudioManager()->getBuffer(*this, buffer_index);
if(buffer == NULL) { if (buffer == NULL) {
return 0.0f; return 0.0f;
} else if(buffer_offset >= buffer->getFrameCount()) { } else if (buffer_offset >= buffer->getFrameCount()) {
return 0.0f; // past the end of the recording return 0.0f; // past the end of the recording
} else { } else {
short *frame = buffer->getFrameData() + (buffer_offset * m_channelsPerFrame); short* frame = buffer->getFrameData() + (buffer_offset * m_channelsPerFrame);
return frame[c] / 32767.0f; return frame[c] / 32767.0f;
} }
} }
} }
} }
void KRAudioSample::sample(__int64_t frame_offset, int frame_count, int channel, float *buffer, float amplitude, bool loop) void KRAudioSample::sample(__int64_t frame_offset, int frame_count, int channel, float* buffer, float amplitude, bool loop)
{ {
loadInfo(); loadInfo();
m_last_frame_used = (int)getContext().getAudioManager()->getAudioFrame(); m_last_frame_used = (int)getContext().getAudioManager()->getAudioFrame();
if(loop) { if (loop) {
int buffer_offset = 0; int buffer_offset = 0;
int frames_left = frame_count; int frames_left = frame_count;
int sample_length = (int)getFrameCount(); int sample_length = (int)getFrameCount();
while(frames_left) { while (frames_left) {
int next_frame = (int)(((__int64_t)frame_offset + (__int64_t)buffer_offset) % sample_length); int next_frame = (int)(((__int64_t)frame_offset + (__int64_t)buffer_offset) % sample_length);
if(next_frame + frames_left >= sample_length) { if (next_frame + frames_left >= sample_length) {
int frames_processed = sample_length - next_frame; int frames_processed = sample_length - next_frame;
sample(next_frame, frames_processed, channel, buffer + buffer_offset, amplitude, false); sample(next_frame, frames_processed, channel, buffer + buffer_offset, amplitude, false);
frames_left -= frames_processed; frames_left -= frames_processed;
@@ -153,16 +153,16 @@ void KRAudioSample::sample(__int64_t frame_offset, int frame_count, int channel,
} else { } else {
int c = KRMIN(channel, m_channelsPerFrame - 1); int c = KRMIN(channel, m_channelsPerFrame - 1);
if(frame_offset + frame_count <= 0) { if (frame_offset + frame_count <= 0) {
// Range is entirely before the sample // Range is entirely before the sample
memset(buffer, 0, frame_count * sizeof(float)); memset(buffer, 0, frame_count * sizeof(float));
} else if(frame_offset >= m_totalFrames) { } else if (frame_offset >= m_totalFrames) {
// Range is entirely after the sample // Range is entirely after the sample
memset(buffer, 0, frame_count * sizeof(float)); memset(buffer, 0, frame_count * sizeof(float));
} else { } else {
int start_frame = (int)(frame_offset < 0 ? 0 : frame_offset); int start_frame = (int)(frame_offset < 0 ? 0 : frame_offset);
int prefix_frames = (int)(frame_offset < 0 ? -frame_offset : 0); int prefix_frames = (int)(frame_offset < 0 ? -frame_offset : 0);
if(prefix_frames > 0) { if (prefix_frames > 0) {
// Prefix with padding of 0's // Prefix with padding of 0's
memset(buffer, 0, prefix_frames * sizeof(float)); memset(buffer, 0, prefix_frames * sizeof(float));
} }
@@ -172,18 +172,18 @@ void KRAudioSample::sample(__int64_t frame_offset, int frame_count, int channel,
int buffer_index = start_frame / frames_per_buffer; int buffer_index = start_frame / frames_per_buffer;
int buffer_offset = start_frame % frames_per_buffer; int buffer_offset = start_frame % frames_per_buffer;
int processed_frames = prefix_frames; int processed_frames = prefix_frames;
while(processed_frames < frame_count) { while (processed_frames < frame_count) {
int frames_left = frame_count - processed_frames; int frames_left = frame_count - processed_frames;
if(buffer_index >= m_bufferCount) { if (buffer_index >= m_bufferCount) {
// Suffix with padding of 0's // Suffix with padding of 0's
memset(buffer + processed_frames, 0, frames_left * sizeof(float)); memset(buffer + processed_frames, 0, frames_left * sizeof(float));
processed_frames += frames_left; processed_frames += frames_left;
} else { } else {
KRAudioBuffer *source_buffer = getContext().getAudioManager()->getBuffer(*this, buffer_index); KRAudioBuffer* source_buffer = getContext().getAudioManager()->getBuffer(*this, buffer_index);
int frames_to_copy = source_buffer->getFrameCount() - buffer_offset; int frames_to_copy = source_buffer->getFrameCount() - buffer_offset;
if(frames_to_copy > frames_left) frames_to_copy = frames_left; if (frames_to_copy > frames_left) frames_to_copy = frames_left;
if(frames_to_copy > 0) { if (frames_to_copy > 0) {
signed short *source_data = source_buffer->getFrameData() + buffer_offset * m_channelsPerFrame + c; signed short* source_data = source_buffer->getFrameData() + buffer_offset * m_channelsPerFrame + c;
KRDSP::Int16ToFloat(source_data, m_channelsPerFrame, buffer + processed_frames, 1, frames_to_copy); KRDSP::Int16ToFloat(source_data, m_channelsPerFrame, buffer + processed_frames, 1, frames_to_copy);
//memcpy(buffer + processed_frames, source_buffer->getFrameData() + buffer_offset, frames_to_copy * m_channelsPerFrame * sizeof(float)); //memcpy(buffer + processed_frames, source_buffer->getFrameData() + buffer_offset, frames_to_copy * m_channelsPerFrame * sizeof(float));
processed_frames += frames_to_copy; processed_frames += frames_to_copy;
@@ -202,13 +202,13 @@ void KRAudioSample::sample(__int64_t frame_offset, int frame_count, int channel,
#ifdef __APPLE__ #ifdef __APPLE__
// Apple Audio Toolbox // Apple Audio Toolbox
OSStatus KRAudioSample::ReadProc( // AudioFile_ReadProc OSStatus KRAudioSample::ReadProc( // AudioFile_ReadProc
void * inClientData, void* inClientData,
SInt64 inPosition, SInt64 inPosition,
UInt32 requestCount, UInt32 requestCount,
void * buffer, void* buffer,
UInt32 * actualCount) UInt32* actualCount)
{ {
KRAudioSample *sound = (KRAudioSample *)inClientData; KRAudioSample* sound = (KRAudioSample*)inClientData;
UInt32 max_count = sound->m_pData->getSize() - inPosition; UInt32 max_count = sound->m_pData->getSize() - inPosition;
*actualCount = requestCount < max_count ? requestCount : max_count; *actualCount = requestCount < max_count ? requestCount : max_count;
sound->m_pData->copy(buffer, inPosition, *actualCount); sound->m_pData->copy(buffer, inPosition, *actualCount);
@@ -216,25 +216,25 @@ OSStatus KRAudioSample::ReadProc( // AudioFile_ReadProc
} }
SInt64 KRAudioSample::GetSizeProc( // AudioFile_GetSizeProc SInt64 KRAudioSample::GetSizeProc( // AudioFile_GetSizeProc
void * inClientData) void* inClientData)
{ {
KRAudioSample *sound = (KRAudioSample *)inClientData; KRAudioSample* sound = (KRAudioSample*)inClientData;
return sound->m_pData->getSize(); return sound->m_pData->getSize();
} }
OSStatus KRAudioSample::SetSizeProc( // AudioFile_SetSizeProc OSStatus KRAudioSample::SetSizeProc( // AudioFile_SetSizeProc
void * inClientData, void* inClientData,
SInt64 inSize) SInt64 inSize)
{ {
return -1; // Writing not supported return -1; // Writing not supported
} }
OSStatus KRAudioSample::WriteProc( // AudioFile_WriteProc OSStatus KRAudioSample::WriteProc( // AudioFile_WriteProc
void * inClientData, void* inClientData,
SInt64 inPosition, SInt64 inPosition,
UInt32 requestCount, UInt32 requestCount,
const void *buffer, const void* buffer,
UInt32 * actualCount) UInt32* actualCount)
{ {
return -1; // Writing not supported return -1; // Writing not supported
} }
@@ -243,21 +243,21 @@ OSStatus KRAudioSample::WriteProc( // AudioFile_WriteProc
void KRAudioSample::openFile() void KRAudioSample::openFile()
{ {
#ifdef __APPLE__ #ifdef __APPLE__
// Apple Audio Toolbox // Apple Audio Toolbox
// AudioFileInitializeWithCallbacks // AudioFileInitializeWithCallbacks
if(m_fileRef == NULL) { if (m_fileRef == NULL) {
// printf("Call to KRAudioSample::openFile() with extension: %s\n", m_extension.c_str()); // printf("Call to KRAudioSample::openFile() with extension: %s\n", m_extension.c_str());
// The m_extension is valid (it's either wav or mp3 for the files in Circa project) // The m_extension is valid (it's either wav or mp3 for the files in Circa project)
// so we can key off the extension and use a different data handler for mp3 files if we want to // so we can key off the extension and use a different data handler for mp3 files if we want to
// //
// Temp variables // Temp variables
UInt32 propertySize; UInt32 propertySize;
// ---- Open audio file ---- // ---- Open audio file ----
assert(AudioFileOpenWithCallbacks((void *)this, ReadProc, WriteProc, GetSizeProc, SetSizeProc, 0, &m_audio_file_id) == noErr); assert(AudioFileOpenWithCallbacks((void*)this, ReadProc, WriteProc, GetSizeProc, SetSizeProc, 0, &m_audio_file_id) == noErr);
assert(ExtAudioFileWrapAudioFileID(m_audio_file_id, false, &m_fileRef) == noErr); assert(ExtAudioFileWrapAudioFileID(m_audio_file_id, false, &m_fileRef) == noErr);
// ---- Get file format information ---- // ---- Get file format information ----
@@ -287,7 +287,7 @@ void KRAudioSample::openFile()
m_frameRate = outputFormat.mSampleRate; m_frameRate = outputFormat.mSampleRate;
int maxFramesPerBuffer = KRENGINE_AUDIO_MAX_BUFFER_SIZE / m_bytesPerFrame; int maxFramesPerBuffer = KRENGINE_AUDIO_MAX_BUFFER_SIZE / m_bytesPerFrame;
m_bufferCount = (m_totalFrames+maxFramesPerBuffer-1)/maxFramesPerBuffer; // CEIL(_totalFrames / maxFramesPerBuffer) m_bufferCount = (m_totalFrames + maxFramesPerBuffer - 1) / maxFramesPerBuffer; // CEIL(_totalFrames / maxFramesPerBuffer)
m_channelsPerFrame = outputFormat.mChannelsPerFrame; m_channelsPerFrame = outputFormat.mChannelsPerFrame;
@@ -302,12 +302,12 @@ void KRAudioSample::closeFile()
{ {
#ifdef __APPLE__ #ifdef __APPLE__
// Apple Audio Toolbox // Apple Audio Toolbox
if(m_fileRef) { if (m_fileRef) {
ExtAudioFileDispose(m_fileRef); ExtAudioFileDispose(m_fileRef);
m_fileRef = NULL; m_fileRef = NULL;
} }
if(m_audio_file_id) { if (m_audio_file_id) {
AudioFileClose(m_audio_file_id); AudioFileClose(m_audio_file_id);
m_audio_file_id = 0; m_audio_file_id = 0;
} }
@@ -318,7 +318,7 @@ void KRAudioSample::closeFile()
void KRAudioSample::loadInfo() void KRAudioSample::loadInfo()
{ {
if(m_frameRate == 0) { if (m_frameRate == 0) {
openFile(); openFile();
closeFile(); closeFile();
} }
@@ -329,7 +329,7 @@ std::string KRAudioSample::getExtension()
return m_extension; return m_extension;
} }
bool KRAudioSample::save(KRDataBlock &data) bool KRAudioSample::save(KRDataBlock& data)
{ {
data.append(*m_pData); data.append(*m_pData);
return true; return true;
@@ -347,7 +347,7 @@ int KRAudioSample::getBufferCount()
return m_bufferCount; return m_bufferCount;
} }
void KRAudioSample::PopulateBuffer(KRAudioSample *sound, int index, void *data) void KRAudioSample::PopulateBuffer(KRAudioSample* sound, int index, void* data)
{ {
int maxFramesPerBuffer = KRENGINE_AUDIO_MAX_BUFFER_SIZE / sound->m_bytesPerFrame; int maxFramesPerBuffer = KRENGINE_AUDIO_MAX_BUFFER_SIZE / sound->m_bytesPerFrame;
int startFrame = index * maxFramesPerBuffer; int startFrame = index * maxFramesPerBuffer;
@@ -367,7 +367,7 @@ void KRAudioSample::PopulateBuffer(KRAudioSample *sound, int index, void *data)
#endif #endif
} }
KRAudioBuffer *KRAudioSample::getBuffer(int index) KRAudioBuffer* KRAudioSample::getBuffer(int index)
{ {
openFile(); openFile();
@@ -375,10 +375,10 @@ KRAudioBuffer *KRAudioSample::getBuffer(int index)
int startFrame = index * maxFramesPerBuffer; int startFrame = index * maxFramesPerBuffer;
__uint32_t frameCount = (__uint32_t)KRMIN(m_totalFrames - startFrame, maxFramesPerBuffer); __uint32_t frameCount = (__uint32_t)KRMIN(m_totalFrames - startFrame, maxFramesPerBuffer);
KRAudioBuffer *buffer = new KRAudioBuffer(getContext().getAudioManager(), this, index, frameCount, m_frameRate, m_bytesPerFrame, PopulateBuffer); KRAudioBuffer* buffer = new KRAudioBuffer(getContext().getAudioManager(), this, index, frameCount, m_frameRate, m_bytesPerFrame, PopulateBuffer);
if(m_bufferCount == 1) { if (m_bufferCount == 1) {
// [self closeFile]; // We don't need to hold on to a file handle if not streaming // [self closeFile]; // We don't need to hold on to a file handle if not streaming
} }
return buffer; return buffer;
} }
@@ -387,7 +387,7 @@ void KRAudioSample::_endFrame()
{ {
const __int64_t AUDIO_SAMPLE_EXPIRY_FRAMES = 500; const __int64_t AUDIO_SAMPLE_EXPIRY_FRAMES = 500;
__int64_t current_frame = getContext().getAudioManager()->getAudioFrame(); __int64_t current_frame = getContext().getAudioManager()->getAudioFrame();
if(current_frame > m_last_frame_used + AUDIO_SAMPLE_EXPIRY_FRAMES) { if (current_frame > m_last_frame_used + AUDIO_SAMPLE_EXPIRY_FRAMES) {
closeFile(); closeFile();
} }
} }

33
kraken/KRAudioSample.h
View File

@@ -38,26 +38,27 @@
class KRAudioBuffer; class KRAudioBuffer;
class KRAudioSample : public KRResource { class KRAudioSample : public KRResource
{
public: public:
KRAudioSample(KRContext &context, std::string name, std::string extension); KRAudioSample(KRContext& context, std::string name, std::string extension);
KRAudioSample(KRContext &context, std::string name, std::string extension, KRDataBlock *data); KRAudioSample(KRContext& context, std::string name, std::string extension, KRDataBlock* data);
virtual ~KRAudioSample(); virtual ~KRAudioSample();
virtual std::string getExtension(); virtual std::string getExtension();
virtual bool save(KRDataBlock &data); virtual bool save(KRDataBlock& data);
float getDuration(); float getDuration();
KRAudioBuffer *getBuffer(int index); KRAudioBuffer* getBuffer(int index);
int getBufferCount(); int getBufferCount();
// Siren audio engine interface // Siren audio engine interface
int getChannelCount(); int getChannelCount();
__int64_t getFrameCount(); __int64_t getFrameCount();
float sample(int frame_offset, int frame_rate, int channel); float sample(int frame_offset, int frame_rate, int channel);
void sample(__int64_t frame_offset, int frame_count, int channel, float *buffer, float amplitude, bool loop); void sample(__int64_t frame_offset, int frame_count, int channel, float* buffer, float amplitude, bool loop);
void _endFrame(); void _endFrame();
private: private:
@@ -65,7 +66,7 @@ private:
__int64_t m_last_frame_used; __int64_t m_last_frame_used;
std::string m_extension; std::string m_extension;
KRDataBlock *m_pData; KRDataBlock* m_pData;
#ifdef __APPLE__ #ifdef __APPLE__
// Apple Audio Toolbox // Apple Audio Toolbox
@@ -73,25 +74,25 @@ private:
ExtAudioFileRef m_fileRef; ExtAudioFileRef m_fileRef;
static OSStatus ReadProc( // AudioFile_ReadProc static OSStatus ReadProc( // AudioFile_ReadProc
void * inClientData, void* inClientData,
SInt64 inPosition, SInt64 inPosition,
UInt32 requestCount, UInt32 requestCount,
void * buffer, void* buffer,
UInt32 * actualCount); UInt32* actualCount);
static OSStatus WriteProc( // AudioFile_WriteProc static OSStatus WriteProc( // AudioFile_WriteProc
void * inClientData, void* inClientData,
SInt64 inPosition, SInt64 inPosition,
UInt32 requestCount, UInt32 requestCount,
const void *buffer, const void* buffer,
UInt32 * actualCount); UInt32* actualCount);
static SInt64 GetSizeProc( // AudioFile_GetSizeProc static SInt64 GetSizeProc( // AudioFile_GetSizeProc
void * inClientData); void* inClientData);
static OSStatus SetSizeProc( // AudioFile_SetSizeProc static OSStatus SetSizeProc( // AudioFile_SetSizeProc
void * inClientData, void* inClientData,
SInt64 inSize); SInt64 inSize);
#endif #endif
@@ -106,5 +107,5 @@ private:
void closeFile(); void closeFile();
void loadInfo(); void loadInfo();
static void PopulateBuffer(KRAudioSample *sound, int index, void *data); static void PopulateBuffer(KRAudioSample* sound, int index, void* data);
}; };

83
kraken/KRAudioSource.cpp
View File

@@ -51,7 +51,7 @@ void KRAudioSource::InitNodeInfo(KrNodeInfo* nodeInfo)
nodeInfo->audio_source.sample = -1; nodeInfo->audio_source.sample = -1;
} }
KRAudioSource::KRAudioSource(KRScene &scene, std::string name) : KRNode(scene, name) KRAudioSource::KRAudioSource(KRScene& scene, std::string name) : KRNode(scene, name)
{ {
m_currentBufferFrame = 0; m_currentBufferFrame = 0;
m_playing = false; m_playing = false;
@@ -74,19 +74,20 @@ KRAudioSource::KRAudioSource(KRScene &scene, std::string name) : KRNode(scene, n
KRAudioSource::~KRAudioSource() KRAudioSource::~KRAudioSource()
{ {
while(m_audioBuffers.size()) { while (m_audioBuffers.size()) {
delete m_audioBuffers.front(); delete m_audioBuffers.front();
m_audioBuffers.pop(); m_audioBuffers.pop();
} }
} }
std::string KRAudioSource::getElementName() { std::string KRAudioSource::getElementName()
{
return "audio_source"; return "audio_source";
} }
tinyxml2::XMLElement *KRAudioSource::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRAudioSource::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
e->SetAttribute("sample", m_audio_sample_name.c_str()); e->SetAttribute("sample", m_audio_sample_name.c_str());
e->SetAttribute("gain", m_gain); e->SetAttribute("gain", m_gain);
e->SetAttribute("pitch", m_pitch); e->SetAttribute("pitch", m_pitch);
@@ -100,59 +101,59 @@ tinyxml2::XMLElement *KRAudioSource::saveXML( tinyxml2::XMLNode *parent)
return e; return e;
} }
void KRAudioSource::loadXML(tinyxml2::XMLElement *e) void KRAudioSource::loadXML(tinyxml2::XMLElement* e)
{ {
m_audio_sample_name = e->Attribute("sample"); m_audio_sample_name = e->Attribute("sample");
float gain = 1.0f; float gain = 1.0f;
if(e->QueryFloatAttribute("gain", &gain) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("gain", &gain) != tinyxml2::XML_SUCCESS) {
gain = 1.0f; gain = 1.0f;
} }
setGain(gain); setGain(gain);
float pitch = 1.0f; float pitch = 1.0f;
if(e->QueryFloatAttribute("pitch", &pitch) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("pitch", &pitch) != tinyxml2::XML_SUCCESS) {
pitch = 1.0f; pitch = 1.0f;
} }
setPitch(m_pitch); setPitch(m_pitch);
bool looping = false; bool looping = false;
if(e->QueryBoolAttribute("looping", &looping) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("looping", &looping) != tinyxml2::XML_SUCCESS) {
looping = false; looping = false;
} }
setLooping(looping); setLooping(looping);
bool is3d = true; bool is3d = true;
if(e->QueryBoolAttribute("is3d", &is3d) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("is3d", &is3d) != tinyxml2::XML_SUCCESS) {
is3d = true; is3d = true;
} }
setIs3D(is3d); setIs3D(is3d);
float reference_distance = 1.0f; float reference_distance = 1.0f;
if(e->QueryFloatAttribute("reference_distance", &reference_distance) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("reference_distance", &reference_distance) != tinyxml2::XML_SUCCESS) {
reference_distance = 1.0f; reference_distance = 1.0f;
} }
setReferenceDistance(reference_distance); setReferenceDistance(reference_distance);
float reverb = 0.0f; float reverb = 0.0f;
if(e->QueryFloatAttribute("reverb", &reverb) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("reverb", &reverb) != tinyxml2::XML_SUCCESS) {
reverb = 0.0f; reverb = 0.0f;
} }
setReverb(reverb); setReverb(reverb);
float rolloff_factor = 2.0f; float rolloff_factor = 2.0f;
if(e->QueryFloatAttribute("rolloff_factor", &rolloff_factor) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("rolloff_factor", &rolloff_factor) != tinyxml2::XML_SUCCESS) {
rolloff_factor = 2.0f; rolloff_factor = 2.0f;
} }
setRolloffFactor(rolloff_factor); setRolloffFactor(rolloff_factor);
m_enable_obstruction = true; m_enable_obstruction = true;
if(e->QueryBoolAttribute("enable_obstruction", &m_enable_obstruction) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("enable_obstruction", &m_enable_obstruction) != tinyxml2::XML_SUCCESS) {
m_enable_obstruction = true; m_enable_obstruction = true;
} }
m_enable_occlusion = true; m_enable_occlusion = true;
if(e->QueryBoolAttribute("enable_occlusion", &m_enable_occlusion) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("enable_occlusion", &m_enable_occlusion) != tinyxml2::XML_SUCCESS) {
m_enable_occlusion = true; m_enable_occlusion = true;
} }
@@ -161,14 +162,14 @@ void KRAudioSource::loadXML(tinyxml2::XMLElement *e)
void KRAudioSource::prime() void KRAudioSource::prime()
{ {
if(!m_isPrimed) { if (!m_isPrimed) {
if(m_audioFile == NULL && m_audio_sample_name.size() != 0) { if (m_audioFile == NULL && m_audio_sample_name.size() != 0) {
m_audioFile = getContext().getAudioManager()->get(m_audio_sample_name); m_audioFile = getContext().getAudioManager()->get(m_audio_sample_name);
} }
if(m_audioFile) { if (m_audioFile) {
// Prime the buffer queue // Prime the buffer queue
m_nextBufferIndex = 0; m_nextBufferIndex = 0;
for(int i=0; i < KRENGINE_AUDIO_BUFFERS_PER_SOURCE; i++) { for (int i = 0; i < KRENGINE_AUDIO_BUFFERS_PER_SOURCE; i++) {
queueBuffer(); queueBuffer();
} }
@@ -179,7 +180,7 @@ void KRAudioSource::prime()
void KRAudioSource::queueBuffer() void KRAudioSource::queueBuffer()
{ {
KRAudioBuffer *buffer = m_audioFile->getBuffer(m_nextBufferIndex); KRAudioBuffer* buffer = m_audioFile->getBuffer(m_nextBufferIndex);
m_audioBuffers.push(buffer); m_audioBuffers.push(buffer);
m_nextBufferIndex = (m_nextBufferIndex + 1) % m_audioFile->getBufferCount(); m_nextBufferIndex = (m_nextBufferIndex + 1) % m_audioFile->getBufferCount();
} }
@@ -187,13 +188,13 @@ void KRAudioSource::queueBuffer()
void KRAudioSource::render(RenderInfo& ri) void KRAudioSource::render(RenderInfo& ri)
{ {
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRNode::render(ri); KRNode::render(ri);
bool bVisualize = false; bool bVisualize = false;
if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) { if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere"); KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) { if (sphereModel) {
Matrix4 sphereModelMatrix = getModelMatrix(); Matrix4 sphereModelMatrix = getModelMatrix();
@@ -307,7 +308,7 @@ void KRAudioSource::setIs3D(bool is3D)
void KRAudioSource::advanceBuffer() void KRAudioSource::advanceBuffer()
{ {
if(m_audioBuffers.size()) { if (m_audioBuffers.size()) {
delete m_audioBuffers.front(); delete m_audioBuffers.front();
m_audioBuffers.pop(); m_audioBuffers.pop();
} }
@@ -318,7 +319,7 @@ void KRAudioSource::physicsUpdate(float deltaTime)
{ {
KRNode::physicsUpdate(deltaTime); KRNode::physicsUpdate(deltaTime);
KRAudioManager *audioManager = getContext().getAudioManager(); KRAudioManager* audioManager = getContext().getAudioManager();
audioManager->activateAudioSource(this); audioManager->activateAudioSource(this);
} }
@@ -328,8 +329,8 @@ void KRAudioSource::play()
// play() does not automatically seek to the beginning of the sample. Call setAudioFrame( 0 ) first if you wish the playback to begin at the start of the audio sample. // play() does not automatically seek to the beginning of the sample. Call setAudioFrame( 0 ) first if you wish the playback to begin at the start of the audio sample.
// If not set to looping, audio playback ends automatically at the end of the sample // If not set to looping, audio playback ends automatically at the end of the sample
if(!m_playing) { if (!m_playing) {
KRAudioManager *audioManager = getContext().getAudioManager(); KRAudioManager* audioManager = getContext().getAudioManager();
assert(m_start_audio_frame == -1); assert(m_start_audio_frame == -1);
m_start_audio_frame = audioManager->getAudioFrame() - m_paused_audio_frame; m_start_audio_frame = audioManager->getAudioFrame() - m_paused_audio_frame;
m_paused_audio_frame = -1; m_paused_audio_frame = -1;
@@ -343,7 +344,7 @@ void KRAudioSource::stop()
// Stop playback of audio. If audio is already stopped, this has no effect. // Stop playback of audio. If audio is already stopped, this has no effect.
// If play() is called afterwards, playback will continue at the current audio sample position. // If play() is called afterwards, playback will continue at the current audio sample position.
if(m_playing) { if (m_playing) {
m_paused_audio_frame = getAudioFrame(); m_paused_audio_frame = getAudioFrame();
m_start_audio_frame = -1; m_start_audio_frame = -1;
m_playing = false; m_playing = false;
@@ -359,7 +360,7 @@ bool KRAudioSource::isPlaying()
} }
void KRAudioSource::setSample(const std::string &sound_name) void KRAudioSource::setSample(const std::string& sound_name)
{ {
m_audio_sample_name = sound_name; m_audio_sample_name = sound_name;
} }
@@ -369,9 +370,9 @@ std::string KRAudioSource::getSample()
return m_audio_sample_name; return m_audio_sample_name;
} }
KRAudioSample *KRAudioSource::getAudioSample() KRAudioSample* KRAudioSource::getAudioSample()
{ {
if(m_audioFile == NULL && m_audio_sample_name.size() != 0) { if (m_audioFile == NULL && m_audio_sample_name.size() != 0) {
m_audioFile = getContext().getAudioManager()->get(m_audio_sample_name); m_audioFile = getContext().getAudioManager()->get(m_audio_sample_name);
} }
return m_audioFile; return m_audioFile;
@@ -381,22 +382,22 @@ void KRAudioSource::advanceFrames(int frame_count)
{ {
m_currentBufferFrame += frame_count; m_currentBufferFrame += frame_count;
KRAudioBuffer *buffer = getBuffer(); KRAudioBuffer* buffer = getBuffer();
while(buffer != NULL && m_currentBufferFrame >= buffer->getFrameCount()) { while (buffer != NULL && m_currentBufferFrame >= buffer->getFrameCount()) {
m_currentBufferFrame -= buffer->getFrameCount(); m_currentBufferFrame -= buffer->getFrameCount();
advanceBuffer(); advanceBuffer();
buffer = getBuffer(); buffer = getBuffer();
} }
if(buffer == NULL) { if (buffer == NULL) {
m_currentBufferFrame = 0; m_currentBufferFrame = 0;
stop(); stop();
} }
} }
KRAudioBuffer *KRAudioSource::getBuffer() KRAudioBuffer* KRAudioSource::getBuffer()
{ {
if(m_playing) { if (m_playing) {
prime(); prime();
return m_audioBuffers.front(); return m_audioBuffers.front();
} else { } else {
@@ -413,7 +414,7 @@ __int64_t KRAudioSource::getAudioFrame()
{ {
// Returns the audio playback position in units of integer audio frames. // Returns the audio playback position in units of integer audio frames.
if(m_playing) { if (m_playing) {
return getContext().getAudioManager()->getAudioFrame() - m_start_audio_frame; return getContext().getAudioManager()->getAudioFrame() - m_start_audio_frame;
} else { } else {
return m_paused_audio_frame; return m_paused_audio_frame;
@@ -423,7 +424,7 @@ __int64_t KRAudioSource::getAudioFrame()
void KRAudioSource::setAudioFrame(__int64_t next_frame) void KRAudioSource::setAudioFrame(__int64_t next_frame)
{ {
// Sets the audio playback position with units of integer audio frames. // Sets the audio playback position with units of integer audio frames.
if(m_playing) { if (m_playing) {
m_start_audio_frame = getContext().getAudioManager()->getAudioFrame() - next_frame; m_start_audio_frame = getContext().getAudioManager()->getAudioFrame() - next_frame;
} else { } else {
m_paused_audio_frame = next_frame; m_paused_audio_frame = next_frame;
@@ -444,13 +445,13 @@ void KRAudioSource::setAudioTime(float new_position)
setAudioFrame((__int64_t)(new_position * 44100.0f)); setAudioFrame((__int64_t)(new_position * 44100.0f));
} }
void KRAudioSource::sample(int frame_count, int channel, float *buffer, float gain) void KRAudioSource::sample(int frame_count, int channel, float* buffer, float gain)
{ {
KRAudioSample *source_sample = getAudioSample(); KRAudioSample* source_sample = getAudioSample();
if(source_sample && m_playing) { if (source_sample && m_playing) {
__int64_t next_frame = getAudioFrame(); __int64_t next_frame = getAudioFrame();
source_sample->sample(next_frame, frame_count, channel, buffer, gain, m_looping); source_sample->sample(next_frame, frame_count, channel, buffer, gain, m_looping);
if(!m_looping && next_frame > source_sample->getFrameCount()) { if (!m_looping && next_frame > source_sample->getFrameCount()) {
stop(); stop();
} }
} else { } else {

21
kraken/KRAudioSource.h
View File

@@ -39,15 +39,16 @@
class KRAudioSample; class KRAudioSample;
class KRAudioBuffer; class KRAudioBuffer;
class KRAudioSource : public KRNode { class KRAudioSource : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRAudioSource(KRScene &scene, std::string name); KRAudioSource(KRScene& scene, std::string name);
virtual ~KRAudioSource(); virtual ~KRAudioSource();
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
virtual void physicsUpdate(float deltaTime); virtual void physicsUpdate(float deltaTime);
void render(RenderInfo& ri); void render(RenderInfo& ri);
@@ -86,10 +87,10 @@ public:
// ---- End: Audio Playback Controls ---- // ---- End: Audio Playback Controls ----
void setSample(const std::string &sound_name); void setSample(const std::string& sound_name);
std::string getSample(); std::string getSample();
KRAudioSample *getAudioSample(); KRAudioSample* getAudioSample();
float getGain(); float getGain();
void setGain(float gain); void setGain(float gain);
@@ -121,10 +122,10 @@ public:
// ---- Siren Audio Engine Interface ---- // ---- Siren Audio Engine Interface ----
void advanceFrames(int frame_count); void advanceFrames(int frame_count);
KRAudioBuffer *getBuffer(); KRAudioBuffer* getBuffer();
int getBufferFrame(); int getBufferFrame();
void sample(int frame_count, int channel, float *buffer, float gain); void sample(int frame_count, int channel, float* buffer, float gain);
private: private:
__int64_t m_start_audio_frame; // Global audio frame that matches the start of the audio sample playback; when paused or not playing, this contains a value of -1 __int64_t m_start_audio_frame; // Global audio frame that matches the start of the audio sample playback; when paused or not playing, this contains a value of -1
@@ -134,12 +135,12 @@ private:
std::string m_audio_sample_name; std::string m_audio_sample_name;
KRAudioSample *m_audioFile; KRAudioSample* m_audioFile;
unsigned int m_sourceID; unsigned int m_sourceID;
float m_gain; float m_gain;
float m_pitch; float m_pitch;
bool m_looping; bool m_looping;
std::queue<KRAudioBuffer *> m_audioBuffers; std::queue<KRAudioBuffer*> m_audioBuffers;
int m_nextBufferIndex; int m_nextBufferIndex;
bool m_playing; bool m_playing;
bool m_is3d; bool m_is3d;

14
kraken/KRBehavior.cpp
View File

@@ -49,30 +49,30 @@ void KRBehavior::init()
// Note: Subclasses are not expected to call this method // Note: Subclasses are not expected to call this method
} }
KRNode *KRBehavior::getNode() const KRNode* KRBehavior::getNode() const
{ {
return __node; return __node;
} }
void KRBehavior::__setNode(KRNode *node) void KRBehavior::__setNode(KRNode* node)
{ {
__node = node; __node = node;
} }
KRBehavior *KRBehavior::LoadXML(KRNode *node, tinyxml2::XMLElement *e) KRBehavior* KRBehavior::LoadXML(KRNode* node, tinyxml2::XMLElement* e)
{ {
std::map<std::string, std::string> attributes; std::map<std::string, std::string> attributes;
for(const tinyxml2::XMLAttribute *attribute = e->FirstAttribute(); attribute != NULL; attribute = attribute->Next()) { for (const tinyxml2::XMLAttribute* attribute = e->FirstAttribute(); attribute != NULL; attribute = attribute->Next()) {
attributes[attribute->Name()] = attribute->Value(); attributes[attribute->Name()] = attribute->Value();
} }
const char *szElementName = e->Attribute("type"); const char* szElementName = e->Attribute("type");
if(szElementName == NULL) { if (szElementName == NULL) {
return NULL; return NULL;
} }
KRBehaviorFactoryFunctionMap::const_iterator itr = m_factoryFunctions.find(szElementName); KRBehaviorFactoryFunctionMap::const_iterator itr = m_factoryFunctions.find(szElementName);
if(itr == m_factoryFunctions.end()) { if (itr == m_factoryFunctions.end()) {
return NULL; return NULL;
} }
return (*itr->second)(attributes); return (*itr->second)(attributes);

10
kraken/KRBehavior.h
View File

@@ -46,7 +46,7 @@ namespace tinyxml2 {
class XMLElement; class XMLElement;
} // namespace tinyxml2 } // namespace tinyxml2
typedef KRBehavior *(*KRBehaviorFactoryFunction)(std::map<std::string, std::string> attributes); typedef KRBehavior* (*KRBehaviorFactoryFunction)(std::map<std::string, std::string> attributes);
typedef std::map<std::string, KRBehaviorFactoryFunction> KRBehaviorFactoryFunctionMap; typedef std::map<std::string, KRBehaviorFactoryFunction> KRBehaviorFactoryFunctionMap;
class KRBehavior class KRBehavior
@@ -57,14 +57,14 @@ public:
KRBehavior(); KRBehavior();
virtual ~KRBehavior(); virtual ~KRBehavior();
KRNode *getNode() const; KRNode* getNode() const;
virtual void init(); virtual void init();
virtual void update(float deltaTime) = 0; virtual void update(float deltaTime) = 0;
virtual void visibleUpdate(float deltatime) = 0; virtual void visibleUpdate(float deltatime) = 0;
void __setNode(KRNode *node); void __setNode(KRNode* node);
static KRBehavior *LoadXML(KRNode *node, tinyxml2::XMLElement *e); static KRBehavior* LoadXML(KRNode* node, tinyxml2::XMLElement* e);
private: private:
KRNode *__node; KRNode* __node;
}; };

27
kraken/KRBone.cpp
View File

@@ -39,45 +39,46 @@ void KRBone::InitNodeInfo(KrNodeInfo* nodeInfo)
// No additional members // No additional members
} }
KRBone::KRBone(KRScene &scene, std::string name) : KRNode(scene, name) KRBone::KRBone(KRScene& scene, std::string name) : KRNode(scene, name)
{ {
setScaleCompensation(true); setScaleCompensation(true);
} }
KRBone::~KRBone() KRBone::~KRBone()
{ {}
}
std::string KRBone::getElementName() { std::string KRBone::getElementName()
{
return "bone"; return "bone";
} }
tinyxml2::XMLElement *KRBone::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRBone::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
return e; return e;
} }
void KRBone::loadXML(tinyxml2::XMLElement *e) void KRBone::loadXML(tinyxml2::XMLElement* e)
{ {
KRNode::loadXML(e); KRNode::loadXML(e);
setScaleCompensation(true); setScaleCompensation(true);
} }
AABB KRBone::getBounds() { AABB KRBone::getBounds()
{
return AABB::Create(-Vector3::One(), Vector3::One(), getModelMatrix()); // Only required for bone debug visualization return AABB::Create(-Vector3::One(), Vector3::One(), getModelMatrix()); // Only required for bone debug visualization
} }
void KRBone::render(RenderInfo& ri) void KRBone::render(RenderInfo& ri)
{ {
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRNode::render(ri); KRNode::render(ri);
bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_BONES; bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_BONES;
if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) { if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere"); KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) { if (sphereModel) {
Matrix4 sphereModelMatrix = getModelMatrix(); Matrix4 sphereModelMatrix = getModelMatrix();
@@ -94,7 +95,7 @@ void KRBone::render(RenderInfo& ri)
info.modelFormat = sphereModel->getModelFormat(); info.modelFormat = sphereModel->getModelFormat();
info.vertexAttributes = sphereModel->getVertexAttributes(); info.vertexAttributes = sphereModel->getVertexAttributes();
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, sphereModelMatrix, &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, sphereModelMatrix, &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);
sphereModel->renderNoMaterials(ri.commandBuffer, ri.renderPass, getName(), "visualize_overlay", 1.0f); sphereModel->renderNoMaterials(ri.commandBuffer, ri.renderPass, getName(), "visualize_overlay", 1.0f);
@@ -103,11 +104,11 @@ void KRBone::render(RenderInfo& ri)
} }
void KRBone::setBindPose(const Matrix4 &pose) void KRBone::setBindPose(const Matrix4& pose)
{ {
m_bind_pose = pose; m_bind_pose = pose;
} }
const Matrix4 &KRBone::getBindPose() const Matrix4& KRBone::getBindPose()
{ {
return m_bind_pose; return m_bind_pose;
} }

13
kraken/KRBone.h
View File

@@ -37,21 +37,22 @@
class RenderInfo; class RenderInfo;
class KRBone : public KRNode { class KRBone : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRBone(KRScene &scene, std::string name); KRBone(KRScene& scene, std::string name);
virtual ~KRBone(); virtual ~KRBone();
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
virtual AABB getBounds(); virtual AABB getBounds();
void render(RenderInfo& ri); void render(RenderInfo& ri);
void setBindPose(const Matrix4 &pose); void setBindPose(const Matrix4& pose);
const Matrix4 &getBindPose(); const Matrix4& getBindPose();
private: private:
Matrix4 m_bind_pose; Matrix4 m_bind_pose;
}; };

31
kraken/KRBundle.cpp
View File

@@ -49,26 +49,26 @@ typedef struct _tar_header
} tar_header_type; } tar_header_type;
KRBundle::KRBundle(KRContext &context, std::string name, KRDataBlock *pData) : KRResource(context, name) KRBundle::KRBundle(KRContext& context, std::string name, KRDataBlock* pData) : KRResource(context, name)
{ {
m_pData = pData; m_pData = pData;
__int64_t file_pos = 0; __int64_t file_pos = 0;
while(file_pos < (__int64_t)m_pData->getSize()) { while (file_pos < (__int64_t)m_pData->getSize()) {
tar_header_type file_header; tar_header_type file_header;
m_pData->copy(&file_header, (int)file_pos, sizeof(file_header)); m_pData->copy(&file_header, (int)file_pos, sizeof(file_header));
size_t file_size = strtol(file_header.file_size, NULL, 8); size_t file_size = strtol(file_header.file_size, NULL, 8);
file_pos += 512; // Skip past the header to the file contents file_pos += 512; // Skip past the header to the file contents
if(file_header.file_name[0] != '\0' && file_header.file_name[0] != '.') { if (file_header.file_name[0] != '\0' && file_header.file_name[0] != '.') {
// We ignore the last two records in the tar file, which are zero'ed out tar_header structures // We ignore the last two records in the tar file, which are zero'ed out tar_header structures
KRDataBlock *pFileData = pData->getSubBlock((int)file_pos, (int)file_size); KRDataBlock* pFileData = pData->getSubBlock((int)file_pos, (int)file_size);
context.loadResource(file_header.file_name, pFileData); context.loadResource(file_header.file_name, pFileData);
} }
file_pos += RoundUpSize(file_size); file_pos += RoundUpSize(file_size);
} }
} }
KRBundle::KRBundle(KRContext &context, std::string name) : KRResource(context, name) KRBundle::KRBundle(KRContext& context, std::string name) : KRResource(context, name)
{ {
// Create an empty krbundle (tar) file, initialized with two zero-ed out file headers, which terminate it. // Create an empty krbundle (tar) file, initialized with two zero-ed out file headers, which terminate it.
m_pData = new KRDataBlock(); m_pData = new KRDataBlock();
@@ -81,7 +81,7 @@ KRBundle::KRBundle(KRContext &context, std::string name) : KRResource(context, n
size_t KRBundle::RoundUpSize(size_t s) size_t KRBundle::RoundUpSize(size_t s)
{ {
// Get amount of padding needed to increase s to a 512 byte alignment // Get amount of padding needed to increase s to a 512 byte alignment
if((s & 0x01ff) == 0) { if ((s & 0x01ff) == 0) {
// file size is a multiple of 512 bytes, we can just add it // file size is a multiple of 512 bytes, we can just add it
return s; return s;
} else { } else {
@@ -106,15 +106,16 @@ bool KRBundle::save(const std::string& path)
return m_pData->save(path); return m_pData->save(path);
} }
bool KRBundle::save(KRDataBlock &data) { bool KRBundle::save(KRDataBlock& data)
if(m_pData->getSize() > KRENGINE_KRBUNDLE_HEADER_SIZE * 2) { {
if (m_pData->getSize() > KRENGINE_KRBUNDLE_HEADER_SIZE * 2) {
// Only output krbundles that contain files // Only output krbundles that contain files
data.append(*m_pData); data.append(*m_pData);
} }
return true; return true;
} }
KRDataBlock* KRBundle::append(KRResource &resource) KRDataBlock* KRBundle::append(KRResource& resource)
{ {
// Serialize resource to binary representation // Serialize resource to binary representation
KRDataBlock resource_data; KRDataBlock resource_data;
@@ -130,18 +131,18 @@ KRDataBlock* KRBundle::append(KRResource &resource)
m_pData->lock(); m_pData->lock();
// Get location of file header // Get location of file header
tar_header_type *file_header = (tar_header_type *)((unsigned char *)m_pData->getEnd() - padding_size - resource_data.getSize() - KRENGINE_KRBUNDLE_HEADER_SIZE); tar_header_type* file_header = (tar_header_type*)((unsigned char*)m_pData->getEnd() - padding_size - resource_data.getSize() - KRENGINE_KRBUNDLE_HEADER_SIZE);
// Zero out new file header // Zero out new file header
memset(file_header, 0, KRENGINE_KRBUNDLE_HEADER_SIZE); memset(file_header, 0, KRENGINE_KRBUNDLE_HEADER_SIZE);
// Copy resource data // Copy resource data
resource_data.lock(); resource_data.lock();
memcpy((unsigned char *)m_pData->getEnd() - padding_size - resource_data.getSize(), resource_data.getStart(), resource_data.getSize()); memcpy((unsigned char*)m_pData->getEnd() - padding_size - resource_data.getSize(), resource_data.getStart(), resource_data.getSize());
resource_data.unlock(); resource_data.unlock();
// Zero out alignment padding and terminating set of file header blocks // Zero out alignment padding and terminating set of file header blocks
memset((unsigned char *)m_pData->getEnd() - padding_size, 0, padding_size); memset((unsigned char*)m_pData->getEnd() - padding_size, 0, padding_size);
// Populate new file header fields // Populate new file header fields
strncpy(file_header->file_name, file_name.c_str(), 100); strncpy(file_header->file_name, file_name.c_str(), 100);
@@ -156,14 +157,14 @@ KRDataBlock* KRBundle::append(KRResource &resource)
// Calculate and write checksum for header // Calculate and write checksum for header
memset(file_header->checksum, ' ', 8); // Must be filled with spaces and no null terminator during checksum calculation memset(file_header->checksum, ' ', 8); // Must be filled with spaces and no null terminator during checksum calculation
int check_sum = 0; int check_sum = 0;
for(int i=0; i < KRENGINE_KRBUNDLE_HEADER_SIZE; i++) { for (int i = 0; i < KRENGINE_KRBUNDLE_HEADER_SIZE; i++) {
unsigned char *byte_ptr = (unsigned char *)file_header; unsigned char* byte_ptr = (unsigned char*)file_header;
check_sum += byte_ptr[i]; check_sum += byte_ptr[i];
} }
sprintf(file_header->checksum, "%07o", check_sum); sprintf(file_header->checksum, "%07o", check_sum);
m_pData->unlock(); m_pData->unlock();
KRDataBlock *pFileData = m_pData->getSubBlock((int)resource_data_start, (int)resource_data.getSize()); KRDataBlock* pFileData = m_pData->getSubBlock((int)resource_data_start, (int)resource_data.getSize());
return pFileData; return pFileData;
} }

13
kraken/KRBundle.h
View File

@@ -34,18 +34,19 @@
#include "KRResource.h" #include "KRResource.h"
#include "KRDataBlock.h" #include "KRDataBlock.h"
class KRBundle : public KRResource { class KRBundle : public KRResource
{
public: public:
KRBundle(KRContext &context, std::string name, KRDataBlock *pData); KRBundle(KRContext& context, std::string name, KRDataBlock* pData);
KRBundle(KRContext &context, std::string name); KRBundle(KRContext& context, std::string name);
virtual ~KRBundle(); virtual ~KRBundle();
virtual std::string getExtension(); virtual std::string getExtension();
virtual bool save(const std::string& path); virtual bool save(const std::string& path);
virtual bool save(KRDataBlock &data); virtual bool save(KRDataBlock& data);
KRDataBlock* append(KRResource &resource); KRDataBlock* append(KRResource& resource);
private: private:
KRDataBlock *m_pData; KRDataBlock* m_pData;
static size_t RoundUpSize(size_t s); static size_t RoundUpSize(size_t s);
}; };

24
kraken/KRBundleManager.cpp
View File

@@ -33,12 +33,14 @@
#include "KRBundle.h" #include "KRBundle.h"
KRBundleManager::KRBundleManager(KRContext &context) : KRResourceManager(context) { KRBundleManager::KRBundleManager(KRContext& context) : KRResourceManager(context)
{
} }
KRBundleManager::~KRBundleManager() { KRBundleManager::~KRBundleManager()
for(unordered_map<std::string, KRBundle *>::iterator itr = m_bundles.begin(); itr != m_bundles.end(); ++itr){ {
for (unordered_map<std::string, KRBundle*>::iterator itr = m_bundles.begin(); itr != m_bundles.end(); ++itr) {
delete (*itr).second; delete (*itr).second;
} }
m_bundles.clear(); m_bundles.clear();
@@ -47,7 +49,7 @@ KRBundleManager::~KRBundleManager() {
KRResource* KRBundleManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) KRResource* KRBundleManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data)
{ {
if (extension.compare("krbundle") == 0) { if (extension.compare("krbundle") == 0) {
return loadBundle(name.c_str() , data); return loadBundle(name.c_str(), data);
} }
return nullptr; return nullptr;
} }
@@ -59,25 +61,27 @@ KRResource* KRBundleManager::getResource(const std::string& name, const std::str
return nullptr; return nullptr;
} }
KRBundle *KRBundleManager::loadBundle(const char *szName, KRDataBlock *pData) KRBundle* KRBundleManager::loadBundle(const char* szName, KRDataBlock* pData)
{ {
KRBundle *pBundle = new KRBundle(*m_pContext, szName, pData); KRBundle* pBundle = new KRBundle(*m_pContext, szName, pData);
m_bundles[szName] = pBundle; m_bundles[szName] = pBundle;
return pBundle; return pBundle;
} }
KRBundle *KRBundleManager::createBundle(const char *szName) KRBundle* KRBundleManager::createBundle(const char* szName)
{ {
// TODO: Check for name conflicts // TODO: Check for name conflicts
KRBundle *pBundle = new KRBundle(*m_pContext, szName); KRBundle* pBundle = new KRBundle(*m_pContext, szName);
m_bundles[szName] = pBundle; m_bundles[szName] = pBundle;
return pBundle; return pBundle;
} }
KRBundle *KRBundleManager::getBundle(const char *szName) { KRBundle* KRBundleManager::getBundle(const char* szName)
{
return m_bundles[szName]; return m_bundles[szName];
} }
unordered_map<std::string, KRBundle *> KRBundleManager::getBundles() { unordered_map<std::string, KRBundle*> KRBundleManager::getBundles()
{
return m_bundles; return m_bundles;
} }

13
kraken/KRBundleManager.h
View File

@@ -40,21 +40,22 @@
class KRContext; class KRContext;
class KRBundle; class KRBundle;
class KRBundleManager : public KRResourceManager { class KRBundleManager : public KRResourceManager
{
public: public:
KRBundleManager(KRContext &context); KRBundleManager(KRContext& context);
~KRBundleManager(); ~KRBundleManager();
virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
virtual KRResource* getResource(const std::string& name, const std::string& extension) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
KRBundle *loadBundle(const char *szName, KRDataBlock *pData); KRBundle* loadBundle(const char* szName, KRDataBlock* pData);
KRBundle *getBundle(const char *szName); KRBundle* getBundle(const char* szName);
KRBundle* createBundle(const char* szName); KRBundle* createBundle(const char* szName);
std::vector<std::string> getBundleNames(); std::vector<std::string> getBundleNames();
unordered_map<std::string, KRBundle *> getBundles(); unordered_map<std::string, KRBundle*> getBundles();
private: private:
unordered_map<std::string, KRBundle *> m_bundles; unordered_map<std::string, KRBundle*> m_bundles;
}; };

170
kraken/KRCamera.cpp
View File

@@ -42,7 +42,8 @@ void KRCamera::InitNodeInfo(KrNodeInfo* nodeInfo)
nodeInfo->camera.skybox_texture = -1; nodeInfo->camera.skybox_texture = -1;
} }
KRCamera::KRCamera(KRScene &scene, std::string name) : KRNode(scene, name) { KRCamera::KRCamera(KRScene& scene, std::string name) : KRNode(scene, name)
{
m_last_frame_start = 0; m_last_frame_start = 0;
m_particlesAbsoluteTime = 0.0f; m_particlesAbsoluteTime = 0.0f;
@@ -70,31 +71,33 @@ KRCamera::KRCamera(KRScene &scene, std::string name) : KRNode(scene, name) {
); );
} }
KRCamera::~KRCamera() { KRCamera::~KRCamera()
{
destroyBuffers(); destroyBuffers();
} }
std::string KRCamera::getElementName() { std::string KRCamera::getElementName()
{
return "camera"; return "camera";
} }
tinyxml2::XMLElement *KRCamera::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRCamera::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
e->SetAttribute("skybox", m_skyBox.c_str()); e->SetAttribute("skybox", m_skyBox.c_str());
return e; return e;
} }
void KRCamera::loadXML(tinyxml2::XMLElement *e) void KRCamera::loadXML(tinyxml2::XMLElement* e)
{ {
KRNode::loadXML(e); KRNode::loadXML(e);
const char *szSkyBoxName = e->Attribute("skybox"); const char* szSkyBoxName = e->Attribute("skybox");
m_skyBox = szSkyBoxName ? szSkyBoxName : ""; m_skyBox = szSkyBoxName ? szSkyBoxName : "";
} }
void KRCamera::setSkyBox(const std::string &skyBox) void KRCamera::setSkyBox(const std::string& skyBox)
{ {
m_pSkyBoxTexture = NULL; m_pSkyBoxTexture = NULL;
m_skyBox = skyBox; m_skyBox = skyBox;
@@ -110,15 +113,15 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
{ {
// ----====---- Record timing information for measuring FPS ----====---- // ----====---- Record timing information for measuring FPS ----====----
uint64_t current_time = m_pContext->getAbsoluteTimeMilliseconds(); uint64_t current_time = m_pContext->getAbsoluteTimeMilliseconds();
if(m_last_frame_start != 0) { if (m_last_frame_start != 0) {
m_frame_times[m_pContext->getCurrentFrame() % KRAKEN_FPS_AVERAGE_FRAME_COUNT] = (int)(current_time - m_last_frame_start); m_frame_times[m_pContext->getCurrentFrame() % KRAKEN_FPS_AVERAGE_FRAME_COUNT] = (int)(current_time - m_last_frame_start);
if(m_frame_times_filled < KRAKEN_FPS_AVERAGE_FRAME_COUNT) m_frame_times_filled++; if (m_frame_times_filled < KRAKEN_FPS_AVERAGE_FRAME_COUNT) m_frame_times_filled++;
} }
m_last_frame_start = current_time; m_last_frame_start = current_time;
createBuffers(compositeSurface.getWidth(), compositeSurface.getHeight()); createBuffers(compositeSurface.getWidth(), compositeSurface.getHeight());
KRScene &scene = getScene(); KRScene& scene = getScene();
Matrix4 modelMatrix = getModelMatrix(); Matrix4 modelMatrix = getModelMatrix();
Matrix4 viewMatrix = Matrix4::LookAt(Matrix4::Dot(modelMatrix, Vector3::Zero()), Matrix4::Dot(modelMatrix, Vector3::Forward()), Vector3::Normalize(Matrix4::DotNoTranslate(modelMatrix, Vector3::Up()))); Matrix4 viewMatrix = Matrix4::LookAt(Matrix4::Dot(modelMatrix, Vector3::Zero()), Matrix4::Dot(modelMatrix, Vector3::Forward()), Vector3::Normalize(Matrix4::DotNoTranslate(modelMatrix, Vector3::Up())));
@@ -140,7 +143,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_PRESTREAM, true); scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_PRESTREAM, true);
// ----====---- Generate Shadowmaps for Lights ----====---- // ----====---- Generate Shadowmaps for Lights ----====----
if(settings.m_cShadowBuffers > 0) { if (settings.m_cShadowBuffers > 0) {
GL_PUSH_GROUP_MARKER("Generate Shadowmaps"); GL_PUSH_GROUP_MARKER("Generate Shadowmaps");
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_GENERATE_SHADOWMAPS, false /*settings.bEnableDeferredLighting*/); scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_GENERATE_SHADOWMAPS, false /*settings.bEnableDeferredLighting*/);
@@ -148,7 +151,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_POP_GROUP_MARKER; GL_POP_GROUP_MARKER;
} }
if(settings.bEnableDeferredLighting) { if (settings.bEnableDeferredLighting) {
// ----====---- Opaque Geometry, Deferred rendering Pass 1 ----====---- // ----====---- Opaque Geometry, Deferred rendering Pass 1 ----====----
@@ -251,11 +254,11 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Sky Box"); GL_PUSH_GROUP_MARKER("Sky Box");
if(!m_pSkyBoxTexture && m_skyBox.length()) { if (!m_pSkyBoxTexture && m_skyBox.length()) {
m_pSkyBoxTexture = getContext().getTextureManager()->getTextureCube(m_skyBox.c_str()); m_pSkyBoxTexture = getContext().getTextureManager()->getTextureCube(m_skyBox.c_str());
} }
if(m_pSkyBoxTexture) { if (m_pSkyBoxTexture) {
std::string shader_name("sky_box"); std::string shader_name("sky_box");
PipelineInfo info{}; PipelineInfo info{};
@@ -307,13 +310,13 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
// ----====---- Volumetric Lighting ----====---- // ----====---- Volumetric Lighting ----====----
if(settings.volumetric_environment_enable) { if (settings.volumetric_environment_enable) {
GL_PUSH_GROUP_MARKER("Volumetric Lighting"); GL_PUSH_GROUP_MARKER("Volumetric Lighting");
KRViewport volumetricLightingViewport = KRViewport(Vector2::Create((float)volumetricBufferWidth, (float)volumetricBufferHeight), m_viewport.getViewMatrix(), m_viewport.getProjectionMatrix()); KRViewport volumetricLightingViewport = KRViewport(Vector2::Create((float)volumetricBufferWidth, (float)volumetricBufferHeight), m_viewport.getViewMatrix(), m_viewport.getProjectionMatrix());
if(settings.volumetric_environment_downsample != 0) { if (settings.volumetric_environment_downsample != 0) {
// Set render target // Set render target
GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, volumetricLightAccumulationBuffer)); GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, volumetricLightAccumulationBuffer));
GLDEBUG(glClearColor(0.0f, 0.0f, 0.0f, 0.0f)); GLDEBUG(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
@@ -342,7 +345,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Debug Overlays"); GL_PUSH_GROUP_MARKER("Debug Overlays");
if(settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_OCTREE) { if (settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_OCTREE) {
KRMeshManager::KRVBOData& vertices = getContext().getMeshManager()->KRENGINE_VBO_DATA_3D_CUBE_VERTICES; KRMeshManager::KRVBOData& vertices = getContext().getMeshManager()->KRENGINE_VBO_DATA_3D_CUBE_VERTICES;
PipelineInfo info{}; PipelineInfo info{};
@@ -353,10 +356,10 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
info.rasterMode = RasterMode::kAdditive; info.rasterMode = RasterMode::kAdditive;
info.vertexAttributes = vertices.getVertexAttributes(); info.vertexAttributes = vertices.getVertexAttributes();
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
KRPipeline *pVisShader = getContext().getPipelineManager()->getPipeline(compositeSurface, info); KRPipeline* pVisShader = getContext().getPipelineManager()->getPipeline(compositeSurface, info);
m_pContext->getMeshManager()->bindVBO(commandBuffer, &vertices, 1.0f); m_pContext->getMeshManager()->bindVBO(commandBuffer, &vertices, 1.0f);
for(unordered_map<AABB, int>::iterator itr=m_viewport.getVisibleBounds().begin(); itr != m_viewport.getVisibleBounds().end(); itr++) { for (unordered_map<AABB, int>::iterator itr = m_viewport.getVisibleBounds().begin(); itr != m_viewport.getVisibleBounds().end(); itr++) {
Matrix4 matModel = Matrix4(); Matrix4 matModel = Matrix4();
matModel.scale((*itr).first.size() * 0.5f); matModel.scale((*itr).first.size() * 0.5f);
matModel.translate((*itr).first.center()); matModel.translate((*itr).first.center());
@@ -366,7 +369,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
} }
GL_POP_GROUP_MARKER; GL_POP_GROUP_MARKER;
// fprintf(stderr, "VBO Mem: %i Kbyte Texture Mem: %i/%i Kbyte (active/total) Shader Handles: %i Visible Bounds: %i Max Texture LOD: %i\n", (int)m_pContext->getMeshManager()->getMemUsed() / 1024, (int)m_pContext->getTextureManager()->getActiveMemUsed() / 1024, (int)m_pContext->getTextureManager()->getMemUsed() / 1024, (int)m_pContext->getPipelineManager()->getShaderHandlesUsed(), (int)m_visibleBounds.size(), m_pContext->getTextureManager()->getLODDimCap()); // fprintf(stderr, "VBO Mem: %i Kbyte Texture Mem: %i/%i Kbyte (active/total) Shader Handles: %i Visible Bounds: %i Max Texture LOD: %i\n", (int)m_pContext->getMeshManager()->getMemUsed() / 1024, (int)m_pContext->getTextureManager()->getActiveMemUsed() / 1024, (int)m_pContext->getTextureManager()->getMemUsed() / 1024, (int)m_pContext->getPipelineManager()->getShaderHandlesUsed(), (int)m_visibleBounds.size(), m_pContext->getTextureManager()->getLODDimCap());
GL_PUSH_GROUP_MARKER("Post Processing"); GL_PUSH_GROUP_MARKER("Post Processing");
@@ -376,7 +379,8 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
} }
void KRCamera::createBuffers(GLint renderBufferWidth, GLint renderBufferHeight) { void KRCamera::createBuffers(GLint renderBufferWidth, GLint renderBufferHeight)
{
// TODO - Vulkan Refactoring.. // TODO - Vulkan Refactoring..
/* /*
if(renderBufferWidth != m_backingWidth || renderBufferHeight != m_backingHeight) { if(renderBufferWidth != m_backingWidth || renderBufferHeight != m_backingHeight) {
@@ -567,37 +571,37 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
*/ */
// if(bShowShadowBuffer) { // if(bShowShadowBuffer) {
// KRPipeline *blitShader = m_pContext->getPipelineManager()->getShader("simple_blit", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); // KRPipeline *blitShader = m_pContext->getPipelineManager()->getShader("simple_blit", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
// //
// for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) { // for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) {
// Matrix4 viewMatrix = Matrix4(); // Matrix4 viewMatrix = Matrix4();
// viewMatrix.scale(0.20, 0.20, 0.20); // viewMatrix.scale(0.20, 0.20, 0.20);
// viewMatrix.translate(-0.70, 0.70 - 0.45 * iShadow, 0.0); // viewMatrix.translate(-0.70, 0.70 - 0.45 * iShadow, 0.0);
// getContext().getPipelineManager()->selectShader(blitShader, KRViewport(getViewportSize(), viewMatrix, Matrix4()), shadowViewports, Matrix4(), Vector3(), NULL, 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); // getContext().getPipelineManager()->selectShader(blitShader, KRViewport(getViewportSize(), viewMatrix, Matrix4()), shadowViewports, Matrix4(), Vector3(), NULL, 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
// m_pContext->getTextureManager()->selectTexture(1, NULL); // m_pContext->getTextureManager()->selectTexture(1, NULL);
// m_pContext->getMeshManager()->bindVBO(&getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES); // m_pContext->getMeshManager()->bindVBO(&getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES);
// m_pContext->getTextureManager()->_setActiveTexture(0); // m_pContext->getTextureManager()->_setActiveTexture(0);
// GLDEBUG(glBindTexture(GL_TEXTURE_2D, shadowDepthTexture[iShadow])); // GLDEBUG(glBindTexture(GL_TEXTURE_2D, shadowDepthTexture[iShadow]));
//#if GL_EXT_shadow_samplers //#if GL_EXT_shadow_samplers
// GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_EXT, GL_NONE)); // TODO - Detect GL_EXT_shadow_samplers and only activate if available // GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_EXT, GL_NONE)); // TODO - Detect GL_EXT_shadow_samplers and only activate if available
//#endif //#endif
// GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); // GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
//#if GL_EXT_shadow_samplers //#if GL_EXT_shadow_samplers
// GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_EXT, GL_COMPARE_REF_TO_TEXTURE_EXT)); // TODO - Detect GL_EXT_shadow_samplers and only activate if available // GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_EXT, GL_COMPARE_REF_TO_TEXTURE_EXT)); // TODO - Detect GL_EXT_shadow_samplers and only activate if available
//#endif //#endif
// } // }
// //
// m_pContext->getTextureManager()->selectTexture(0, NULL); // m_pContext->getTextureManager()->selectTexture(0, NULL);
// m_pContext->getTextureManager()->_setActiveTexture(0); // m_pContext->getTextureManager()->_setActiveTexture(0);
// GLDEBUG(glBindTexture(GL_TEXTURE_2D, 0)); // GLDEBUG(glBindTexture(GL_TEXTURE_2D, 0));
// } // }
const char *szText = settings.m_debug_text.c_str(); const char* szText = settings.m_debug_text.c_str();
std::string debug_text; std::string debug_text;
if(settings.debug_display != KRRenderSettings::KRENGINE_DEBUG_DISPLAY_NONE) { if (settings.debug_display != KRRenderSettings::KRENGINE_DEBUG_DISPLAY_NONE) {
debug_text = getDebugText();; debug_text = getDebugText();;
if(debug_text.length() > 0) { if (debug_text.length() > 0) {
szText = debug_text.c_str(); szText = debug_text.c_str();
} }
} }
@@ -605,31 +609,31 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
// TODO - Test code for Vulkan conversion, remove once texture streaming working // TODO - Test code for Vulkan conversion, remove once texture streaming working
szText = "Hello, earthlings!"; szText = "Hello, earthlings!";
if(*szText) { if (*szText) {
int row_count = 1; int row_count = 1;
const int MAX_TABS = 5; const int MAX_TABS = 5;
const int TAB_EXTRA = 2; const int TAB_EXTRA = 2;
int tab_cols[MAX_TABS] = {0, 0, 0, 0, 0}; int tab_cols[MAX_TABS] = { 0, 0, 0, 0, 0 };
int iCol = 0; int iCol = 0;
int iTab = 0; int iTab = 0;
const char *pChar = szText; const char* pChar = szText;
while(*pChar) { while (*pChar) {
char c = *pChar++; char c = *pChar++;
if(c == '\n') { if (c == '\n') {
row_count++; row_count++;
iCol = 0; iCol = 0;
iTab = 0; iTab = 0;
} else if(c == '\t') { } else if (c == '\t') {
iCol = 0; iCol = 0;
iTab++; iTab++;
} else { } else {
iCol++; iCol++;
if(iCol > tab_cols[iTab]) tab_cols[iTab] = iCol; if (iCol > tab_cols[iTab]) tab_cols[iTab] = iCol;
} }
} }
iCol = 0; iCol = 0;
for(iTab=0; iTab < MAX_TABS; iTab++) { for (iTab = 0; iTab < MAX_TABS; iTab++) {
iCol += tab_cols[iTab] + TAB_EXTRA; iCol += tab_cols[iTab] + TAB_EXTRA;
tab_cols[iTab] = iCol; tab_cols[iTab] = iCol;
} }
@@ -637,29 +641,29 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
const int DEBUG_TEXT_COLUMNS = 256; const int DEBUG_TEXT_COLUMNS = 256;
const int DEBUG_TEXT_ROWS = 128; const int DEBUG_TEXT_ROWS = 128;
if(m_debug_text_vertices.getSize() == 0) { if (m_debug_text_vertices.getSize() == 0) {
m_debug_text_vertices.expand(sizeof(DebugTextVertexData) * DEBUG_TEXT_COLUMNS * DEBUG_TEXT_ROWS * 6); m_debug_text_vertices.expand(sizeof(DebugTextVertexData) * DEBUG_TEXT_COLUMNS * DEBUG_TEXT_ROWS * 6);
} }
int vertex_count = 0; int vertex_count = 0;
m_debug_text_vertices.lock(); m_debug_text_vertices.lock();
DebugTextVertexData *vertex_data = (DebugTextVertexData *)m_debug_text_vertices.getStart(); DebugTextVertexData* vertex_data = (DebugTextVertexData*)m_debug_text_vertices.getStart();
pChar = szText; pChar = szText;
float dScaleX = 2.0f / (1024.0f / 16.0f); float dScaleX = 2.0f / (1024.0f / 16.0f);
float dScaleY = 2.0f / (768.0f / 16.0f); float dScaleY = 2.0f / (768.0f / 16.0f);
float dTexScale = 1.0f / 16.0f; float dTexScale = 1.0f / 16.0f;
int iRow = row_count - 1; iCol = 0; iTab = 0; int iRow = row_count - 1; iCol = 0; iTab = 0;
while(*pChar) { while (*pChar) {
char c = *pChar++; char c = *pChar++;
if(c == '\n') { if (c == '\n') {
iCol = 0; iCol = 0;
iTab = 0; iTab = 0;
iRow--; iRow--;
} else if(c == '\t') { } else if (c == '\t') {
iCol = tab_cols[iTab++]; iCol = tab_cols[iTab++];
} else { } else {
if(iCol < DEBUG_TEXT_COLUMNS && iRow < DEBUG_TEXT_ROWS) { if (iCol < DEBUG_TEXT_COLUMNS && iRow < DEBUG_TEXT_ROWS) {
int iChar = c - '\0'; int iChar = c - '\0';
int iTexCol = iChar % 16; int iTexCol = iChar % 16;
int iTexRow = 15 - (iChar - iTexCol) / 16; int iTexRow = 15 - (iChar - iTexCol) / 16;
@@ -728,7 +732,7 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
info.cullMode = CullMode::kCullNone; info.cullMode = CullMode::kCullNone;
info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA); info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA);
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline *fontShader = m_pContext->getPipelineManager()->getPipeline(surface, info); KRPipeline* fontShader = m_pContext->getPipelineManager()->getPipeline(surface, info);
fontShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); fontShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
m_pContext->getTextureManager()->selectTexture(0, m_pContext->getTextureManager()->getTexture("font"), 0.0f, KRTexture::TEXTURE_USAGE_UI); m_pContext->getTextureManager()->selectTexture(0, m_pContext->getTextureManager()->getTexture("font"), 0.0f, KRTexture::TEXTURE_USAGE_UI);
@@ -741,7 +745,7 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
m_debug_text_vertices.unlock(); m_debug_text_vertices.unlock();
} else { } else {
if(m_debug_text_vertices.getSize() > 0) { if (m_debug_text_vertices.getSize() > 0) {
m_debug_text_vertices = KRDataBlock(); m_debug_text_vertices = KRDataBlock();
} }
} }
@@ -756,20 +760,20 @@ std::string KRCamera::getDebugText()
uint64_t fps = 0; uint64_t fps = 0;
if(m_frame_times_filled == KRAKEN_FPS_AVERAGE_FRAME_COUNT) { if (m_frame_times_filled == KRAKEN_FPS_AVERAGE_FRAME_COUNT) {
for(int i=0; i < KRAKEN_FPS_AVERAGE_FRAME_COUNT; i++) { for (int i = 0; i < KRAKEN_FPS_AVERAGE_FRAME_COUNT; i++) {
fps += m_frame_times[i]; fps += m_frame_times[i];
} }
fps = 1000000 / (fps / KRAKEN_FPS_AVERAGE_FRAME_COUNT); // Order of division chosen to prevent overflow fps = 1000000 / (fps / KRAKEN_FPS_AVERAGE_FRAME_COUNT); // Order of division chosen to prevent overflow
} }
switch(settings.debug_display) { switch (settings.debug_display) {
case KRRenderSettings::KRENGINE_DEBUG_DISPLAY_NONE: // ----====---- No debug display ----====---- case KRRenderSettings::KRENGINE_DEBUG_DISPLAY_NONE: // ----====---- No debug display ----====----
break; break;
case KRRenderSettings::KRENGINE_DEBUG_DISPLAY_TIME: // ----====---- Time / FPS ----====---- case KRRenderSettings::KRENGINE_DEBUG_DISPLAY_TIME: // ----====---- Time / FPS ----====----
{ {
if(fps > 0) { if (fps > 0) {
stream << "FPS\t" << fps; stream << "FPS\t" << fps;
} }
} }
@@ -786,7 +790,7 @@ std::string KRCamera::getDebugText()
TASK_BASIC_INFO, TASK_BASIC_INFO,
(task_info_t)&info, (task_info_t)&info,
&size); &size);
if( kerr == KERN_SUCCESS ) { if (kerr == KERN_SUCCESS) {
stream << "\tResident\tVirtual\tTotal"; stream << "\tResident\tVirtual\tTotal";
stream << "\nCPU\t" << (info.resident_size / 1024 / 1024) << " MB\t" << (info.virtual_size / 1024 / 1024) << " MB\t" << ((info.resident_size + info.virtual_size) / 1024 / 1024) << " MB"; stream << "\nCPU\t" << (info.resident_size / 1024 / 1024) << " MB\t" << (info.virtual_size / 1024 / 1024) << " MB\t" << ((info.resident_size + info.virtual_size) / 1024 / 1024) << " MB";
} else { } else {
@@ -798,9 +802,9 @@ std::string KRCamera::getDebugText()
mach_msg_type_number_t host_size = sizeof(vm_statistics_data_t) / sizeof(integer_t); mach_msg_type_number_t host_size = sizeof(vm_statistics_data_t) / sizeof(integer_t);
vm_size_t pagesize = 0; vm_size_t pagesize = 0;
vm_statistics_data_t vm_stat; vm_statistics_data_t vm_stat;
if(host_page_size(host_port, &pagesize) != KERN_SUCCESS) { if (host_page_size(host_port, &pagesize) != KERN_SUCCESS) {
stream << "\n\nERROR: Could not get VM page size."; stream << "\n\nERROR: Could not get VM page size.";
} else if(host_statistics(host_port, HOST_VM_INFO, (host_info_t)&vm_stat, &host_size) != KERN_SUCCESS) { } else if (host_statistics(host_port, HOST_VM_INFO, (host_info_t)&vm_stat, &host_size) != KERN_SUCCESS) {
stream << "\n\nERROR: Could not get VM stats."; stream << "\n\nERROR: Could not get VM stats.";
} else { } else {
stream << "\n\n\n\tWired\tActive\tInactive\tFree\tTotal"; stream << "\n\n\n\tWired\tActive\tInactive\tFree\tTotal";
@@ -832,7 +836,7 @@ std::string KRCamera::getDebugText()
stream << "\n\n\n\t# Active\t# Used\tActive\tUsed\tThroughput\n"; stream << "\n\n\n\t# Active\t# Used\tActive\tUsed\tThroughput\n";
stream << "Textures\t" << texture_count_active << "\t" << texture_count << "\t" << (texture_mem_active / 1024) << " KB\t" << (texture_mem_used / 1024) << " KB\t" << (texture_mem_throughput / 1024) << " KB / frame\n"; stream << "Textures\t" << texture_count_active << "\t" << texture_count << "\t" << (texture_mem_active / 1024) << " KB\t" << (texture_mem_used / 1024) << " KB\t" << (texture_mem_throughput / 1024) << " KB / frame\n";
stream << "VBO's\t" << vbo_count_active << "\t" << vbo_count_active << "\t" << (vbo_mem_active / 1024) <<" KB\t" << (vbo_mem_used / 1024) << " KB\t" << (vbo_mem_throughput / 1024) << " KB / frame\n"; stream << "VBO's\t" << vbo_count_active << "\t" << vbo_count_active << "\t" << (vbo_mem_active / 1024) << " KB\t" << (vbo_mem_used / 1024) << " KB\t" << (vbo_mem_throughput / 1024) << " KB / frame\n";
stream << "\nGPU Total\t\t\t" << (total_mem_active / 1024) << " KB\t" << (total_mem_used / 1024) << " KB\t" << (total_mem_throughput / 1024) << " KB / frame"; stream << "\nGPU Total\t\t\t" << (total_mem_active / 1024) << " KB\t" << (total_mem_used / 1024) << " KB\t" << (total_mem_throughput / 1024) << " KB / frame";
} }
break; break;
@@ -841,10 +845,10 @@ std::string KRCamera::getDebugText()
{ {
bool first = true; bool first = true;
int texture_count = 0; int texture_count = 0;
std::set<KRTexture *> active_textures = m_pContext->getTextureManager()->getActiveTextures(); std::set<KRTexture*> active_textures = m_pContext->getTextureManager()->getActiveTextures();
for(std::set<KRTexture *>::iterator itr=active_textures.begin(); itr != active_textures.end(); itr++) { for (std::set<KRTexture*>::iterator itr = active_textures.begin(); itr != active_textures.end(); itr++) {
KRTexture *texture = *itr; KRTexture* texture = *itr;
if(first) { if (first) {
first = false; first = false;
} else { } else {
stream << "\n"; stream << "\n";
@@ -855,7 +859,7 @@ std::string KRCamera::getDebugText()
stream << " KB"; stream << " KB";
stream << "\t"; stream << "\t";
stream << texture->getMaxMipMap(); stream << texture->getMaxMipMap();
if(texture->hasMipmaps() && texture->getCurrentLodMaxDim() != texture->getMaxMipMap()) { if (texture->hasMipmaps() && texture->getCurrentLodMaxDim() != texture->getMaxMipMap()) {
stream << " px => "; stream << " px => ";
stream << texture->getCurrentLodMaxDim(); stream << texture->getCurrentLodMaxDim();
} }
@@ -877,10 +881,10 @@ std::string KRCamera::getDebugText()
long draw_call_count = 0; long draw_call_count = 0;
long vertex_count = 0; long vertex_count = 0;
stream << "\tVerts\tPass\tObject\tMaterial"; stream << "\tVerts\tPass\tObject\tMaterial";
for(std::vector<KRMeshManager::draw_call_info>::iterator itr = draw_calls.begin(); itr != draw_calls.end(); itr++) { for (std::vector<KRMeshManager::draw_call_info>::iterator itr = draw_calls.begin(); itr != draw_calls.end(); itr++) {
draw_call_count++; draw_call_count++;
stream << "\n" << draw_call_count << "\t" << (*itr).vertex_count << "\t"; stream << "\n" << draw_call_count << "\t" << (*itr).vertex_count << "\t";
switch((*itr).pass) { switch ((*itr).pass) {
case KRNode::RENDER_PASS_FORWARD_OPAQUE: case KRNode::RENDER_PASS_FORWARD_OPAQUE:
stream << "opaq"; stream << "opaq";
break; break;
@@ -943,7 +947,7 @@ std::string KRCamera::getDebugText()
} }
const KRViewport &KRCamera::getViewport() const const KRViewport& KRCamera::getViewport() const
{ {
return m_viewport; return m_viewport;
} }
@@ -959,7 +963,7 @@ void KRCamera::setDownsample(float v)
m_downsample = Vector2::Create(v); m_downsample = Vector2::Create(v);
} }
void KRCamera::setFadeColor(const Vector4 &fade_color) void KRCamera::setFadeColor(const Vector4& fade_color)
{ {
m_fade_color = fade_color; m_fade_color = fade_color;
} }

22
kraken/KRCamera.h
View File

@@ -48,22 +48,23 @@ class KRScene;
class KRViewport; class KRViewport;
class KRSurface; class KRSurface;
class KRCamera : public KRNode { class KRCamera : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRCamera(KRScene &scene, std::string name); KRCamera(KRScene& scene, std::string name);
virtual ~KRCamera(); virtual ~KRCamera();
void renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeSurface); void renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeSurface);
KRRenderSettings settings; KRRenderSettings settings;
const KRViewport &getViewport() const; const KRViewport& getViewport() const;
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
std::string getDebugText(); std::string getDebugText();
@@ -71,10 +72,10 @@ public:
Vector2 getDownsample(); Vector2 getDownsample();
void setDownsample(float v); void setDownsample(float v);
void setFadeColor(const Vector4 &fade_color); void setFadeColor(const Vector4& fade_color);
Vector4 getFadeColor(); Vector4 getFadeColor();
void setSkyBox(const std::string &skyBox); void setSkyBox(const std::string& skyBox);
const std::string getSkyBox() const; const std::string getSkyBox() const;
private: private:
@@ -92,7 +93,7 @@ private:
void destroyBuffers(); void destroyBuffers();
KRTexture *m_pSkyBoxTexture; KRTexture* m_pSkyBoxTexture;
std::string m_skyBox; std::string m_skyBox;
KRViewport m_viewport; KRViewport m_viewport;
@@ -102,7 +103,8 @@ private:
Vector4 m_fade_color; Vector4 m_fade_color;
typedef struct { typedef struct
{
float x; float x;
float y; float y;
float z; float z;
@@ -113,7 +115,7 @@ private:
KRDataBlock m_debug_text_vertices; KRDataBlock m_debug_text_vertices;
KRMeshManager::KRVBOData m_debug_text_vbo_data; KRMeshManager::KRVBOData m_debug_text_vbo_data;
// std::string getDebugText(); // std::string getDebugText();
uint64_t m_last_frame_start; uint64_t m_last_frame_start;
int m_frame_times[KRAKEN_FPS_AVERAGE_FRAME_COUNT]; int m_frame_times[KRAKEN_FPS_AVERAGE_FRAME_COUNT];

74
kraken/KRCollider.cpp
View File

@@ -43,79 +43,85 @@ void KRCollider::InitNodeInfo(KrNodeInfo* nodeInfo)
nodeInfo->collider.mesh = -1; nodeInfo->collider.mesh = -1;
} }
KRCollider::KRCollider(KRScene &scene, std::string collider_name, std::string model_name, unsigned int layer_mask, float audio_occlusion) : KRNode(scene, collider_name) { KRCollider::KRCollider(KRScene& scene, std::string collider_name, std::string model_name, unsigned int layer_mask, float audio_occlusion) : KRNode(scene, collider_name)
{
m_model_name = model_name; m_model_name = model_name;
m_layer_mask = layer_mask; m_layer_mask = layer_mask;
m_audio_occlusion = audio_occlusion; m_audio_occlusion = audio_occlusion;
m_model = nullptr; m_model = nullptr;
} }
KRCollider::~KRCollider() { KRCollider::~KRCollider()
{
} }
std::string KRCollider::getElementName() { std::string KRCollider::getElementName()
{
return "collider"; return "collider";
} }
tinyxml2::XMLElement *KRCollider::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRCollider::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
e->SetAttribute("mesh", m_model_name.c_str()); e->SetAttribute("mesh", m_model_name.c_str());
e->SetAttribute("layer_mask", m_layer_mask); e->SetAttribute("layer_mask", m_layer_mask);
e->SetAttribute("audio_occlusion", m_audio_occlusion); e->SetAttribute("audio_occlusion", m_audio_occlusion);
return e; return e;
} }
void KRCollider::loadXML(tinyxml2::XMLElement *e) { void KRCollider::loadXML(tinyxml2::XMLElement* e)
{
KRNode::loadXML(e); KRNode::loadXML(e);
m_model_name = e->Attribute("mesh"); m_model_name = e->Attribute("mesh");
m_layer_mask = 65535; m_layer_mask = 65535;
if(e->QueryUnsignedAttribute("layer_mask", &m_layer_mask) != tinyxml2::XML_SUCCESS) { if (e->QueryUnsignedAttribute("layer_mask", &m_layer_mask) != tinyxml2::XML_SUCCESS) {
m_layer_mask = 65535; m_layer_mask = 65535;
} }
m_audio_occlusion = 1.0f; m_audio_occlusion = 1.0f;
if(e->QueryFloatAttribute("audio_occlusion", &m_audio_occlusion) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("audio_occlusion", &m_audio_occlusion) != tinyxml2::XML_SUCCESS) {
m_audio_occlusion = 1.0f; m_audio_occlusion = 1.0f;
} }
} }
void KRCollider::loadModel() { void KRCollider::loadModel()
if(m_model == nullptr) { {
if (m_model == nullptr) {
m_model = m_pContext->getMeshManager()->getMaxLODModel(m_model_name.c_str()); m_model = m_pContext->getMeshManager()->getMaxLODModel(m_model_name.c_str());
if(m_model) { if (m_model) {
getScene().notify_sceneGraphModify(this); getScene().notify_sceneGraphModify(this);
} }
} }
} }
AABB KRCollider::getBounds() { AABB KRCollider::getBounds()
{
loadModel(); loadModel();
if(m_model) { if (m_model) {
return AABB::Create(m_model->getMinPoint(), m_model->getMaxPoint(), getModelMatrix()); return AABB::Create(m_model->getMinPoint(), m_model->getMaxPoint(), getModelMatrix());
} else { } else {
return AABB::Infinite(); return AABB::Infinite();
} }
} }
bool KRCollider::lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo, unsigned int layer_mask) bool KRCollider::lineCast(const Vector3& v0, const Vector3& v1, HitInfo& hitinfo, unsigned int layer_mask)
{ {
if(layer_mask & m_layer_mask ) { // Only test if layer masks have a common bit set if (layer_mask & m_layer_mask) { // Only test if layer masks have a common bit set
loadModel(); loadModel();
if(m_model) { if (m_model) {
if(getBounds().intersectsLine(v0, v1)) { if (getBounds().intersectsLine(v0, v1)) {
Vector3 v0_model_space = Matrix4::Dot(getInverseModelMatrix(), v0); Vector3 v0_model_space = Matrix4::Dot(getInverseModelMatrix(), v0);
Vector3 v1_model_space = Matrix4::Dot(getInverseModelMatrix(), v1); Vector3 v1_model_space = Matrix4::Dot(getInverseModelMatrix(), v1);
HitInfo hitinfo_model_space; HitInfo hitinfo_model_space;
if(hitinfo.didHit()) { if (hitinfo.didHit()) {
Vector3 hit_position_model_space = Matrix4::Dot(getInverseModelMatrix(), hitinfo.getPosition()); Vector3 hit_position_model_space = Matrix4::Dot(getInverseModelMatrix(), hitinfo.getPosition());
hitinfo_model_space = HitInfo(hit_position_model_space, Matrix4::DotNoTranslate(getInverseModelMatrix(), hitinfo.getNormal()), (hit_position_model_space - v0_model_space).magnitude(), hitinfo.getNode()); hitinfo_model_space = HitInfo(hit_position_model_space, Matrix4::DotNoTranslate(getInverseModelMatrix(), hitinfo.getNormal()), (hit_position_model_space - v0_model_space).magnitude(), hitinfo.getNode());
} }
if(m_model->lineCast(v0_model_space, v1_model_space, hitinfo_model_space)) { if (m_model->lineCast(v0_model_space, v1_model_space, hitinfo_model_space)) {
Vector3 hit_position_world_space = Matrix4::Dot(getModelMatrix(), hitinfo_model_space.getPosition()); Vector3 hit_position_world_space = Matrix4::Dot(getModelMatrix(), hitinfo_model_space.getPosition());
hitinfo = HitInfo(hit_position_world_space, Vector3::Normalize(Matrix4::DotNoTranslate(getModelMatrix(), hitinfo_model_space.getNormal())), (hit_position_world_space - v0).magnitude(), this); hitinfo = HitInfo(hit_position_world_space, Vector3::Normalize(Matrix4::DotNoTranslate(getModelMatrix(), hitinfo_model_space.getNormal())), (hit_position_world_space - v0).magnitude(), this);
return true; return true;
@@ -126,21 +132,21 @@ bool KRCollider::lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo
return false; return false;
} }
bool KRCollider::rayCast(const Vector3 &v0, const Vector3 &dir, HitInfo &hitinfo, unsigned int layer_mask) bool KRCollider::rayCast(const Vector3& v0, const Vector3& dir, HitInfo& hitinfo, unsigned int layer_mask)
{ {
if(layer_mask & m_layer_mask) { // Only test if layer masks have a common bit set if (layer_mask & m_layer_mask) { // Only test if layer masks have a common bit set
loadModel(); loadModel();
if(m_model) { if (m_model) {
if(getBounds().intersectsRay(v0, dir)) { if (getBounds().intersectsRay(v0, dir)) {
Vector3 v0_model_space = Matrix4::Dot(getInverseModelMatrix(), v0); Vector3 v0_model_space = Matrix4::Dot(getInverseModelMatrix(), v0);
Vector3 dir_model_space = Vector3::Normalize(Matrix4::DotNoTranslate(getInverseModelMatrix(), dir)); Vector3 dir_model_space = Vector3::Normalize(Matrix4::DotNoTranslate(getInverseModelMatrix(), dir));
HitInfo hitinfo_model_space; HitInfo hitinfo_model_space;
if(hitinfo.didHit()) { if (hitinfo.didHit()) {
Vector3 hit_position_model_space = Matrix4::Dot(getInverseModelMatrix(), hitinfo.getPosition()); Vector3 hit_position_model_space = Matrix4::Dot(getInverseModelMatrix(), hitinfo.getPosition());
hitinfo_model_space = HitInfo(hit_position_model_space, Vector3::Normalize(Matrix4::DotNoTranslate(getInverseModelMatrix(), hitinfo.getNormal())), (hit_position_model_space - v0_model_space).magnitude(), hitinfo.getNode()); hitinfo_model_space = HitInfo(hit_position_model_space, Vector3::Normalize(Matrix4::DotNoTranslate(getInverseModelMatrix(), hitinfo.getNormal())), (hit_position_model_space - v0_model_space).magnitude(), hitinfo.getNode());
} }
if(m_model->rayCast(v0_model_space, dir_model_space, hitinfo_model_space)) { if (m_model->rayCast(v0_model_space, dir_model_space, hitinfo_model_space)) {
Vector3 hit_position_world_space = Matrix4::Dot(getModelMatrix(), hitinfo_model_space.getPosition()); Vector3 hit_position_world_space = Matrix4::Dot(getModelMatrix(), hitinfo_model_space.getPosition());
hitinfo = HitInfo(hit_position_world_space, Vector3::Normalize(Matrix4::DotNoTranslate(getModelMatrix(), hitinfo_model_space.getNormal())), (hit_position_world_space - v0).magnitude(), this); hitinfo = HitInfo(hit_position_world_space, Vector3::Normalize(Matrix4::DotNoTranslate(getModelMatrix(), hitinfo_model_space.getNormal())), (hit_position_world_space - v0).magnitude(), this);
return true; return true;
@@ -151,18 +157,18 @@ bool KRCollider::rayCast(const Vector3 &v0, const Vector3 &dir, HitInfo &hitinfo
return false; return false;
} }
bool KRCollider::sphereCast(const Vector3 &v0, const Vector3 &v1, float radius, HitInfo &hitinfo, unsigned int layer_mask) bool KRCollider::sphereCast(const Vector3& v0, const Vector3& v1, float radius, HitInfo& hitinfo, unsigned int layer_mask)
{ {
if(layer_mask & m_layer_mask) { // Only test if layer masks have a common bit set if (layer_mask & m_layer_mask) { // Only test if layer masks have a common bit set
loadModel(); loadModel();
if(m_model) { if (m_model) {
AABB sphereCastBounds = AABB::Create( // TODO - Need to cache this; perhaps encasulate within a "spherecast" class to be passed through these functions AABB sphereCastBounds = AABB::Create( // TODO - Need to cache this; perhaps encasulate within a "spherecast" class to be passed through these functions
Vector3::Create(KRMIN(v0.x, v1.x) - radius, KRMIN(v0.y, v1.y) - radius, KRMIN(v0.z, v1.z) - radius), Vector3::Create(KRMIN(v0.x, v1.x) - radius, KRMIN(v0.y, v1.y) - radius, KRMIN(v0.z, v1.z) - radius),
Vector3::Create(KRMAX(v0.x, v1.x) + radius, KRMAX(v0.y, v1.y) + radius, KRMAX(v0.z, v1.z) + radius) Vector3::Create(KRMAX(v0.x, v1.x) + radius, KRMAX(v0.y, v1.y) + radius, KRMAX(v0.z, v1.z) + radius)
); );
if(getBounds().intersects(sphereCastBounds)) { if (getBounds().intersects(sphereCastBounds)) {
if(m_model->sphereCast(getModelMatrix(), v0, v1, radius, hitinfo)) { if (m_model->sphereCast(getModelMatrix(), v0, v1, radius, hitinfo)) {
hitinfo = HitInfo(hitinfo.getPosition(), hitinfo.getNormal(), hitinfo.getDistance(), this); hitinfo = HitInfo(hitinfo.getPosition(), hitinfo.getNormal(), hitinfo.getDistance(), this);
return true; return true;
} }
@@ -195,13 +201,13 @@ void KRCollider::setAudioOcclusion(float audio_occlusion)
void KRCollider::render(RenderInfo& ri) void KRCollider::render(RenderInfo& ri)
{ {
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRNode::render(ri); KRNode::render(ri);
if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_COLLIDERS) { if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_COLLIDERS) {
loadModel(); loadModel();
if(m_model) { if (m_model) {
GL_PUSH_GROUP_MARKER("Debug Overlays"); GL_PUSH_GROUP_MARKER("Debug Overlays");
@@ -217,7 +223,7 @@ void KRCollider::render(RenderInfo& ri)
info.modelFormat = m_model->getModelFormat(); info.modelFormat = m_model->getModelFormat();
info.vertexAttributes = m_model->getVertexAttributes(); info.vertexAttributes = m_model->getVertexAttributes();
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);

15
kraken/KRCollider.h
View File

@@ -46,22 +46,23 @@
#include "KRMesh.h" #include "KRMesh.h"
#include "KRTexture.h" #include "KRTexture.h"
class KRCollider : public KRNode { class KRCollider : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRCollider(KRScene &scene, std::string collider_name, std::string model_name, unsigned int layer_mask, float audio_occlusion); KRCollider(KRScene& scene, std::string collider_name, std::string model_name, unsigned int layer_mask, float audio_occlusion);
virtual ~KRCollider(); virtual ~KRCollider();
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
virtual AABB getBounds(); virtual AABB getBounds();
bool lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo, unsigned int layer_mask); bool lineCast(const Vector3& v0, const Vector3& v1, HitInfo& hitinfo, unsigned int layer_mask);
bool rayCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo, unsigned int layer_mask); bool rayCast(const Vector3& v0, const Vector3& v1, HitInfo& hitinfo, unsigned int layer_mask);
bool sphereCast(const Vector3 &v0, const Vector3 &v1, float radius, HitInfo &hitinfo, unsigned int layer_mask); bool sphereCast(const Vector3& v0, const Vector3& v1, float radius, HitInfo& hitinfo, unsigned int layer_mask);
unsigned int getLayerMask(); unsigned int getLayerMask();
void setLayerMask(unsigned int layer_mask); void setLayerMask(unsigned int layer_mask);

183
kraken/KRContext.cpp
View File

@@ -79,15 +79,15 @@ int KRContext::KRENGINE_SYS_PAGE_SIZE;
std::mutex KRContext::g_SurfaceInfoMutex; std::mutex KRContext::g_SurfaceInfoMutex;
std::mutex KRContext::g_DeviceInfoMutex; std::mutex KRContext::g_DeviceInfoMutex;
KRContext::log_callback *KRContext::s_log_callback = NULL; KRContext::log_callback* KRContext::s_log_callback = NULL;
void *KRContext::s_log_callback_user_data = NULL; void* KRContext::s_log_callback_user_data = NULL;
KRContext::KRContext(const KrInitializeInfo* initializeInfo) KRContext::KRContext(const KrInitializeInfo* initializeInfo)
: m_resourceMapSize(initializeInfo->resourceMapSize) : m_resourceMapSize(initializeInfo->resourceMapSize)
{ {
m_presentationThread = std::make_unique<KRPresentationThread>(*this); m_presentationThread = std::make_unique<KRPresentationThread>(*this);
m_streamerThread = std::make_unique<KRStreamerThread>(*this); m_streamerThread = std::make_unique<KRStreamerThread>(*this);
m_resourceMap = (KRResource **)malloc(sizeof(KRResource*) * m_resourceMapSize); m_resourceMap = (KRResource**)malloc(sizeof(KRResource*) * m_resourceMapSize);
memset(m_resourceMap, 0, m_resourceMapSize * sizeof(KRResource*)); memset(m_resourceMap, 0, m_resourceMapSize * sizeof(KRResource*));
m_streamingEnabled = false; m_streamingEnabled = false;
#ifdef __APPLE__ #ifdef __APPLE__
@@ -138,7 +138,8 @@ KRContext::KRContext(const KrInitializeInfo* initializeInfo)
m_streamerThread->start(); m_streamerThread->start();
} }
KRContext::~KRContext() { KRContext::~KRContext()
{
m_presentationThread->stop(); m_presentationThread->stop();
m_streamerThread->stop(); m_streamerThread->stop();
m_pSceneManager.reset(); m_pSceneManager.reset();
@@ -167,7 +168,7 @@ KRContext::~KRContext() {
} }
} }
void KRContext::SetLogCallback(log_callback *log_callback, void *user_data) void KRContext::SetLogCallback(log_callback* log_callback, void* user_data)
{ {
s_log_callback = log_callback; s_log_callback = log_callback;
s_log_callback_user_data = user_data; s_log_callback_user_data = user_data;
@@ -178,13 +179,13 @@ void KRContext::Log(log_level level, const std::string message_format, ...)
va_list args; va_list args;
va_start(args, message_format); va_start(args, message_format);
if(s_log_callback) { if (s_log_callback) {
const int LOG_BUFFER_SIZE = 32768; const int LOG_BUFFER_SIZE = 32768;
char log_buffer[LOG_BUFFER_SIZE]; char log_buffer[LOG_BUFFER_SIZE];
vsnprintf(log_buffer, LOG_BUFFER_SIZE, message_format.c_str(), args); vsnprintf(log_buffer, LOG_BUFFER_SIZE, message_format.c_str(), args);
s_log_callback(s_log_callback_user_data, std::string(log_buffer), level); s_log_callback(s_log_callback_user_data, std::string(log_buffer), level);
} else { } else {
FILE *out_file = level == LOG_LEVEL_INFORMATION ? stdout : stderr; FILE* out_file = level == LOG_LEVEL_INFORMATION ? stdout : stderr;
fprintf(out_file, "Kraken - INFO: "); fprintf(out_file, "Kraken - INFO: ");
vfprintf(out_file, message_format.c_str(), args); vfprintf(out_file, message_format.c_str(), args);
fprintf(out_file, "\n"); fprintf(out_file, "\n");
@@ -193,91 +194,105 @@ void KRContext::Log(log_level level, const std::string message_format, ...)
va_end(args); va_end(args);
} }
KRBundleManager *KRContext::getBundleManager() { KRBundleManager* KRContext::getBundleManager()
{
return m_pBundleManager.get(); return m_pBundleManager.get();
} }
KRSceneManager *KRContext::getSceneManager() { KRSceneManager* KRContext::getSceneManager()
{
return m_pSceneManager.get(); return m_pSceneManager.get();
} }
KRTextureManager *KRContext::getTextureManager() { KRTextureManager* KRContext::getTextureManager()
{
return m_pTextureManager.get(); return m_pTextureManager.get();
} }
KRMaterialManager *KRContext::getMaterialManager() { KRMaterialManager* KRContext::getMaterialManager()
{
return m_pMaterialManager.get(); return m_pMaterialManager.get();
} }
KRPipelineManager *KRContext::getPipelineManager() { KRPipelineManager* KRContext::getPipelineManager()
{
return m_pPipelineManager.get(); return m_pPipelineManager.get();
} }
KRMeshManager *KRContext::getMeshManager() { KRMeshManager* KRContext::getMeshManager()
{
return m_pMeshManager.get(); return m_pMeshManager.get();
} }
KRAnimationManager *KRContext::getAnimationManager() { KRAnimationManager* KRContext::getAnimationManager()
{
return m_pAnimationManager.get(); return m_pAnimationManager.get();
} }
KRAnimationCurveManager *KRContext::getAnimationCurveManager() { KRAnimationCurveManager* KRContext::getAnimationCurveManager()
{
return m_pAnimationCurveManager.get(); return m_pAnimationCurveManager.get();
} }
KRAudioManager *KRContext::getAudioManager() { KRAudioManager* KRContext::getAudioManager()
{
return m_pSoundManager.get(); return m_pSoundManager.get();
} }
KRShaderManager *KRContext::getShaderManager() { KRShaderManager* KRContext::getShaderManager()
{
return m_pShaderManager.get(); return m_pShaderManager.get();
} }
KRSourceManager *KRContext::getSourceManager() { KRSourceManager* KRContext::getSourceManager()
{
return m_pSourceManager.get(); return m_pSourceManager.get();
} }
KRSurfaceManager* KRContext::getSurfaceManager() { KRSurfaceManager* KRContext::getSurfaceManager()
{
return m_surfaceManager.get(); return m_surfaceManager.get();
} }
KRDeviceManager* KRContext::getDeviceManager() { KRDeviceManager* KRContext::getDeviceManager()
{
return m_deviceManager.get(); return m_deviceManager.get();
} }
KRUnknownManager *KRContext::getUnknownManager() { KRUnknownManager* KRContext::getUnknownManager()
{
return m_pUnknownManager.get(); return m_pUnknownManager.get();
} }
std::vector<KRResource *> KRContext::getResources() std::vector<KRResource*> KRContext::getResources()
{ {
std::vector<KRResource *> resources; std::vector<KRResource*> resources;
for(unordered_map<std::string, KRScene *>::iterator itr = m_pSceneManager->getScenes().begin(); itr != m_pSceneManager->getScenes().end(); itr++) { for (unordered_map<std::string, KRScene*>::iterator itr = m_pSceneManager->getScenes().begin(); itr != m_pSceneManager->getScenes().end(); itr++) {
resources.push_back((*itr).second); resources.push_back((*itr).second);
} }
for(unordered_map<std::string, KRTexture *>::iterator itr = m_pTextureManager->getTextures().begin(); itr != m_pTextureManager->getTextures().end(); itr++) { for (unordered_map<std::string, KRTexture*>::iterator itr = m_pTextureManager->getTextures().begin(); itr != m_pTextureManager->getTextures().end(); itr++) {
resources.push_back((*itr).second); resources.push_back((*itr).second);
} }
for(unordered_map<std::string, KRMaterial *>::iterator itr = m_pMaterialManager->getMaterials().begin(); itr != m_pMaterialManager->getMaterials().end(); itr++) { for (unordered_map<std::string, KRMaterial*>::iterator itr = m_pMaterialManager->getMaterials().begin(); itr != m_pMaterialManager->getMaterials().end(); itr++) {
resources.push_back((*itr).second); resources.push_back((*itr).second);
} }
for(unordered_multimap<std::string, KRMesh *>::iterator itr = m_pMeshManager->getModels().begin(); itr != m_pMeshManager->getModels().end(); itr++) { for (unordered_multimap<std::string, KRMesh*>::iterator itr = m_pMeshManager->getModels().begin(); itr != m_pMeshManager->getModels().end(); itr++) {
resources.push_back((*itr).second); resources.push_back((*itr).second);
} }
for(unordered_map<std::string, KRAnimation *>::iterator itr = m_pAnimationManager->getAnimations().begin(); itr != m_pAnimationManager->getAnimations().end(); itr++) { for (unordered_map<std::string, KRAnimation*>::iterator itr = m_pAnimationManager->getAnimations().begin(); itr != m_pAnimationManager->getAnimations().end(); itr++) {
resources.push_back((*itr).second); resources.push_back((*itr).second);
} }
for(unordered_map<std::string, KRAnimationCurve *>::iterator itr = m_pAnimationCurveManager->getAnimationCurves().begin(); itr != m_pAnimationCurveManager->getAnimationCurves().end(); itr++) { for (unordered_map<std::string, KRAnimationCurve*>::iterator itr = m_pAnimationCurveManager->getAnimationCurves().begin(); itr != m_pAnimationCurveManager->getAnimationCurves().end(); itr++) {
resources.push_back((*itr).second); resources.push_back((*itr).second);
} }
for(unordered_map<std::string, KRAudioSample *>::iterator itr = m_pSoundManager->getSounds().begin(); itr != m_pSoundManager->getSounds().end(); itr++) { for (unordered_map<std::string, KRAudioSample*>::iterator itr = m_pSoundManager->getSounds().begin(); itr != m_pSoundManager->getSounds().end(); itr++) {
resources.push_back((*itr).second); resources.push_back((*itr).second);
} }
unordered_map<std::string, unordered_map<std::string, KRSource *> > sources = m_pSourceManager->getSources(); unordered_map<std::string, unordered_map<std::string, KRSource*> > sources = m_pSourceManager->getSources();
for(unordered_map<std::string, unordered_map<std::string, KRSource *> >::iterator itr = sources.begin(); itr != sources.end(); itr++) { for (unordered_map<std::string, unordered_map<std::string, KRSource*> >::iterator itr = sources.begin(); itr != sources.end(); itr++) {
for(unordered_map<std::string, KRSource *>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) { for (unordered_map<std::string, KRSource*>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) {
resources.push_back((*itr2).second); resources.push_back((*itr2).second);
} }
} }
unordered_map<std::string, unordered_map<std::string, KRShader *> > shaders = m_pShaderManager->getShaders(); unordered_map<std::string, unordered_map<std::string, KRShader*> > shaders = m_pShaderManager->getShaders();
for(unordered_map<std::string, unordered_map<std::string, KRShader *> >::iterator itr = shaders.begin(); itr != shaders.end(); itr++) { for (unordered_map<std::string, unordered_map<std::string, KRShader*> >::iterator itr = shaders.begin(); itr != shaders.end(); itr++) {
for(unordered_map<std::string, KRShader *>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) { for (unordered_map<std::string, KRShader*>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) {
resources.push_back((*itr2).second); resources.push_back((*itr2).second);
} }
} }
unordered_map<std::string, unordered_map<std::string, KRUnknown *> > unknowns = m_pUnknownManager->getUnknowns(); unordered_map<std::string, unordered_map<std::string, KRUnknown*> > unknowns = m_pUnknownManager->getUnknowns();
for(unordered_map<std::string, unordered_map<std::string, KRUnknown *> >::iterator itr = unknowns.begin(); itr != unknowns.end(); itr++) { for (unordered_map<std::string, unordered_map<std::string, KRUnknown*> >::iterator itr = unknowns.begin(); itr != unknowns.end(); itr++) {
for(unordered_map<std::string, KRUnknown *>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) { for (unordered_map<std::string, KRUnknown*>::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); itr2++) {
resources.push_back((*itr2).second); resources.push_back((*itr2).second);
} }
} }
@@ -285,98 +300,99 @@ std::vector<KRResource *> KRContext::getResources()
return resources; return resources;
} }
KRResource* KRContext::loadResource(const std::string &file_name, KRDataBlock *data) { KRResource* KRContext::loadResource(const std::string& file_name, KRDataBlock* data)
{
std::string name = KRResource::GetFileBase(file_name); std::string name = KRResource::GetFileBase(file_name);
std::string extension = KRResource::GetFileExtension(file_name); std::string extension = KRResource::GetFileExtension(file_name);
KRResource *resource = nullptr; KRResource* resource = nullptr;
// fprintf(stderr, "KRContext::loadResource - Loading: %s\n", file_name.c_str()); // fprintf(stderr, "KRContext::loadResource - Loading: %s\n", file_name.c_str());
if(extension.compare("krbundle") == 0) { if (extension.compare("krbundle") == 0) {
resource = m_pBundleManager->loadBundle(name.c_str(), data); resource = m_pBundleManager->loadBundle(name.c_str(), data);
} else if(extension.compare("krmesh") == 0) { } else if (extension.compare("krmesh") == 0) {
resource = m_pMeshManager->loadModel(name.c_str(), data); resource = m_pMeshManager->loadModel(name.c_str(), data);
} else if(extension.compare("krscene") == 0) { } else if (extension.compare("krscene") == 0) {
resource = m_pSceneManager->loadScene(name.c_str(), data); resource = m_pSceneManager->loadScene(name.c_str(), data);
} else if(extension.compare("kranimation") == 0) { } else if (extension.compare("kranimation") == 0) {
resource = m_pAnimationManager->loadAnimation(name.c_str(), data); resource = m_pAnimationManager->loadAnimation(name.c_str(), data);
} else if(extension.compare("kranimationcurve") == 0) { } else if (extension.compare("kranimationcurve") == 0) {
resource = m_pAnimationCurveManager->loadAnimationCurve(name.c_str(), data); resource = m_pAnimationCurveManager->loadAnimationCurve(name.c_str(), data);
} else if(extension.compare("pvr") == 0) { } else if (extension.compare("pvr") == 0) {
resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data); resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
} else if(extension.compare("ktx") == 0) { } else if (extension.compare("ktx") == 0) {
resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data); resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
} else if(extension.compare("tga") == 0) { } else if (extension.compare("tga") == 0) {
resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data); resource = m_pTextureManager->loadTexture(name.c_str(), extension.c_str(), data);
} else if(extension.compare("spv") == 0) { } else if (extension.compare("spv") == 0) {
// SPIR-V shader binary // SPIR-V shader binary
resource = m_pShaderManager->load(name, extension, data); resource = m_pShaderManager->load(name, extension, data);
} else if(extension.compare("vert") == 0) { } else if (extension.compare("vert") == 0) {
// vertex shader // vertex shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("frag") == 0) { } else if (extension.compare("frag") == 0) {
// fragment shader // fragment shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("tesc") == 0) { } else if (extension.compare("tesc") == 0) {
// tessellation control shader // tessellation control shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("tese") == 0) { } else if (extension.compare("tese") == 0) {
// tessellation evaluation shader // tessellation evaluation shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("geom") == 0) { } else if (extension.compare("geom") == 0) {
// geometry shader // geometry shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("comp") == 0) { } else if (extension.compare("comp") == 0) {
// compute shader // compute shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("mesh") == 0) { } else if (extension.compare("mesh") == 0) {
// mesh shader // mesh shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("task") == 0) { } else if (extension.compare("task") == 0) {
// task shader // task shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("rgen") == 0) { } else if (extension.compare("rgen") == 0) {
// ray generation shader // ray generation shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("rint") == 0) { } else if (extension.compare("rint") == 0) {
// ray intersection shader // ray intersection shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("rahit") == 0) { } else if (extension.compare("rahit") == 0) {
// ray any hit shader // ray any hit shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("rchit") == 0) { } else if (extension.compare("rchit") == 0) {
// ray closest hit shader // ray closest hit shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("rmiss") == 0) { } else if (extension.compare("rmiss") == 0) {
// ray miss shader // ray miss shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("rcall") == 0) { } else if (extension.compare("rcall") == 0) {
// ray callable shader // ray callable shader
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("glsl") == 0) { } else if (extension.compare("glsl") == 0) {
// glsl included by other shaders // glsl included by other shaders
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("options") == 0) { } else if (extension.compare("options") == 0) {
// shader pre-processor options definition file // shader pre-processor options definition file
resource = m_pSourceManager->load(name, extension, data); resource = m_pSourceManager->load(name, extension, data);
} else if(extension.compare("mtl") == 0) { } else if (extension.compare("mtl") == 0) {
resource = m_pMaterialManager->load(name.c_str(), data); resource = m_pMaterialManager->load(name.c_str(), data);
} else if(extension.compare("mp3") == 0) { } else if (extension.compare("mp3") == 0) {
resource = m_pSoundManager->load(name.c_str(), extension, data); resource = m_pSoundManager->load(name.c_str(), extension, data);
} else if(extension.compare("wav") == 0) { } else if (extension.compare("wav") == 0) {
resource = m_pSoundManager->load(name.c_str(), extension, data); resource = m_pSoundManager->load(name.c_str(), extension, data);
} else if(extension.compare("aac") == 0) { } else if (extension.compare("aac") == 0) {
resource = m_pSoundManager->load(name.c_str(), extension, data); resource = m_pSoundManager->load(name.c_str(), extension, data);
} else if(extension.compare("obj") == 0) { } else if (extension.compare("obj") == 0) {
resource = KRResource::LoadObj(*this, file_name); resource = KRResource::LoadObj(*this, file_name);
#if !TARGET_OS_IPHONE #if !TARGET_OS_IPHONE
/* /*
// FINDME, TODO, HACK! - Uncomment // FINDME, TODO, HACK! - Uncomment
} else if(extension.compare("fbx") == 0) { } else if(extension.compare("fbx") == 0) {
resource = KRResource::LoadFbx(*this, file_name); resource = KRResource::LoadFbx(*this, file_name);
*/ */
} else if(extension.compare("blend") == 0) { } else if (extension.compare("blend") == 0) {
resource = KRResource::LoadBlenderScene(*this, file_name); resource = KRResource::LoadBlenderScene(*this, file_name);
#endif #endif
} else { } else {
@@ -385,18 +401,19 @@ KRResource* KRContext::loadResource(const std::string &file_name, KRDataBlock *d
return resource; return resource;
} }
KrResult KRContext::loadResource(const KrLoadResourceInfo* loadResourceInfo) { KrResult KRContext::loadResource(const KrLoadResourceInfo* loadResourceInfo)
{
if (loadResourceInfo->resourceHandle < 0 || loadResourceInfo->resourceHandle >= m_resourceMapSize) { if (loadResourceInfo->resourceHandle < 0 || loadResourceInfo->resourceHandle >= m_resourceMapSize) {
return KR_ERROR_OUT_OF_BOUNDS; return KR_ERROR_OUT_OF_BOUNDS;
} }
KRDataBlock *data = new KRDataBlock(); KRDataBlock* data = new KRDataBlock();
if(!data->load(loadResourceInfo->pResourcePath)) { if (!data->load(loadResourceInfo->pResourcePath)) {
KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KRContext::loadResource - Failed to open file: %s", loadResourceInfo->pResourcePath); KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KRContext::loadResource - Failed to open file: %s", loadResourceInfo->pResourcePath);
delete data; delete data;
return KR_ERROR_UNEXPECTED; return KR_ERROR_UNEXPECTED;
} }
KRResource *resource = loadResource(loadResourceInfo->pResourcePath, data); KRResource* resource = loadResource(loadResourceInfo->pResourcePath, data);
m_resourceMap[loadResourceInfo->resourceHandle] = resource; m_resourceMap[loadResourceInfo->resourceHandle] = resource;
return KR_SUCCESS; return KR_SUCCESS;
} }
@@ -608,7 +625,7 @@ float KRContext::getAbsoluteTime() const
long KRContext::getAbsoluteTimeMilliseconds() long KRContext::getAbsoluteTimeMilliseconds()
{ {
#if defined(ANDROID) #if defined(ANDROID)
return std::chrono::duration_cast< std::chrono::milliseconds >( return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count(); std::chrono::system_clock::now().time_since_epoch()).count();
#elif defined(__APPLE__) #elif defined(__APPLE__)
return (long)(mach_absolute_time() / 1000 * m_timebase_info.numer / m_timebase_info.denom); // Division done first to avoid potential overflow return (long)(mach_absolute_time() / 1000 * m_timebase_info.numer / m_timebase_info.denom); // Division done first to avoid potential overflow
@@ -619,7 +636,7 @@ long KRContext::getAbsoluteTimeMilliseconds()
#if TARGET_OS_IPHONE || TARGET_OS_MAC #if TARGET_OS_IPHONE || TARGET_OS_MAC
void KRContext::getMemoryStats(long &free_memory) void KRContext::getMemoryStats(long& free_memory)
{ {
free_memory = 0; free_memory = 0;
@@ -628,9 +645,9 @@ void KRContext::getMemoryStats(long &free_memory)
vm_size_t pagesize = 0; vm_size_t pagesize = 0;
vm_statistics_data_t vm_stat; vm_statistics_data_t vm_stat;
// int total_ram = 256 * 1024 * 1024; // int total_ram = 256 * 1024 * 1024;
if(host_page_size(host_port, &pagesize) != KERN_SUCCESS) { if (host_page_size(host_port, &pagesize) != KERN_SUCCESS) {
KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Could not get VM page size."); KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Could not get VM page size.");
} else if(host_statistics(host_port, HOST_VM_INFO, (host_info_t)&vm_stat, &host_size) != KERN_SUCCESS) { } else if (host_statistics(host_port, HOST_VM_INFO, (host_info_t)&vm_stat, &host_size) != KERN_SUCCESS) {
KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Could not get VM stats."); KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Could not get VM stats.");
} else { } else {
// total_ram = (vm_stat.wire_count + vm_stat.active_count + vm_stat.inactive_count + vm_stat.free_count) * pagesize; // total_ram = (vm_stat.wire_count + vm_stat.active_count + vm_stat.inactive_count + vm_stat.free_count) * pagesize;

44
kraken/KRContext.h
View File

@@ -54,7 +54,8 @@ class KRStreamerThread;
class KRDeviceManager; class KRDeviceManager;
class KRSurfaceManager; class KRSurfaceManager;
class KRContext { class KRContext
{
public: public:
static int KRENGINE_MAX_PIPELINE_HANDLES; static int KRENGINE_MAX_PIPELINE_HANDLES;
static int KRENGINE_GPU_MEM_MAX; static int KRENGINE_GPU_MEM_MAX;
@@ -97,21 +98,21 @@ public:
KrResult updateNode(const KrUpdateNodeInfo* pUpdateNodeInfo); KrResult updateNode(const KrUpdateNodeInfo* pUpdateNodeInfo);
KRResource* loadResource(const std::string &file_name, KRDataBlock *data); KRResource* loadResource(const std::string& file_name, KRDataBlock* data);
KRBundleManager *getBundleManager(); KRBundleManager* getBundleManager();
KRSceneManager *getSceneManager(); KRSceneManager* getSceneManager();
KRTextureManager *getTextureManager(); KRTextureManager* getTextureManager();
KRMaterialManager *getMaterialManager(); KRMaterialManager* getMaterialManager();
KRPipelineManager *getPipelineManager(); KRPipelineManager* getPipelineManager();
KRMeshManager *getMeshManager(); KRMeshManager* getMeshManager();
KRAnimationManager *getAnimationManager(); KRAnimationManager* getAnimationManager();
KRAnimationCurveManager *getAnimationCurveManager(); KRAnimationCurveManager* getAnimationCurveManager();
KRAudioManager *getAudioManager(); KRAudioManager* getAudioManager();
KRUnknownManager *getUnknownManager(); KRUnknownManager* getUnknownManager();
KRShaderManager *getShaderManager(); KRShaderManager* getShaderManager();
KRSourceManager *getSourceManager(); KRSourceManager* getSourceManager();
KRSurfaceManager* getSurfaceManager(); KRSurfaceManager* getSurfaceManager();
KRDeviceManager* getDeviceManager(); KRDeviceManager* getDeviceManager();
@@ -124,22 +125,23 @@ public:
long getAbsoluteTimeMilliseconds(); long getAbsoluteTimeMilliseconds();
std::vector<KRResource *> getResources(); std::vector<KRResource*> getResources();
#if TARGET_OS_IPHONE || TARGET_OS_MAC #if TARGET_OS_IPHONE || TARGET_OS_MAC
// XXX This doesn't belong here, and might not actually be needed at all // XXX This doesn't belong here, and might not actually be needed at all
void getMemoryStats(long &free_memory); void getMemoryStats(long& free_memory);
#endif #endif
typedef enum { typedef enum
{
LOG_LEVEL_INFORMATION, LOG_LEVEL_INFORMATION,
LOG_LEVEL_WARNING, LOG_LEVEL_WARNING,
LOG_LEVEL_ERROR LOG_LEVEL_ERROR
} log_level; } log_level;
typedef void log_callback(void *userdata, const std::string &message, log_level level); typedef void log_callback(void* userdata, const std::string& message, log_level level);
static void SetLogCallback(log_callback *log_callback, void *user_data); static void SetLogCallback(log_callback* log_callback, void* user_data);
static void Log(log_level level, const std::string message_format, ...); static void Log(log_level level, const std::string message_format, ...);
void doStreaming(); void doStreaming();
@@ -181,8 +183,8 @@ private:
// m_streamingEnabled is set to true once all managers are loaded // m_streamingEnabled is set to true once all managers are loaded
std::atomic<bool> m_streamingEnabled; std::atomic<bool> m_streamingEnabled;
static log_callback *s_log_callback; static log_callback* s_log_callback;
static void *s_log_callback_user_data; static void* s_log_callback_user_data;
unordered_multimap<std::string, KRResource*> m_resources; unordered_multimap<std::string, KRResource*> m_resources;

4
kraken/KRContextObject.cpp
View File

@@ -31,7 +31,7 @@
#include "KRContextObject.h" #include "KRContextObject.h"
KRContextObject::KRContextObject(KRContext &context) KRContextObject::KRContextObject(KRContext& context)
{ {
m_pContext = &context; m_pContext = &context;
} }
@@ -41,7 +41,7 @@ KRContextObject::~KRContextObject()
} }
KRContext &KRContextObject::getContext() const KRContext& KRContextObject::getContext() const
{ {
return *m_pContext; return *m_pContext;
} }

9
kraken/KRContextObject.h
View File

@@ -33,13 +33,14 @@
class KRContext; class KRContext;
class KRContextObject { class KRContextObject
{
public: public:
KRContextObject(KRContext &context); KRContextObject(KRContext& context);
~KRContextObject(); ~KRContextObject();
KRContext &getContext() const; KRContext& getContext() const;
protected: protected:
KRContext *m_pContext; KRContext* m_pContext;
}; };

47
kraken/KRDSP.h
View File

@@ -39,53 +39,56 @@ namespace KRDSP {
#define KRDSP_APPLE_VDSP #define KRDSP_APPLE_VDSP
#include <Accelerate/Accelerate.h> #include <Accelerate/Accelerate.h>
#else #else
// Slow, but portable fallback implementation // Slow, but portable fallback implementation
#define KRDSP_SLOW #define KRDSP_SLOW
#endif #endif
#if defined(KRDSP_APPLE_VDSP) #if defined(KRDSP_APPLE_VDSP)
// Apple vDSP // Apple vDSP
typedef DSPSplitComplex SplitComplex; typedef DSPSplitComplex SplitComplex;
struct FFTWorkspace { struct FFTWorkspace
{
FFTSetup setup; FFTSetup setup;
void create(size_t length); void create(size_t length);
void destroy(); void destroy();
FFTWorkspace(); FFTWorkspace();
~FFTWorkspace(); ~FFTWorkspace();
}; };
#elif defined(KRDSP_SLOW) #elif defined(KRDSP_SLOW)
typedef struct { typedef struct
float *realp; {
float *imagp; float* realp;
} SplitComplex; float* imagp;
} SplitComplex;
struct FFTWorkspace { struct FFTWorkspace
float *sin_table; {
float *cos_table; float* sin_table;
float* cos_table;
void create(size_t length); void create(size_t length);
void destroy(); void destroy();
FFTWorkspace(); FFTWorkspace();
~FFTWorkspace(); ~FFTWorkspace();
}; };
#else #else
#error Not Implemented #error Not Implemented
#endif #endif
void FFTForward(const FFTWorkspace &workspace, SplitComplex *src, size_t count); void FFTForward(const FFTWorkspace& workspace, SplitComplex* src, size_t count);
void FFTInverse(const FFTWorkspace &workspace, SplitComplex *src, size_t count); void FFTInverse(const FFTWorkspace& workspace, SplitComplex* src, size_t count);
void Int16ToFloat(const short *src, size_t srcStride, float *dest, size_t destStride, size_t count); void Int16ToFloat(const short* src, size_t srcStride, float* dest, size_t destStride, size_t count);
void Scale(float *buffer, float scale, size_t count); void Scale(float* buffer, float scale, size_t count);
void ScaleCopy(const float *src, float scale, float *dest, size_t count); void ScaleCopy(const float* src, float scale, float* dest, size_t count);
void ScaleCopy(const SplitComplex *src, float scale, SplitComplex *dest, size_t count); void ScaleCopy(const SplitComplex* src, float scale, SplitComplex* dest, size_t count);
void ScaleRamp(float *buffer, float scaleStart, float scaleStep, size_t count); void ScaleRamp(float* buffer, float scaleStart, float scaleStep, size_t count);
void Accumulate(float *buffer, size_t bufferStride, const float *buffer2, size_t buffer2Stride, size_t count); void Accumulate(float* buffer, size_t bufferStride, const float* buffer2, size_t buffer2Stride, size_t count);
void Accumulate(SplitComplex *buffer, const SplitComplex *buffer2, size_t count); void Accumulate(SplitComplex* buffer, const SplitComplex* buffer2, size_t count);
void Multiply(const SplitComplex *a, const SplitComplex *b, SplitComplex *c, size_t count); void Multiply(const SplitComplex* a, const SplitComplex* b, SplitComplex* c, size_t count);
} // namespace KRDSP } // namespace KRDSP

36
kraken/KRDSP_slow.cpp
View File

@@ -72,7 +72,7 @@ void FFTWorkspace::destroy()
} }
} }
void FFTForward(const FFTWorkspace &workspace, SplitComplex *src, size_t count) void FFTForward(const FFTWorkspace& workspace, SplitComplex* src, size_t count)
{ {
// Radix-2 Decimation in Time FFT Algorithm // Radix-2 Decimation in Time FFT Algorithm
// http://en.dsplib.org/content/fft_dec_in_time.html // http://en.dsplib.org/content/fft_dec_in_time.html
@@ -119,7 +119,7 @@ void FFTForward(const FFTWorkspace &workspace, SplitComplex *src, size_t count)
} }
} }
void FFTInverse(const FFTWorkspace &workspace, SplitComplex *src, size_t count) void FFTInverse(const FFTWorkspace& workspace, SplitComplex* src, size_t count)
{ {
SplitComplex swapped; SplitComplex swapped;
swapped.imagp = src->realp; swapped.imagp = src->realp;
@@ -127,10 +127,10 @@ void FFTInverse(const FFTWorkspace &workspace, SplitComplex *src, size_t count)
FFTForward(workspace, &swapped, count); FFTForward(workspace, &swapped, count);
} }
void Int16ToFloat(const short *src, size_t srcStride, float *dest, size_t destStride, size_t count) void Int16ToFloat(const short* src, size_t srcStride, float* dest, size_t destStride, size_t count)
{ {
const short *r = src; const short* r = src;
float *w = dest; float* w = dest;
while (w < dest + destStride * count) { while (w < dest + destStride * count) {
*w = (float)*r; *w = (float)*r;
r += srcStride; r += srcStride;
@@ -138,19 +138,19 @@ void Int16ToFloat(const short *src, size_t srcStride, float *dest, size_t destSt
} }
} }
void Scale(float *buffer, float scale, size_t count) void Scale(float* buffer, float scale, size_t count)
{ {
float *w = buffer; float* w = buffer;
while (w < buffer + count) { while (w < buffer + count) {
*w *= scale; *w *= scale;
w++; w++;
} }
} }
void ScaleCopy(const float *src, float scale, float *dest, size_t count) void ScaleCopy(const float* src, float scale, float* dest, size_t count)
{ {
const float *r = src; const float* r = src;
float *w = dest; float* w = dest;
while (w < dest + count) { while (w < dest + count) {
*w = *r * scale; *w = *r * scale;
w++; w++;
@@ -158,15 +158,15 @@ void ScaleCopy(const float *src, float scale, float *dest, size_t count)
} }
} }
void ScaleCopy(const SplitComplex *src, float scale, SplitComplex *dest, size_t count) void ScaleCopy(const SplitComplex* src, float scale, SplitComplex* dest, size_t count)
{ {
ScaleCopy(src->realp, scale, dest->realp, count); ScaleCopy(src->realp, scale, dest->realp, count);
ScaleCopy(src->imagp, scale, dest->imagp, count); ScaleCopy(src->imagp, scale, dest->imagp, count);
} }
void ScaleRamp(float *buffer, float scaleStart, float scaleStep, size_t count) void ScaleRamp(float* buffer, float scaleStart, float scaleStep, size_t count)
{ {
float *w = buffer; float* w = buffer;
float s = scaleStart; float s = scaleStart;
while (w < buffer + count) { while (w < buffer + count) {
*w *= s; *w *= s;
@@ -175,10 +175,10 @@ void ScaleRamp(float *buffer, float scaleStart, float scaleStep, size_t count)
} }
} }
void Accumulate(float *buffer, size_t bufferStride, const float *buffer2, size_t buffer2Stride, size_t count) void Accumulate(float* buffer, size_t bufferStride, const float* buffer2, size_t buffer2Stride, size_t count)
{ {
float *w = buffer; float* w = buffer;
const float *r = buffer2; const float* r = buffer2;
while (w < buffer + bufferStride * count) { while (w < buffer + bufferStride * count) {
*w *= *r; *w *= *r;
w += bufferStride; w += bufferStride;
@@ -186,7 +186,7 @@ void Accumulate(float *buffer, size_t bufferStride, const float *buffer2, size_t
} }
} }
void Accumulate(SplitComplex *buffer, const SplitComplex *buffer2, size_t count) void Accumulate(SplitComplex* buffer, const SplitComplex* buffer2, size_t count)
{ {
for (size_t i = 0; i < count; i++) { for (size_t i = 0; i < count; i++) {
buffer->imagp[i] += buffer2->imagp[i]; buffer->imagp[i] += buffer2->imagp[i];
@@ -194,7 +194,7 @@ void Accumulate(SplitComplex *buffer, const SplitComplex *buffer2, size_t count)
} }
} }
void Multiply(const SplitComplex *a, const SplitComplex *b, SplitComplex *c, size_t count) void Multiply(const SplitComplex* a, const SplitComplex* b, SplitComplex* c, size_t count)
{ {
for (size_t i = 0; i < count; i++) { for (size_t i = 0; i < count; i++) {
c->realp[i] = a->realp[i] * b->realp[i] - a->imagp[i] * b->imagp[i]; c->realp[i] = a->realp[i] * b->realp[i] - a->imagp[i] * b->imagp[i];

20
kraken/KRDSP_vDSP.cpp
View File

@@ -62,54 +62,54 @@ void FFTWorkspace::destroy()
} }
} }
void FFTForward(const FFTWorkspace &workspace, SplitComplex *src, size_t count) void FFTForward(const FFTWorkspace& workspace, SplitComplex* src, size_t count)
{ {
vDSP_fft_zip(workspace.setup, src, 1, count, kFFTDirection_Forward); vDSP_fft_zip(workspace.setup, src, 1, count, kFFTDirection_Forward);
} }
void FFTInverse(const FFTWorkspace &workspace, SplitComplex *src, size_t count) void FFTInverse(const FFTWorkspace& workspace, SplitComplex* src, size_t count)
{ {
vDSP_fft_zip(workspace.setup, src, 1, count, kFFTDirection_Inverse); vDSP_fft_zip(workspace.setup, src, 1, count, kFFTDirection_Inverse);
} }
void Int16ToFloat(const short *src, size_t srcStride, float *dest, size_t destStride, size_t count) void Int16ToFloat(const short* src, size_t srcStride, float* dest, size_t destStride, size_t count)
{ {
vDSP_vflt16(src, srcStride, dest, destStride, count); vDSP_vflt16(src, srcStride, dest, destStride, count);
} }
void Scale(float *buffer, float scale, size_t count) void Scale(float* buffer, float scale, size_t count)
{ {
vDSP_vsmul(buffer, 1, &scale, buffer, 1, count); vDSP_vsmul(buffer, 1, &scale, buffer, 1, count);
} }
void ScaleCopy(const float *src, float scale, float *dest, size_t count) void ScaleCopy(const float* src, float scale, float* dest, size_t count)
{ {
vDSP_vsmul(src, 1, &scale, dest, 1, count); vDSP_vsmul(src, 1, &scale, dest, 1, count);
} }
void ScaleCopy(const SplitComplex *src, float scale, SplitComplex *dest, size_t count) void ScaleCopy(const SplitComplex* src, float scale, SplitComplex* dest, size_t count)
{ {
ScaleCopy(src->realp, scale, dest->realp, count); ScaleCopy(src->realp, scale, dest->realp, count);
ScaleCopy(src->imagp, scale, dest->imagp, count); ScaleCopy(src->imagp, scale, dest->imagp, count);
} }
void ScaleRamp(float *buffer, float scaleStart, float scaleStep, size_t count) void ScaleRamp(float* buffer, float scaleStart, float scaleStep, size_t count)
{ {
vDSP_vrampmul(buffer, 1, &scaleStart, &scaleStep, buffer, 1, count); vDSP_vrampmul(buffer, 1, &scaleStart, &scaleStep, buffer, 1, count);
} }
void Accumulate(float *buffer, size_t bufferStride, const float *buffer2, size_t buffer2Stride, size_t count) void Accumulate(float* buffer, size_t bufferStride, const float* buffer2, size_t buffer2Stride, size_t count)
{ {
vDSP_vadd(buffer, bufferStride, buffer2, buffer2Stride, buffer, bufferStride, count); vDSP_vadd(buffer, bufferStride, buffer2, buffer2Stride, buffer, bufferStride, count);
} }
void Accumulate(SplitComplex *buffer, const SplitComplex *buffer2, size_t count) void Accumulate(SplitComplex* buffer, const SplitComplex* buffer2, size_t count)
{ {
vDSP_zvadd(buffer2, 1, buffer, 1, buffer, 1, count); vDSP_zvadd(buffer2, 1, buffer, 1, buffer, 1, count);
} }
void Multiply(const SplitComplex *a, const SplitComplex *b, SplitComplex *c, size_t count) void Multiply(const SplitComplex* a, const SplitComplex* b, SplitComplex* c, size_t count)
{ {
vDSP_zvmul(a, 1, b, 1, c, 1, count, 1); vDSP_zvmul(a, 1, b, 1, c, 1, count, 1);
} }

133
kraken/KRDataBlock.cpp
View File

@@ -47,7 +47,8 @@ int m_mapCount = 0;
size_t m_mapSize = 0; size_t m_mapSize = 0;
size_t m_mapOverhead = 0; size_t m_mapOverhead = 0;
KRDataBlock::KRDataBlock() { KRDataBlock::KRDataBlock()
{
m_data = NULL; m_data = NULL;
m_data_size = 0; m_data_size = 0;
m_data_offset = 0; m_data_offset = 0;
@@ -65,7 +66,8 @@ KRDataBlock::KRDataBlock() {
m_bReadOnly = false; m_bReadOnly = false;
} }
KRDataBlock::KRDataBlock(void *data, size_t size) { KRDataBlock::KRDataBlock(void* data, size_t size)
{
m_data = NULL; m_data = NULL;
m_data_size = 0; m_data_size = 0;
m_data_offset = 0; m_data_offset = 0;
@@ -84,7 +86,8 @@ KRDataBlock::KRDataBlock(void *data, size_t size) {
load(data, size); load(data, size);
} }
KRDataBlock::~KRDataBlock() { KRDataBlock::~KRDataBlock()
{
unload(); unload();
} }
@@ -102,16 +105,16 @@ void KRDataBlock::unload()
m_hPackFile = INVALID_HANDLE_VALUE; m_hPackFile = INVALID_HANDLE_VALUE;
} }
#elif defined(__APPLE__) #elif defined(__APPLE__)
if(m_fdPackFile) { if (m_fdPackFile) {
// Memory mapped file // Memory mapped file
if(m_fileOwnerDataBlock == this) { if (m_fileOwnerDataBlock == this) {
close(m_fdPackFile); close(m_fdPackFile);
} }
m_fdPackFile = 0; m_fdPackFile = 0;
} }
#endif #endif
if(m_data != NULL && m_bMalloced) { if (m_data != NULL && m_bMalloced) {
// Malloc'ed data // Malloc'ed data
free(m_data); free(m_data);
} }
@@ -127,7 +130,7 @@ void KRDataBlock::unload()
} }
// Encapsulate a pointer. Note - The pointer will not be free'ed // Encapsulate a pointer. Note - The pointer will not be free'ed
bool KRDataBlock::load(void *data, size_t size) bool KRDataBlock::load(void* data, size_t size)
{ {
unload(); unload();
m_data = data; m_data = data;
@@ -138,7 +141,7 @@ bool KRDataBlock::load(void *data, size_t size)
} }
// Load a file into memory using mmap. The data pointer will be protected as read-only until append() or expand() is called // Load a file into memory using mmap. The data pointer will be protected as read-only until append() or expand() is called
bool KRDataBlock::load(const std::string &path) bool KRDataBlock::load(const std::string& path)
{ {
bool success = false; bool success = false;
unload(); unload();
@@ -147,11 +150,11 @@ bool KRDataBlock::load(const std::string &path)
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
m_hPackFile = CreateFile(path.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); m_hPackFile = CreateFile(path.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(m_hPackFile != INVALID_HANDLE_VALUE) { if (m_hPackFile != INVALID_HANDLE_VALUE) {
m_fileOwnerDataBlock = this; m_fileOwnerDataBlock = this;
m_fileName = KRResource::GetFileBase(path); m_fileName = KRResource::GetFileBase(path);
FILE_STANDARD_INFO fileInfo; FILE_STANDARD_INFO fileInfo;
if(GetFileInformationByHandleEx(m_hPackFile, FileStandardInfo, &fileInfo, sizeof(fileInfo))) { if (GetFileInformationByHandleEx(m_hPackFile, FileStandardInfo, &fileInfo, sizeof(fileInfo))) {
m_data_size = fileInfo.EndOfFile.QuadPart; m_data_size = fileInfo.EndOfFile.QuadPart;
m_data_offset = 0; m_data_offset = 0;
success = true; success = true;
@@ -159,18 +162,18 @@ bool KRDataBlock::load(const std::string &path)
} }
#elif defined(__APPLE__) #elif defined(__APPLE__)
m_fdPackFile = open(path.c_str(), O_RDONLY); m_fdPackFile = open(path.c_str(), O_RDONLY);
if(m_fdPackFile >= 0) { if (m_fdPackFile >= 0) {
m_fileOwnerDataBlock = this; m_fileOwnerDataBlock = this;
m_fileName = KRResource::GetFileBase(path); m_fileName = KRResource::GetFileBase(path);
struct stat statbuf; struct stat statbuf;
if(fstat(m_fdPackFile, &statbuf) >= 0) { if (fstat(m_fdPackFile, &statbuf) >= 0) {
m_data_size = statbuf.st_size; m_data_size = statbuf.st_size;
m_data_offset = 0; m_data_offset = 0;
success = true; success = true;
} }
} }
#endif #endif
if(!success) { if (!success) {
// If anything failed, don't leave the object in an invalid state // If anything failed, don't leave the object in an invalid state
unload(); unload();
} }
@@ -178,13 +181,13 @@ bool KRDataBlock::load(const std::string &path)
} }
// Create a KRDataBlock encapsulating a sub-region of this block. The caller is responsible to free the object. // Create a KRDataBlock encapsulating a sub-region of this block. The caller is responsible to free the object.
KRDataBlock *KRDataBlock::getSubBlock(int start, int length) KRDataBlock* KRDataBlock::getSubBlock(int start, int length)
{ {
KRDataBlock *new_block = new KRDataBlock(); KRDataBlock* new_block = new KRDataBlock();
new_block->m_data_size = length; new_block->m_data_size = length;
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
if(m_hPackFile != INVALID_HANDLE_VALUE) { if (m_hPackFile != INVALID_HANDLE_VALUE) {
new_block->m_hPackFile = m_hPackFile; new_block->m_hPackFile = m_hPackFile;
#elif defined(__APPLE__) || defined(ANDROID) #elif defined(__APPLE__) || defined(ANDROID)
if (m_fdPackFile) { if (m_fdPackFile) {
@@ -194,8 +197,8 @@ KRDataBlock *KRDataBlock::getSubBlock(int start, int length)
#endif #endif
new_block->m_fileOwnerDataBlock = m_fileOwnerDataBlock; new_block->m_fileOwnerDataBlock = m_fileOwnerDataBlock;
new_block->m_data_offset = start + m_data_offset; new_block->m_data_offset = start + m_data_offset;
} else if(m_bMalloced) { } else if (m_bMalloced) {
new_block->m_data = (unsigned char *)m_data + start + m_data_offset; new_block->m_data = (unsigned char*)m_data + start + m_data_offset;
} }
new_block->m_bReadOnly = true; new_block->m_bReadOnly = true;
@@ -203,19 +206,22 @@ KRDataBlock *KRDataBlock::getSubBlock(int start, int length)
} }
// Return a pointer to the start of the data block // Return a pointer to the start of the data block
void *KRDataBlock::getStart() { void* KRDataBlock::getStart()
{
assertLocked(); assertLocked();
return m_data; return m_data;
} }
// Return a pointer to the byte after the end of the data block // Return a pointer to the byte after the end of the data block
void *KRDataBlock::getEnd() { void* KRDataBlock::getEnd()
{
assertLocked(); assertLocked();
return (unsigned char *)m_data + m_data_size; return (unsigned char*)m_data + m_data_size;
} }
// Return the size of the data block. Use append() or expand() to make the data block larger // Return the size of the data block. Use append() or expand() to make the data block larger
size_t KRDataBlock::getSize() const { size_t KRDataBlock::getSize() const
{
return m_data_size; return m_data_size;
} }
@@ -223,7 +229,7 @@ size_t KRDataBlock::getSize() const {
void KRDataBlock::expand(size_t size) void KRDataBlock::expand(size_t size)
{ {
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
if(m_data == NULL && m_hPackFile == INVALID_HANDLE_VALUE) { if (m_data == NULL && m_hPackFile == INVALID_HANDLE_VALUE) {
#elif defined(__APPLE__) || defined(ANDROID) #elif defined(__APPLE__) || defined(ANDROID)
if (m_data == NULL && m_fdPackFile == 0) { if (m_data == NULL && m_fdPackFile == 0) {
#else #else
@@ -235,14 +241,14 @@ void KRDataBlock::expand(size_t size)
m_data_size = size; m_data_size = size;
m_data_offset = 0; m_data_offset = 0;
m_bMalloced = true; m_bMalloced = true;
} else if(m_bMalloced) { } else if (m_bMalloced) {
// Starting with a malloc'ed data block; realloc it expand // Starting with a malloc'ed data block; realloc it expand
m_data = realloc(m_data, m_data_size + size); m_data = realloc(m_data, m_data_size + size);
m_data_size += size; m_data_size += size;
} else { } else {
// Starting with a mmap'ed data block, an encapsulated pointer, or a sub-block; copy it to ram before expanding to avoid updating the original file until save() is called // Starting with a mmap'ed data block, an encapsulated pointer, or a sub-block; copy it to ram before expanding to avoid updating the original file until save() is called
// ... Or starting with a pointer reference, we must make our own copy and must not free the pointer // ... Or starting with a pointer reference, we must make our own copy and must not free the pointer
void *pNewData = malloc(m_data_size + size); void* pNewData = malloc(m_data_size + size);
assert(pNewData != NULL); assert(pNewData != NULL);
// Copy exising data // Copy exising data
@@ -259,24 +265,27 @@ void KRDataBlock::expand(size_t size)
} }
// Append data to the end of the block, increasing the size of the block and making it read-write. // Append data to the end of the block, increasing the size of the block and making it read-write.
void KRDataBlock::append(void *data, size_t size) { void KRDataBlock::append(void* data, size_t size)
{
// Expand the data block // Expand the data block
expand(size); expand(size);
// Fill the new space with the data to append // Fill the new space with the data to append
lock(); lock();
memcpy((unsigned char *)m_data + m_data_size - size, data, size); memcpy((unsigned char*)m_data + m_data_size - size, data, size);
unlock(); unlock();
} }
// Copy the entire data block to the destination pointer // Copy the entire data block to the destination pointer
void KRDataBlock::copy(void *dest) { void KRDataBlock::copy(void* dest)
{
copy(dest, 0, (int)m_data_size); copy(dest, 0, (int)m_data_size);
} }
// Copy a range of data to the destination pointer // Copy a range of data to the destination pointer
void KRDataBlock::copy(void *dest, int start, int count) { void KRDataBlock::copy(void* dest, int start, int count)
{
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
if (m_lockCount == 0 && m_hPackFile != INVALID_HANDLE_VALUE) { if (m_lockCount == 0 && m_hPackFile != INVALID_HANDLE_VALUE) {
// Optimization: If we haven't mmap'ed or malloced the data already, ReadFile() it directly from the file into the buffer // Optimization: If we haven't mmap'ed or malloced the data already, ReadFile() it directly from the file into the buffer
@@ -285,19 +294,19 @@ void KRDataBlock::copy(void *dest, int start, int count) {
bool success = SetFilePointerEx(m_hPackFile, distance, NULL, FILE_BEGIN); bool success = SetFilePointerEx(m_hPackFile, distance, NULL, FILE_BEGIN);
assert(success); assert(success);
void *w = dest; void* w = dest;
DWORD bytes_remaining = count; DWORD bytes_remaining = count;
while(bytes_remaining > 0) { while (bytes_remaining > 0) {
DWORD bytes_read = 0; DWORD bytes_read = 0;
success = ReadFile(m_hPackFile, w, bytes_remaining, &bytes_read, NULL); success = ReadFile(m_hPackFile, w, bytes_remaining, &bytes_read, NULL);
assert(success); assert(success);
assert(bytes_read > 0); assert(bytes_read > 0);
w = (unsigned char *)w + bytes_read; w = (unsigned char*)w + bytes_read;
bytes_remaining -= bytes_read; bytes_remaining -= bytes_read;
} }
assert(bytes_remaining == 0); assert(bytes_remaining == 0);
#elif defined(__APPLE__) || defined(ANDROID) #elif defined(__APPLE__) || defined(ANDROID)
if(m_lockCount == 0 && m_fdPackFile != 0) { if (m_lockCount == 0 && m_fdPackFile != 0) {
// Optimization: If we haven't mmap'ed or malloced the data already, pread() it directly from the file into the buffer // Optimization: If we haven't mmap'ed or malloced the data already, pread() it directly from the file into the buffer
ssize_t r = pread(m_fdPackFile, dest, count, start + m_data_offset); ssize_t r = pread(m_fdPackFile, dest, count, start + m_data_offset);
assert(r != -1); assert(r != -1);
@@ -306,20 +315,21 @@ void KRDataBlock::copy(void *dest, int start, int count) {
#endif #endif
} else { } else {
lock(); lock();
memcpy((unsigned char *)dest, (unsigned char *)m_data + start, count); memcpy((unsigned char*)dest, (unsigned char*)m_data + start, count);
unlock(); unlock();
} }
} }
// Append data to the end of the block, increasing the size of the block and making it read-write. // Append data to the end of the block, increasing the size of the block and making it read-write.
void KRDataBlock::append(KRDataBlock &data) { void KRDataBlock::append(KRDataBlock & data)
{
data.lock(); data.lock();
append(data.getStart(), data.getSize()); append(data.getStart(), data.getSize());
data.unlock(); data.unlock();
} }
// Append string to the end of the block, increasing the size of the block and making it read-write. The resulting datablock includes a terminating character // Append string to the end of the block, increasing the size of the block and making it read-write. The resulting datablock includes a terminating character
void KRDataBlock::append(const std::string &s) void KRDataBlock::append(const std::string & s)
{ {
const char* szText = s.c_str(); const char* szText = s.c_str();
size_t text_length = strlen(szText); size_t text_length = strlen(szText);
@@ -339,12 +349,13 @@ void KRDataBlock::append(const std::string &s)
} }
// Save the data to a file. // Save the data to a file.
bool KRDataBlock::save(const std::string& path) { bool KRDataBlock::save(const std::string & path)
{
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
bool success = true; bool success = true;
HANDLE hNewFile = INVALID_HANDLE_VALUE; HANDLE hNewFile = INVALID_HANDLE_VALUE;
HANDLE hFileMapping = NULL; HANDLE hFileMapping = NULL;
void *pNewData = NULL; void* pNewData = NULL;
hNewFile = CreateFile(path.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); hNewFile = CreateFile(path.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hNewFile == INVALID_HANDLE_VALUE) { if (hNewFile == INVALID_HANDLE_VALUE) {
@@ -386,21 +397,21 @@ bool KRDataBlock::save(const std::string& path) {
#elif defined(__APPLE__) || defined(ANDROID) #elif defined(__APPLE__) || defined(ANDROID)
int fdNewFile = open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600); int fdNewFile = open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
if(fdNewFile == -1) { if (fdNewFile == -1) {
return false; return false;
} }
// Seek to end of file and write a byte to enlarge it // Seek to end of file and write a byte to enlarge it
lseek(fdNewFile, m_data_size-1, SEEK_SET); lseek(fdNewFile, m_data_size - 1, SEEK_SET);
write(fdNewFile, "", 1); write(fdNewFile, "", 1);
// Now map it... // Now map it...
void *pNewData = mmap(0, m_data_size, PROT_READ | PROT_WRITE, MAP_SHARED, fdNewFile, 0); void* pNewData = mmap(0, m_data_size, PROT_READ | PROT_WRITE, MAP_SHARED, fdNewFile, 0);
if(pNewData == (caddr_t) -1) { if (pNewData == (caddr_t)-1) {
close(fdNewFile); close(fdNewFile);
return false; return false;
} }
if(m_data != NULL) { if (m_data != NULL) {
// Copy data to new file // Copy data to new file
copy(pNewData); copy(pNewData);
@@ -422,9 +433,9 @@ std::string KRDataBlock::getString()
{ {
KRDataBlock b; KRDataBlock b;
b.append(*this); b.append(*this);
b.append((void *)"\0", 1); // Ensure data is null terminated, to read as a string safely b.append((void*)"\0", 1); // Ensure data is null terminated, to read as a string safely
b.lock(); b.lock();
std::string ret = std::string((char *)b.getStart()); std::string ret = std::string((char*)b.getStart());
b.unlock(); b.unlock();
return ret; return ret;
} }
@@ -462,17 +473,17 @@ void ReportWindowsLastError(LPCTSTR lpszFunction)
// Lock the memory, forcing it to be loaded into a contiguous block of address space // Lock the memory, forcing it to be loaded into a contiguous block of address space
void KRDataBlock::lock() void KRDataBlock::lock()
{ {
if(m_lockCount == 0) { if (m_lockCount == 0) {
// Memory mapped file; ensure data is mapped to ram // Memory mapped file; ensure data is mapped to ram
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
if(m_hPackFile != INVALID_HANDLE_VALUE) { if (m_hPackFile != INVALID_HANDLE_VALUE) {
#elif defined(__APPLE__) || defined(ANDROID) #elif defined(__APPLE__) || defined(ANDROID)
if(m_fdPackFile) { if (m_fdPackFile) {
#else #else
#error Unsupported #error Unsupported
#endif #endif
if(m_data_size < KRENGINE_MIN_MMAP) { if (m_data_size < KRENGINE_MIN_MMAP) {
m_data = malloc(m_data_size); m_data = malloc(m_data_size);
assert(m_data != NULL); assert(m_data != NULL);
copy(m_data); copy(m_data);
@@ -481,13 +492,13 @@ void KRDataBlock::lock()
assert(m_mmapData == NULL); assert(m_mmapData == NULL);
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
m_hFileMapping = CreateFileMappingFromApp(m_hPackFile, NULL, m_bReadOnly ? PAGE_READONLY : PAGE_READWRITE, m_fileOwnerDataBlock->getSize(), NULL); m_hFileMapping = CreateFileMappingFromApp(m_hPackFile, NULL, m_bReadOnly ? PAGE_READONLY : PAGE_READWRITE, m_fileOwnerDataBlock->getSize(), NULL);
if(m_hFileMapping == NULL) { if (m_hFileMapping == NULL) {
ReportWindowsLastError("CreateFileMappingFromApp"); ReportWindowsLastError("CreateFileMappingFromApp");
} }
assert(m_hFileMapping != NULL); assert(m_hFileMapping != NULL);
m_mmapData = MapViewOfFileFromApp(m_hFileMapping, m_bReadOnly ? FILE_MAP_READ | FILE_MAP_COPY : FILE_MAP_WRITE, m_data_offset - alignment_offset, m_data_size + alignment_offset); m_mmapData = MapViewOfFileFromApp(m_hFileMapping, m_bReadOnly ? FILE_MAP_READ | FILE_MAP_COPY : FILE_MAP_WRITE, m_data_offset - alignment_offset, m_data_size + alignment_offset);
if(m_mmapData == NULL) { if (m_mmapData == NULL) {
ReportWindowsLastError("MapViewOfFileFromApp"); ReportWindowsLastError("MapViewOfFileFromApp");
} }
assert(m_mmapData != NULL); assert(m_mmapData != NULL);
@@ -495,9 +506,9 @@ void KRDataBlock::lock()
//fprintf(stderr, "KRDataBlock::lock - \"%s\" (%i)\n", m_fileOwnerDataBlock->m_fileName.c_str(), m_lockCount); //fprintf(stderr, "KRDataBlock::lock - \"%s\" (%i)\n", m_fileOwnerDataBlock->m_fileName.c_str(), m_lockCount);
// Round m_data_offset down to the next memory page, as required by mmap // Round m_data_offset down to the next memory page, as required by mmap
if ((m_mmapData = mmap(0, m_data_size + alignment_offset, m_bReadOnly ? PROT_READ : PROT_WRITE, MAP_SHARED, m_fdPackFile, m_data_offset - alignment_offset)) == (caddr_t) -1) { if ((m_mmapData = mmap(0, m_data_size + alignment_offset, m_bReadOnly ? PROT_READ : PROT_WRITE, MAP_SHARED, m_fdPackFile, m_data_offset - alignment_offset)) == (caddr_t)-1) {
int iError = errno; int iError = errno;
switch(iError) { switch (iError) {
case EACCES: case EACCES:
KRContext::Log(KRContext::LOG_LEVEL_ERROR, "mmap failed with EACCES"); KRContext::Log(KRContext::LOG_LEVEL_ERROR, "mmap failed with EACCES");
break; break;
@@ -532,11 +543,11 @@ void KRDataBlock::lock()
m_mapSize += m_data_size; m_mapSize += m_data_size;
m_mapOverhead += alignment_offset + KRAKEN_MEM_ROUND_UP_PAGE(m_data_size + alignment_offset) - m_data_size + alignment_offset; m_mapOverhead += alignment_offset + KRAKEN_MEM_ROUND_UP_PAGE(m_data_size + alignment_offset) - m_data_size + alignment_offset;
// fprintf(stderr, "Mapped: %i Size: %d Overhead: %d\n", m_mapCount, m_mapSize, m_mapOverhead); // fprintf(stderr, "Mapped: %i Size: %d Overhead: %d\n", m_mapCount, m_mapSize, m_mapOverhead);
m_data = (unsigned char *)m_mmapData + alignment_offset; m_data = (unsigned char*)m_mmapData + alignment_offset;
} }
} }
} }
m_lockCount++; m_lockCount++;
} }
// Unlock the memory, releasing the address space for use by other allocations // Unlock the memory, releasing the address space for use by other allocations
@@ -546,17 +557,17 @@ void KRDataBlock::unlock()
assertLocked(); assertLocked();
if(m_lockCount == 1) { if (m_lockCount == 1) {
// Memory mapped file; ensure data is unmapped from ram // Memory mapped file; ensure data is unmapped from ram
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
if (m_hPackFile != INVALID_HANDLE_VALUE) { if (m_hPackFile != INVALID_HANDLE_VALUE) {
#elif defined(__APPLE__) || defined(ANDROID) #elif defined(__APPLE__) || defined(ANDROID)
if(m_fdPackFile) { if (m_fdPackFile) {
#else #else
#error Undefined #error Undefined
#endif #endif
if(m_data_size < KRENGINE_MIN_MMAP) { if (m_data_size < KRENGINE_MIN_MMAP) {
free(m_data); free(m_data);
m_data = NULL; m_data = NULL;
} else { } else {
@@ -565,7 +576,7 @@ void KRDataBlock::unlock()
if (m_mmapData != NULL) { if (m_mmapData != NULL) {
UnmapViewOfFile(m_mmapData); UnmapViewOfFile(m_mmapData);
} }
if(m_hFileMapping != NULL) { if (m_hFileMapping != NULL) {
CloseHandle(m_hFileMapping); CloseHandle(m_hFileMapping);
m_hFileMapping = NULL; m_hFileMapping = NULL;
} }
@@ -584,7 +595,7 @@ void KRDataBlock::unlock()
} }
} }
} }
m_lockCount--; m_lockCount--;
} }
// Assert if not locked // Assert if not locked

31
kraken/KRDataBlock.h
View File

@@ -39,32 +39,33 @@
#define KRENGINE_MIN_MMAP 32768 #define KRENGINE_MIN_MMAP 32768
class KRDataBlock { class KRDataBlock
{
public: public:
KRDataBlock(); KRDataBlock();
KRDataBlock(void *data, size_t size); KRDataBlock(void* data, size_t size);
~KRDataBlock(); ~KRDataBlock();
// Encapsulate a pointer. Note - The pointer will not be free'ed // Encapsulate a pointer. Note - The pointer will not be free'ed
bool load(void *data, size_t size); bool load(void* data, size_t size);
// Load a file into memory using mmap. The data pointer will be protected as read-only until append() or expand() is called // Load a file into memory using mmap. The data pointer will be protected as read-only until append() or expand() is called
bool load(const std::string &path); bool load(const std::string& path);
// Save the data to a file. // Save the data to a file.
bool save(const std::string& path); bool save(const std::string& path);
// Create a KRDataBlock encapsulating a sub-region of this block. The caller is responsible to free the object. // Create a KRDataBlock encapsulating a sub-region of this block. The caller is responsible to free the object.
KRDataBlock *getSubBlock(int start, int length); KRDataBlock* getSubBlock(int start, int length);
// Append data to the end of the block, increasing the size of the block and making it read-write. // Append data to the end of the block, increasing the size of the block and making it read-write.
void append(void *data, size_t size); void append(void* data, size_t size);
// Append data to the end of the block, increasing the size of the block and making it read-write. // Append data to the end of the block, increasing the size of the block and making it read-write.
void append(KRDataBlock &data); void append(KRDataBlock& data);
// Append string to the end of the block, increasing the size of the block and making it read-write. The null terminating character is included // Append string to the end of the block, increasing the size of the block and making it read-write. The null terminating character is included
void append(const std::string &s); void append(const std::string& s);
// Expand or shrink the data block, and switch it to read-write mode. Note - this may result in a mmap'ed file being copied to malloc'ed ram and then closed // Expand or shrink the data block, and switch it to read-write mode. Note - this may result in a mmap'ed file being copied to malloc'ed ram and then closed
void expand(size_t size); void expand(size_t size);
@@ -73,10 +74,10 @@ public:
void unload(); void unload();
// Return a pointer to the start of the data block // Return a pointer to the start of the data block
void *getStart(); void* getStart();
// Return a pointer to the one byte after the end of the data block // Return a pointer to the one byte after the end of the data block
void *getEnd(); void* getEnd();
// Return the size of the data block. Use append() or expand() to make the data block larger // Return the size of the data block. Use append() or expand() to make the data block larger
size_t getSize() const; size_t getSize() const;
@@ -85,10 +86,10 @@ public:
std::string getString(); std::string getString();
// Copy the entire data block to the destination pointer // Copy the entire data block to the destination pointer
void copy(void *dest); void copy(void* dest);
// Copy a range of data to the destination pointer // Copy a range of data to the destination pointer
void copy(void *dest, int start, int count); void copy(void* dest, int start, int count);
// Lock the memory, forcing it to be loaded into a contiguous block of address space // Lock the memory, forcing it to be loaded into a contiguous block of address space
void lock(); void lock();
@@ -97,7 +98,7 @@ public:
void unlock(); void unlock();
private: private:
void *m_data; void* m_data;
size_t m_data_size; size_t m_data_size;
size_t m_data_offset; size_t m_data_offset;
@@ -110,8 +111,8 @@ private:
#endif #endif
std::string m_fileName; std::string m_fileName;
KRDataBlock *m_fileOwnerDataBlock; KRDataBlock* m_fileOwnerDataBlock;
void *m_mmapData; void* m_mmapData;
// For malloc'ed objects: // For malloc'ed objects:
bool m_bMalloced; bool m_bMalloced;

2
kraken/KRDevice.cpp
View File

@@ -422,7 +422,7 @@ bool KRDevice::initStagingBuffer(VkDeviceSize size, StagingBufferInfo* info
#if KRENGINE_DEBUG_GPU_LABELS #if KRENGINE_DEBUG_GPU_LABELS
, const char* debug_label , const char* debug_label
#endif // KRENGINE_DEBUG_GPU_LABELS #endif // KRENGINE_DEBUG_GPU_LABELS
) )
{ {
if (!createBuffer( if (!createBuffer(
size, size,

5
kraken/KRDevice.h
View File

@@ -76,7 +76,7 @@ public:
void streamStart(); void streamStart();
void streamUpload(KRDataBlock& data, VkBuffer destination); void streamUpload(KRDataBlock& data, VkBuffer destination);
void streamUpload(void *data, size_t size, VkBuffer destination); void streamUpload(void* data, size_t size, VkBuffer destination);
void streamUpload(void* data, size_t size, Vector2i dimensions, VkImage destination); void streamUpload(void* data, size_t size, Vector2i dimensions, VkImage destination);
void streamEnd(); void streamEnd();
@@ -101,7 +101,8 @@ public:
std::vector<VkCommandBuffer> m_transferCommandBuffers; std::vector<VkCommandBuffer> m_transferCommandBuffers;
VmaAllocator m_allocator; VmaAllocator m_allocator;
struct StagingBufferInfo { struct StagingBufferInfo
{
VkBuffer buffer; VkBuffer buffer;
VmaAllocation allocation; VmaAllocation allocation;
size_t size; size_t size;

12
kraken/KRDeviceManager.cpp
View File

@@ -162,23 +162,19 @@ void KRDeviceManager::createDevices()
bool addDevice = false; bool addDevice = false;
if (candidateDevices.empty()) { if (candidateDevices.empty()) {
addDevice = true; addDevice = true;
} } else {
else {
VkPhysicalDeviceType collectedType = candidateDevices[0]->m_deviceProperties.deviceType; VkPhysicalDeviceType collectedType = candidateDevices[0]->m_deviceProperties.deviceType;
if (collectedType == device->m_deviceProperties.deviceType) { if (collectedType == device->m_deviceProperties.deviceType) {
addDevice = true; addDevice = true;
} } else if (device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
else if (device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
// Discrete GPU's are always the best choice // Discrete GPU's are always the best choice
candidateDevices.clear(); candidateDevices.clear();
addDevice = true; addDevice = true;
} } else if (collectedType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) {
else if (collectedType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) {
// Integrated GPU's are the second best choice // Integrated GPU's are the second best choice
candidateDevices.clear(); candidateDevices.clear();
addDevice = true; addDevice = true;
} } else if (collectedType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && collectedType != VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU && device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) {
else if (collectedType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && collectedType != VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU && device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) {
// Virtual GPU's are the 3rd best choice // Virtual GPU's are the 3rd best choice
candidateDevices.clear(); candidateDevices.clear();
addDevice = true; addDevice = true;

33
kraken/KRDirectionalLight.cpp
View File

@@ -43,7 +43,7 @@ void KRDirectionalLight::InitNodeInfo(KrNodeInfo* nodeInfo)
// No additional members // No additional members
} }
KRDirectionalLight::KRDirectionalLight(KRScene &scene, std::string name) : KRLight(scene, name) KRDirectionalLight::KRDirectionalLight(KRScene& scene, std::string name) : KRLight(scene, name)
{ {
} }
@@ -53,24 +53,28 @@ KRDirectionalLight::~KRDirectionalLight()
} }
std::string KRDirectionalLight::getElementName() { std::string KRDirectionalLight::getElementName()
{
return "directional_light"; return "directional_light";
} }
Vector3 KRDirectionalLight::getWorldLightDirection() { Vector3 KRDirectionalLight::getWorldLightDirection()
{
return Matrix4::Dot(getWorldRotation().rotationMatrix(), getLocalLightDirection()); return Matrix4::Dot(getWorldRotation().rotationMatrix(), getLocalLightDirection());
} }
Vector3 KRDirectionalLight::getLocalLightDirection() { Vector3 KRDirectionalLight::getLocalLightDirection()
{
return Vector3::Up(); //&KRF HACK changed from Vector3::Forward(); - to compensate for the way Maya handles post rotation. return Vector3::Up(); //&KRF HACK changed from Vector3::Forward(); - to compensate for the way Maya handles post rotation.
} }
int KRDirectionalLight::configureShadowBufferViewports(const KRViewport &viewport) { int KRDirectionalLight::configureShadowBufferViewports(const KRViewport& viewport)
{
const float KRENGINE_SHADOW_BOUNDS_EXTRA_SCALE = 1.25f; // Scale to apply to view frustrum bounds so that we don't need to refresh shadows on every frame const float KRENGINE_SHADOW_BOUNDS_EXTRA_SCALE = 1.25f; // Scale to apply to view frustrum bounds so that we don't need to refresh shadows on every frame
int cShadows = 1; int cShadows = 1;
for(int iShadow=0; iShadow < cShadows; iShadow++) { for (int iShadow = 0; iShadow < cShadows; iShadow++) {
/* /*
TODO - Determine if we still need this... TODO - Determine if we still need this...
@@ -87,7 +91,7 @@ int KRDirectionalLight::configureShadowBufferViewports(const KRViewport &viewpor
Vector3 shadowLook = -Vector3::Normalize(getWorldLightDirection()); Vector3 shadowLook = -Vector3::Normalize(getWorldLightDirection());
Vector3 shadowUp = Vector3::Create(0.0, 1.0, 0.0); Vector3 shadowUp = Vector3::Create(0.0, 1.0, 0.0);
if(Vector3::Dot(shadowUp, shadowLook) > 0.99f) shadowUp = Vector3::Create(0.0, 0.0, 1.0); // Ensure shadow look direction is not parallel with the shadowUp direction if (Vector3::Dot(shadowUp, shadowLook) > 0.99f) shadowUp = Vector3::Create(0.0, 0.0, 1.0); // Ensure shadow look direction is not parallel with the shadowUp direction
// Matrix4 matShadowView = Matrix4::LookAt(viewport.getCameraPosition() - shadowLook, viewport.getCameraPosition(), shadowUp); // Matrix4 matShadowView = Matrix4::LookAt(viewport.getCameraPosition() - shadowLook, viewport.getCameraPosition(), shadowUp);
// Matrix4 matShadowProjection = Matrix4(); // Matrix4 matShadowProjection = Matrix4();
@@ -97,7 +101,7 @@ int KRDirectionalLight::configureShadowBufferViewports(const KRViewport &viewpor
Matrix4 matShadowProjection = Matrix4(); Matrix4 matShadowProjection = Matrix4();
AABB shadowSpaceFrustrumSliceBounds = AABB::Create(worldSpacefrustrumSliceBounds.min, worldSpacefrustrumSliceBounds.max, Matrix4::Invert(matShadowProjection)); AABB shadowSpaceFrustrumSliceBounds = AABB::Create(worldSpacefrustrumSliceBounds.min, worldSpacefrustrumSliceBounds.max, Matrix4::Invert(matShadowProjection));
AABB shadowSpaceSceneBounds = AABB::Create(getScene().getRootOctreeBounds().min, getScene().getRootOctreeBounds().max, Matrix4::Invert(matShadowProjection)); AABB shadowSpaceSceneBounds = AABB::Create(getScene().getRootOctreeBounds().min, getScene().getRootOctreeBounds().max, Matrix4::Invert(matShadowProjection));
if(shadowSpaceSceneBounds.min.z < shadowSpaceFrustrumSliceBounds.min.z) shadowSpaceFrustrumSliceBounds.min.z = shadowSpaceSceneBounds.min.z; // Include any potential shadow casters that are outside the view frustrum if (shadowSpaceSceneBounds.min.z < shadowSpaceFrustrumSliceBounds.min.z) shadowSpaceFrustrumSliceBounds.min.z = shadowSpaceSceneBounds.min.z; // Include any potential shadow casters that are outside the view frustrum
matShadowProjection.scale(1.0f / shadowSpaceFrustrumSliceBounds.size().x, 1.0f / shadowSpaceFrustrumSliceBounds.size().y, 1.0f / shadowSpaceFrustrumSliceBounds.size().z); matShadowProjection.scale(1.0f / shadowSpaceFrustrumSliceBounds.size().x, 1.0f / shadowSpaceFrustrumSliceBounds.size().y, 1.0f / shadowSpaceFrustrumSliceBounds.size().z);
Matrix4 matBias; Matrix4 matBias;
@@ -108,7 +112,7 @@ int KRDirectionalLight::configureShadowBufferViewports(const KRViewport &viewpor
AABB prevShadowBounds = AABB::Create(-Vector3::One(), Vector3::One(), Matrix4::Invert(m_shadowViewports[iShadow].getViewProjectionMatrix())); AABB prevShadowBounds = AABB::Create(-Vector3::One(), Vector3::One(), Matrix4::Invert(m_shadowViewports[iShadow].getViewProjectionMatrix()));
AABB minimumShadowBounds = AABB::Create(-Vector3::One(), Vector3::One(), Matrix4::Invert(newShadowViewport.getViewProjectionMatrix())); AABB minimumShadowBounds = AABB::Create(-Vector3::One(), Vector3::One(), Matrix4::Invert(newShadowViewport.getViewProjectionMatrix()));
minimumShadowBounds.scale(1.0f / KRENGINE_SHADOW_BOUNDS_EXTRA_SCALE); minimumShadowBounds.scale(1.0f / KRENGINE_SHADOW_BOUNDS_EXTRA_SCALE);
if(!prevShadowBounds.contains(minimumShadowBounds) || !shadowValid[iShadow] || true) { // FINDME, HACK - Re-generating the shadow map every frame. This should only be needed if the shadow contains non-static geometry if (!prevShadowBounds.contains(minimumShadowBounds) || !shadowValid[iShadow] || true) { // FINDME, HACK - Re-generating the shadow map every frame. This should only be needed if the shadow contains non-static geometry
m_shadowViewports[iShadow] = newShadowViewport; m_shadowViewports[iShadow] = newShadowViewport;
shadowValid[iShadow] = false; shadowValid[iShadow] = false;
fprintf(stderr, "Kraken - Generate shadow maps...\n"); fprintf(stderr, "Kraken - Generate shadow maps...\n");
@@ -118,16 +122,17 @@ int KRDirectionalLight::configureShadowBufferViewports(const KRViewport &viewpor
return 1; return 1;
} }
void KRDirectionalLight::render(RenderInfo& ri) { void KRDirectionalLight::render(RenderInfo& ri)
{
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRLight::render(ri); KRLight::render(ri);
if(ri.renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS) { if (ri.renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS) {
// Lights are rendered on the second pass of the deferred renderer // Lights are rendered on the second pass of the deferred renderer
std::vector<KRDirectionalLight *> this_light; std::vector<KRDirectionalLight*> this_light;
this_light.push_back(this); this_light.push_back(this);
Matrix4 matModelViewInverseTranspose = ri.viewport.getViewMatrix() * getModelMatrix(); Matrix4 matModelViewInverseTranspose = ri.viewport.getViewMatrix() * getModelMatrix();
@@ -151,7 +156,7 @@ void KRDirectionalLight::render(RenderInfo& ri) {
info.vertexAttributes = vertices.getVertexAttributes(); info.vertexAttributes = vertices.getVertexAttributes();
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->setUniform(KRPipeline::Uniform::light_direction_view_space, light_direction_view_space); pShader->setUniform(KRPipeline::Uniform::light_direction_view_space, light_direction_view_space);
pShader->setUniform(KRPipeline::Uniform::light_color, m_color); pShader->setUniform(KRPipeline::Uniform::light_color, m_color);
pShader->setUniform(KRPipeline::Uniform::light_intensity, m_intensity * 0.01f); pShader->setUniform(KRPipeline::Uniform::light_intensity, m_intensity * 0.01f);

7
kraken/KRDirectionalLight.h
View File

@@ -33,12 +33,13 @@
#include "KRLight.h" #include "KRLight.h"
class KRDirectionalLight : public KRLight { class KRDirectionalLight : public KRLight
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRDirectionalLight(KRScene &scene, std::string name); KRDirectionalLight(KRScene& scene, std::string name);
virtual ~KRDirectionalLight(); virtual ~KRDirectionalLight();
virtual std::string getElementName(); virtual std::string getElementName();
@@ -50,7 +51,7 @@ public:
protected: protected:
virtual int configureShadowBufferViewports(const KRViewport &viewport); virtual int configureShadowBufferViewports(const KRViewport& viewport);
}; };

3
kraken/KREngine-common.h
View File

@@ -253,7 +253,8 @@ fprintf(stderr, "Error at line number %d, in file %s. Returned %d for call %s\n"
#endif #endif
typedef enum { typedef enum
{
STREAM_LEVEL_OUT, STREAM_LEVEL_OUT,
STREAM_LEVEL_IN_LQ, STREAM_LEVEL_IN_LQ,
STREAM_LEVEL_IN_HQ STREAM_LEVEL_IN_HQ

39
kraken/KREngine.h
View File

@@ -37,43 +37,46 @@
#include "KREngine-common.h" #include "KREngine-common.h"
typedef enum KREngineParameterType {KRENGINE_PARAMETER_INT, KRENGINE_PARAMETER_FLOAT, KRENGINE_PARAMETER_BOOL} KREngineParameterType; typedef enum KREngineParameterType
{
KRENGINE_PARAMETER_INT, KRENGINE_PARAMETER_FLOAT, KRENGINE_PARAMETER_BOOL
} KREngineParameterType;
namespace kraken { namespace kraken {
void set_parameter(const std::string &parameter_name, float parameter_value); void set_parameter(const std::string& parameter_name, float parameter_value);
void set_debug_text(const std::string &print_text); void set_debug_text(const std::string& print_text);
}; };
#ifdef __OBJC__ #ifdef __OBJC__
@interface KREngine : NSObject @interface KREngine : NSObject
+ (KREngine *)sharedInstance; + (KREngine*)sharedInstance;
@property(nonatomic, readonly) NSDictionary *parameter_names; @property(nonatomic, readonly) NSDictionary* parameter_names;
@property(nonatomic, assign) KRContext *context; @property(nonatomic, assign) KRContext* context;
@property(nonatomic, retain) NSString *debug_text; @property(nonatomic, retain) NSString* debug_text;
@property(nonatomic, assign, readonly) KRRenderSettings *settings; @property(nonatomic, assign, readonly) KRRenderSettings* settings;
- (id)init; -(id)init;
- (BOOL)loadResource:(NSString *)path; -(BOOL)loadResource:(NSString*)path;
// Parameter enumeration interface // Parameter enumeration interface
-(int)getParameterCount; -(int)getParameterCount;
-(NSString *)getParameterNameWithIndex: (int)i; -(NSString*)getParameterNameWithIndex: (int)i;
-(NSString *)getParameterLabelWithIndex: (int)i; -(NSString*)getParameterLabelWithIndex: (int)i;
-(KREngineParameterType)getParameterTypeWithIndex: (int)i; -(KREngineParameterType)getParameterTypeWithIndex: (int)i;
-(float)getParameterMinWithIndex: (int)i; -(float)getParameterMinWithIndex: (int)i;
-(float)getParameterMaxWithIndex: (int)i; -(float)getParameterMaxWithIndex: (int)i;
-(float)getParameterValueWithIndex: (int)i; -(float)getParameterValueWithIndex: (int)i;
-(void)setParameterValueWithIndex: (int)i Value: (float)v; -(void)setParameterValueWithIndex: (int)i Value : (float)v;
-(void)setParameterValueWithName: (NSString *)name Value: (float)v; -(void)setParameterValueWithName: (NSString*)name Value : (float)v;
-(int)getParameterIndexWithName: (NSString *)name; -(int)getParameterIndexWithName: (NSString*)name;
- (void)renderScene: (KRScene *)pScene WithDeltaTime: (float)deltaTime AndWidth: (int)width AndHeight: (int)height AndDefaultFBO: (GLint)defaultFBO; -(void)renderScene: (KRScene*)pScene WithDeltaTime : (float)deltaTime AndWidth : (int)width AndHeight : (int)height AndDefaultFBO : (GLint)defaultFBO;
//- (void)renderScene: (KRScene *)pScene WithDeltaTime: (float)deltaTime; //- (void)renderScene: (KRScene *)pScene WithDeltaTime: (float)deltaTime;
- (void)setNearZ: (float)dNearZ; -(void)setNearZ: (float)dNearZ;
- (void)setFarZ: (float)dFarZ; -(void)setFarZ: (float)dFarZ;
@end @end

4
kraken/KRHelpers.cpp
View File

@@ -35,7 +35,7 @@
namespace kraken { namespace kraken {
void setXMLAttribute(const std::string &base_name, tinyxml2::XMLElement *e, const Vector3 &value, const Vector3 &default_value) void setXMLAttribute(const std::string& base_name, tinyxml2::XMLElement* e, const Vector3& value, const Vector3& default_value)
{ {
// TODO - Increase number of digits after the decimal in floating point format (6 -> 12?) // TODO - Increase number of digits after the decimal in floating point format (6 -> 12?)
// FINDME, TODO - This needs optimization... // FINDME, TODO - This needs optimization...
@@ -46,7 +46,7 @@ void setXMLAttribute(const std::string &base_name, tinyxml2::XMLElement *e, cons
} }
} }
const Vector3 getXMLAttribute(const std::string &base_name, tinyxml2::XMLElement *e, const Vector3 &default_value) const Vector3 getXMLAttribute(const std::string& base_name, tinyxml2::XMLElement* e, const Vector3& default_value)
{ {
Vector3 value; Vector3 value;
if (e->QueryFloatAttribute((base_name + "_x").c_str(), &value.x) == tinyxml2::XML_SUCCESS if (e->QueryFloatAttribute((base_name + "_x").c_str(), &value.x) == tinyxml2::XML_SUCCESS

4
kraken/KRHelpers.h
View File

@@ -60,7 +60,7 @@ float const PI = 3.141592653589793f;
float const D2R = PI * 2 / 360; float const D2R = PI * 2 / 360;
namespace kraken { namespace kraken {
void setXMLAttribute(const std::string &base_name, ::tinyxml2::XMLElement *e, const Vector3 &value, const Vector3 &default_value); void setXMLAttribute(const std::string& base_name, ::tinyxml2::XMLElement* e, const Vector3& value, const Vector3& default_value);
const Vector3 getXMLAttribute(const std::string &base_name, ::tinyxml2::XMLElement *e, const Vector3 &default_value); const Vector3 getXMLAttribute(const std::string& base_name, ::tinyxml2::XMLElement* e, const Vector3& default_value);
} // namespace kraken } // namespace kraken

54
kraken/KRLODGroup.cpp
View File

@@ -44,7 +44,7 @@ void KRLODGroup::InitNodeInfo(KrNodeInfo* nodeInfo)
nodeInfo->lod_group.use_world_units = true; nodeInfo->lod_group.use_world_units = true;
} }
KRLODGroup::KRLODGroup(KRScene &scene, std::string name) : KRNode(scene, name) KRLODGroup::KRLODGroup(KRScene& scene, std::string name) : KRNode(scene, name)
{ {
m_min_distance = 0.0f; m_min_distance = 0.0f;
m_max_distance = 0.0f; m_max_distance = 0.0f;
@@ -53,16 +53,16 @@ KRLODGroup::KRLODGroup(KRScene &scene, std::string name) : KRNode(scene, name)
} }
KRLODGroup::~KRLODGroup() KRLODGroup::~KRLODGroup()
{ {}
}
std::string KRLODGroup::getElementName() { std::string KRLODGroup::getElementName()
{
return "lod_group"; return "lod_group";
} }
tinyxml2::XMLElement *KRLODGroup::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRLODGroup::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
e->SetAttribute("min_distance", m_min_distance); e->SetAttribute("min_distance", m_min_distance);
e->SetAttribute("max_distance", m_max_distance); e->SetAttribute("max_distance", m_max_distance);
@@ -79,66 +79,66 @@ tinyxml2::XMLElement *KRLODGroup::saveXML( tinyxml2::XMLNode *parent)
return e; return e;
} }
void KRLODGroup::loadXML(tinyxml2::XMLElement *e) void KRLODGroup::loadXML(tinyxml2::XMLElement* e)
{ {
KRNode::loadXML(e); KRNode::loadXML(e);
m_min_distance = 0.0f; m_min_distance = 0.0f;
if(e->QueryFloatAttribute("min_distance", &m_min_distance) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("min_distance", &m_min_distance) != tinyxml2::XML_SUCCESS) {
m_min_distance = 0.0f; m_min_distance = 0.0f;
} }
m_max_distance = 0.0f; m_max_distance = 0.0f;
if(e->QueryFloatAttribute("max_distance", &m_max_distance) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("max_distance", &m_max_distance) != tinyxml2::XML_SUCCESS) {
m_max_distance = 0.0f; m_max_distance = 0.0f;
} }
float x=0.0f, y=0.0f, z=0.0f; float x = 0.0f, y = 0.0f, z = 0.0f;
if(e->QueryFloatAttribute("reference_min_x", &x) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("reference_min_x", &x) != tinyxml2::XML_SUCCESS) {
x = 0.0f; x = 0.0f;
} }
if(e->QueryFloatAttribute("reference_min_y", &y) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("reference_min_y", &y) != tinyxml2::XML_SUCCESS) {
y = 0.0f; y = 0.0f;
} }
if(e->QueryFloatAttribute("reference_min_z", &z) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("reference_min_z", &z) != tinyxml2::XML_SUCCESS) {
z = 0.0f; z = 0.0f;
} }
m_reference.min = Vector3::Create(x,y,z); m_reference.min = Vector3::Create(x, y, z);
x=0.0f; y=0.0f; z=0.0f; x = 0.0f; y = 0.0f; z = 0.0f;
if(e->QueryFloatAttribute("reference_max_x", &x) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("reference_max_x", &x) != tinyxml2::XML_SUCCESS) {
x = 0.0f; x = 0.0f;
} }
if(e->QueryFloatAttribute("reference_max_y", &y) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("reference_max_y", &y) != tinyxml2::XML_SUCCESS) {
y = 0.0f; y = 0.0f;
} }
if(e->QueryFloatAttribute("reference_max_z", &z) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("reference_max_z", &z) != tinyxml2::XML_SUCCESS) {
z = 0.0f; z = 0.0f;
} }
m_reference.max = Vector3::Create(x,y,z); m_reference.max = Vector3::Create(x, y, z);
m_use_world_units = true; m_use_world_units = true;
if(e->QueryBoolAttribute("use_world_units", &m_use_world_units) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("use_world_units", &m_use_world_units) != tinyxml2::XML_SUCCESS) {
m_use_world_units = true; m_use_world_units = true;
} }
} }
const AABB &KRLODGroup::getReference() const const AABB& KRLODGroup::getReference() const
{ {
return m_reference; return m_reference;
} }
void KRLODGroup::setReference(const AABB &reference) void KRLODGroup::setReference(const AABB& reference)
{ {
m_reference = reference; m_reference = reference;
} }
KRNode::LodVisibility KRLODGroup::calcLODVisibility(const KRViewport &viewport) KRNode::LodVisibility KRLODGroup::calcLODVisibility(const KRViewport& viewport)
{ {
if(m_min_distance == 0 && m_max_distance == 0) { if (m_min_distance == 0 && m_max_distance == 0) {
return LOD_VISIBILITY_VISIBLE; return LOD_VISIBILITY_VISIBLE;
} else { } else {
float lod_bias = viewport.getLODBias(); float lod_bias = viewport.getLODBias();
@@ -152,7 +152,7 @@ KRNode::LodVisibility KRLODGroup::calcLODVisibility(const KRViewport &viewport)
Vector3 local_camera_position = worldToLocal(world_camera_position); Vector3 local_camera_position = worldToLocal(world_camera_position);
Vector3 local_reference_point = m_reference.nearestPoint(local_camera_position); Vector3 local_reference_point = m_reference.nearestPoint(local_camera_position);
if(m_use_world_units) { if (m_use_world_units) {
Vector3 world_reference_point = localToWorld(local_reference_point); Vector3 world_reference_point = localToWorld(local_reference_point);
sqr_distance = (world_camera_position - world_reference_point).sqrMagnitude() * (lod_bias * lod_bias); sqr_distance = (world_camera_position - world_reference_point).sqrMagnitude() * (lod_bias * lod_bias);
sqr_prestream_distance = (float)(getContext().KRENGINE_PRESTREAM_DISTANCE * getContext().KRENGINE_PRESTREAM_DISTANCE); sqr_prestream_distance = (float)(getContext().KRENGINE_PRESTREAM_DISTANCE * getContext().KRENGINE_PRESTREAM_DISTANCE);
@@ -166,9 +166,9 @@ KRNode::LodVisibility KRLODGroup::calcLODVisibility(const KRViewport &viewport)
float sqr_min_visible_distance = m_min_distance * m_min_distance; float sqr_min_visible_distance = m_min_distance * m_min_distance;
float sqr_max_visible_distance = m_max_distance * m_max_distance; float sqr_max_visible_distance = m_max_distance * m_max_distance;
if((sqr_distance >= sqr_min_visible_distance || m_min_distance == 0) && (sqr_distance < sqr_max_visible_distance || m_max_distance == 0)) { if ((sqr_distance >= sqr_min_visible_distance || m_min_distance == 0) && (sqr_distance < sqr_max_visible_distance || m_max_distance == 0)) {
return LOD_VISIBILITY_VISIBLE; return LOD_VISIBILITY_VISIBLE;
} else if((sqr_distance >= sqr_min_visible_distance - sqr_prestream_distance || m_min_distance == 0) && (sqr_distance < sqr_max_visible_distance + sqr_prestream_distance || m_max_distance == 0)) { } else if ((sqr_distance >= sqr_min_visible_distance - sqr_prestream_distance || m_min_distance == 0) && (sqr_distance < sqr_max_visible_distance + sqr_prestream_distance || m_max_distance == 0)) {
return LOD_VISIBILITY_PRESTREAM; return LOD_VISIBILITY_PRESTREAM;
} else { } else {
return LOD_VISIBILITY_HIDDEN; return LOD_VISIBILITY_HIDDEN;

15
kraken/KRLODGroup.h
View File

@@ -34,26 +34,27 @@
#include "KRResource.h" #include "KRResource.h"
#include "KRNode.h" #include "KRNode.h"
class KRLODGroup : public KRNode { class KRLODGroup : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRLODGroup(KRScene &scene, std::string name); KRLODGroup(KRScene& scene, std::string name);
virtual ~KRLODGroup(); virtual ~KRLODGroup();
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
float getMinDistance(); float getMinDistance();
float getMaxDistance(); float getMaxDistance();
void setMinDistance(float min_distance); void setMinDistance(float min_distance);
void setMaxDistance(float max_distance); void setMaxDistance(float max_distance);
const AABB &getReference() const; const AABB& getReference() const;
void setReference(const AABB &reference); void setReference(const AABB& reference);
void setUseWorldUnits(bool use_world_units); void setUseWorldUnits(bool use_world_units);
bool getUseWorldUnits() const; bool getUseWorldUnits() const;
LodVisibility calcLODVisibility(const KRViewport &viewport); LodVisibility calcLODVisibility(const KRViewport& viewport);
private: private:
float m_min_distance; float m_min_distance;

46
kraken/KRLODSet.cpp
View File

@@ -40,43 +40,43 @@ void KRLODSet::InitNodeInfo(KrNodeInfo* nodeInfo)
// No additional members // No additional members
} }
KRLODSet::KRLODSet(KRScene &scene, std::string name) : KRNode(scene, name) KRLODSet::KRLODSet(KRScene& scene, std::string name) : KRNode(scene, name)
{ {
} }
KRLODSet::~KRLODSet() KRLODSet::~KRLODSet()
{ {}
}
std::string KRLODSet::getElementName() { std::string KRLODSet::getElementName()
{
return "lod_set"; return "lod_set";
} }
tinyxml2::XMLElement *KRLODSet::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRLODSet::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
return e; return e;
} }
void KRLODSet::loadXML(tinyxml2::XMLElement *e) void KRLODSet::loadXML(tinyxml2::XMLElement* e)
{ {
KRNode::loadXML(e); KRNode::loadXML(e);
} }
void KRLODSet::updateLODVisibility(const KRViewport &viewport) void KRLODSet::updateLODVisibility(const KRViewport& viewport)
{ {
if(m_lod_visible >= LOD_VISIBILITY_PRESTREAM) { if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM) {
/* /*
// FINDME, TODO, HACK - Disabled streamer delayed LOD load due to performance issues: // FINDME, TODO, HACK - Disabled streamer delayed LOD load due to performance issues:
KRLODGroup *new_active_lod_group = NULL; KRLODGroup *new_active_lod_group = NULL;
*/ */
// Upgrade and downgrade LOD groups as needed // Upgrade and downgrade LOD groups as needed
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
KRLODGroup *lod_group = dynamic_cast<KRLODGroup *>(*itr); KRLODGroup* lod_group = dynamic_cast<KRLODGroup*>(*itr);
assert(lod_group != NULL); assert(lod_group != NULL);
LodVisibility group_lod_visibility = KRMIN(lod_group->calcLODVisibility(viewport), m_lod_visible); LodVisibility group_lod_visibility = KRMIN(lod_group->calcLODVisibility(viewport), m_lod_visible);
/* /*
@@ -99,10 +99,10 @@ void KRLODSet::updateLODVisibility(const KRViewport &viewport)
*/ */
bool streamer_ready = true; bool streamer_ready = true;
if(streamer_ready) { if (streamer_ready) {
// Upgrade and downgrade LOD groups as needed // Upgrade and downgrade LOD groups as needed
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
KRLODGroup *lod_group = dynamic_cast<KRLODGroup *>(*itr); KRLODGroup* lod_group = dynamic_cast<KRLODGroup*>(*itr);
assert(lod_group != NULL); assert(lod_group != NULL);
LodVisibility group_lod_visibility = KRMIN(lod_group->calcLODVisibility(viewport), m_lod_visible); LodVisibility group_lod_visibility = KRMIN(lod_group->calcLODVisibility(viewport), m_lod_visible);
lod_group->setLODVisibility(group_lod_visibility); lod_group->setLODVisibility(group_lod_visibility);
@@ -115,31 +115,31 @@ void KRLODSet::updateLODVisibility(const KRViewport &viewport)
void KRLODSet::setLODVisibility(KRNode::LodVisibility lod_visibility) void KRLODSet::setLODVisibility(KRNode::LodVisibility lod_visibility)
{ {
if(lod_visibility == LOD_VISIBILITY_HIDDEN) { if (lod_visibility == LOD_VISIBILITY_HIDDEN) {
KRNode::setLODVisibility(lod_visibility); KRNode::setLODVisibility(lod_visibility);
} else if(m_lod_visible != lod_visibility) { } else if (m_lod_visible != lod_visibility) {
// Don't automatically recurse into our children, as only one of those will be activated, by updateLODVisibility // Don't automatically recurse into our children, as only one of those will be activated, by updateLODVisibility
if(m_lod_visible == LOD_VISIBILITY_HIDDEN && lod_visibility >= LOD_VISIBILITY_PRESTREAM) { if (m_lod_visible == LOD_VISIBILITY_HIDDEN && lod_visibility >= LOD_VISIBILITY_PRESTREAM) {
getScene().notify_sceneGraphCreate(this); getScene().notify_sceneGraphCreate(this);
} }
m_lod_visible = lod_visibility; m_lod_visible = lod_visibility;
} }
} }
kraken_stream_level KRLODSet::getStreamLevel(const KRViewport &viewport) kraken_stream_level KRLODSet::getStreamLevel(const KRViewport& viewport)
{ {
KRLODGroup *new_active_lod_group = NULL; KRLODGroup* new_active_lod_group = NULL;
// Upgrade and downgrade LOD groups as needed // Upgrade and downgrade LOD groups as needed
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
KRLODGroup *lod_group = dynamic_cast<KRLODGroup *>(*itr); KRLODGroup* lod_group = dynamic_cast<KRLODGroup*>(*itr);
assert(lod_group != NULL); assert(lod_group != NULL);
if(lod_group->calcLODVisibility(viewport) == LOD_VISIBILITY_VISIBLE) { if (lod_group->calcLODVisibility(viewport) == LOD_VISIBILITY_VISIBLE) {
new_active_lod_group = lod_group; new_active_lod_group = lod_group;
} }
} }
if(new_active_lod_group) { if (new_active_lod_group) {
return new_active_lod_group->getStreamLevel(viewport); return new_active_lod_group->getStreamLevel(viewport);
} else { } else {
return kraken_stream_level::STREAM_LEVEL_IN_HQ; return kraken_stream_level::STREAM_LEVEL_IN_HQ;

13
kraken/KRLODSet.h
View File

@@ -36,18 +36,19 @@
class KRLODGroup; class KRLODGroup;
class KRLODSet : public KRNode { class KRLODSet : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRLODSet(KRScene &scene, std::string name); KRLODSet(KRScene& scene, std::string name);
virtual ~KRLODSet(); virtual ~KRLODSet();
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
virtual void updateLODVisibility(const KRViewport &viewport); virtual void updateLODVisibility(const KRViewport& viewport);
virtual void setLODVisibility(LodVisibility lod_visibility); virtual void setLODVisibility(LodVisibility lod_visibility);
virtual kraken_stream_level getStreamLevel(const KRViewport &viewport); virtual kraken_stream_level getStreamLevel(const KRViewport& viewport);
}; };

184
kraken/KRLight.cpp
View File

@@ -60,7 +60,7 @@ void KRLight::InitNodeInfo(KrNodeInfo* nodeInfo)
nodeInfo->light.light_shafts = true; nodeInfo->light.light_shafts = true;
} }
KRLight::KRLight(KRScene &scene, std::string name) : KRNode(scene, name) KRLight::KRLight(KRScene& scene, std::string name) : KRNode(scene, name)
{ {
m_intensity = 1.0f; m_intensity = 1.0f;
m_dust_particle_intensity = 1.0f; m_dust_particle_intensity = 1.0f;
@@ -79,7 +79,7 @@ KRLight::KRLight(KRScene &scene, std::string name) : KRNode(scene, name)
// Initialize shadow buffers // Initialize shadow buffers
m_cShadowBuffers = 0; m_cShadowBuffers = 0;
for(int iBuffer=0; iBuffer < KRENGINE_MAX_SHADOW_BUFFERS; iBuffer++) { for (int iBuffer = 0; iBuffer < KRENGINE_MAX_SHADOW_BUFFERS; iBuffer++) {
shadowFramebuffer[iBuffer] = 0; shadowFramebuffer[iBuffer] = 0;
shadowDepthTexture[iBuffer] = 0; shadowDepthTexture[iBuffer] = 0;
shadowValid[iBuffer] = false; shadowValid[iBuffer] = false;
@@ -88,16 +88,16 @@ KRLight::KRLight(KRScene &scene, std::string name) : KRNode(scene, name)
KRLight::~KRLight() KRLight::~KRLight()
{ {
if(m_occlusionQuery) { if (m_occlusionQuery) {
GLDEBUG(glDeleteQueriesEXT(1, &m_occlusionQuery)); GLDEBUG(glDeleteQueriesEXT(1, &m_occlusionQuery));
m_occlusionQuery = 0; m_occlusionQuery = 0;
} }
allocateShadowBuffers(0); allocateShadowBuffers(0);
} }
tinyxml2::XMLElement *KRLight::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRLight::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
e->SetAttribute("intensity", m_intensity); e->SetAttribute("intensity", m_intensity);
e->SetAttribute("color_r", m_color.x); e->SetAttribute("color_r", m_color.x);
e->SetAttribute("color_g", m_color.y); e->SetAttribute("color_g", m_color.y);
@@ -114,61 +114,62 @@ tinyxml2::XMLElement *KRLight::saveXML( tinyxml2::XMLNode *parent)
return e; return e;
} }
void KRLight::loadXML(tinyxml2::XMLElement *e) { void KRLight::loadXML(tinyxml2::XMLElement* e)
{
KRNode::loadXML(e); KRNode::loadXML(e);
float x=1.0f,y=1.0f,z=1.0f; float x = 1.0f, y = 1.0f, z = 1.0f;
if(e->QueryFloatAttribute("color_r", &x) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("color_r", &x) != tinyxml2::XML_SUCCESS) {
x = 1.0; x = 1.0;
} }
if(e->QueryFloatAttribute("color_g", &y) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("color_g", &y) != tinyxml2::XML_SUCCESS) {
y = 1.0; y = 1.0;
} }
if(e->QueryFloatAttribute("color_b", &z) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("color_b", &z) != tinyxml2::XML_SUCCESS) {
z = 1.0; z = 1.0;
} }
m_color = Vector3::Create(x,y,z); m_color = Vector3::Create(x, y, z);
if(e->QueryFloatAttribute("intensity", &m_intensity) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("intensity", &m_intensity) != tinyxml2::XML_SUCCESS) {
m_intensity = 100.0; m_intensity = 100.0;
} }
if(e->QueryFloatAttribute("decay_start", &m_decayStart) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("decay_start", &m_decayStart) != tinyxml2::XML_SUCCESS) {
m_decayStart = 0.0; m_decayStart = 0.0;
} }
if(e->QueryFloatAttribute("flare_size", &m_flareSize) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("flare_size", &m_flareSize) != tinyxml2::XML_SUCCESS) {
m_flareSize = 0.0; m_flareSize = 0.0;
} }
if(e->QueryFloatAttribute("flare_occlusion_size", &m_flareOcclusionSize) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("flare_occlusion_size", &m_flareOcclusionSize) != tinyxml2::XML_SUCCESS) {
m_flareOcclusionSize = 0.05f; m_flareOcclusionSize = 0.05f;
} }
if(e->QueryBoolAttribute("casts_shadow", &m_casts_shadow) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("casts_shadow", &m_casts_shadow) != tinyxml2::XML_SUCCESS) {
m_casts_shadow = true; m_casts_shadow = true;
} }
if(e->QueryBoolAttribute("light_shafts", &m_light_shafts) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("light_shafts", &m_light_shafts) != tinyxml2::XML_SUCCESS) {
m_light_shafts = true; m_light_shafts = true;
} }
m_dust_particle_density = 0.1f; m_dust_particle_density = 0.1f;
if(e->QueryFloatAttribute("dust_particle_density", &m_dust_particle_density) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("dust_particle_density", &m_dust_particle_density) != tinyxml2::XML_SUCCESS) {
m_dust_particle_density = 0.1f; m_dust_particle_density = 0.1f;
} }
m_dust_particle_size = 1.0f; m_dust_particle_size = 1.0f;
if(e->QueryFloatAttribute("dust_particle_size", &m_dust_particle_size) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("dust_particle_size", &m_dust_particle_size) != tinyxml2::XML_SUCCESS) {
m_dust_particle_size = 1.0f; m_dust_particle_size = 1.0f;
} }
m_dust_particle_intensity = 1.0f; m_dust_particle_intensity = 1.0f;
if(e->QueryFloatAttribute("dust_particle_intensity", &m_dust_particle_intensity) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("dust_particle_intensity", &m_dust_particle_intensity) != tinyxml2::XML_SUCCESS) {
m_dust_particle_intensity = 1.0f; m_dust_particle_intensity = 1.0f;
} }
const char *szFlareTexture = e->Attribute("flare_texture"); const char* szFlareTexture = e->Attribute("flare_texture");
if(szFlareTexture) { if (szFlareTexture) {
m_flareTexture = szFlareTexture; m_flareTexture = szFlareTexture;
} else { } else {
m_flareTexture = ""; m_flareTexture = "";
@@ -176,58 +177,68 @@ void KRLight::loadXML(tinyxml2::XMLElement *e) {
m_pFlareTexture = NULL; m_pFlareTexture = NULL;
} }
void KRLight::setFlareTexture(std::string flare_texture) { void KRLight::setFlareTexture(std::string flare_texture)
{
m_flareTexture = flare_texture; m_flareTexture = flare_texture;
m_pFlareTexture = NULL; m_pFlareTexture = NULL;
} }
void KRLight::setFlareSize(float flare_size) { void KRLight::setFlareSize(float flare_size)
{
m_flareSize = flare_size; m_flareSize = flare_size;
} }
void KRLight::setFlareOcclusionSize(float occlusion_size) { void KRLight::setFlareOcclusionSize(float occlusion_size)
{
m_flareOcclusionSize = occlusion_size; m_flareOcclusionSize = occlusion_size;
} }
void KRLight::setIntensity(float intensity) { void KRLight::setIntensity(float intensity)
{
m_intensity = intensity; m_intensity = intensity;
} }
float KRLight::getIntensity() { float KRLight::getIntensity()
{
return m_intensity; return m_intensity;
} }
const Vector3 &KRLight::getColor() { const Vector3& KRLight::getColor()
{
return m_color; return m_color;
} }
void KRLight::setColor(const Vector3 &color) { void KRLight::setColor(const Vector3& color)
{
m_color = color; m_color = color;
} }
void KRLight::setDecayStart(float decayStart) { void KRLight::setDecayStart(float decayStart)
{
m_decayStart = decayStart; m_decayStart = decayStart;
} }
float KRLight::getDecayStart() { float KRLight::getDecayStart()
{
return m_decayStart; return m_decayStart;
} }
void KRLight::render(RenderInfo& ri) { void KRLight::render(RenderInfo& ri)
{
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRNode::render(ri); KRNode::render(ri);
if(ri.renderPass == KRNode::RENDER_PASS_GENERATE_SHADOWMAPS && (ri.camera->settings.volumetric_environment_enable || ri.camera->settings.dust_particle_enable || (ri.camera->settings.m_cShadowBuffers > 0 && m_casts_shadow))) { if (ri.renderPass == KRNode::RENDER_PASS_GENERATE_SHADOWMAPS && (ri.camera->settings.volumetric_environment_enable || ri.camera->settings.dust_particle_enable || (ri.camera->settings.m_cShadowBuffers > 0 && m_casts_shadow))) {
allocateShadowBuffers(configureShadowBufferViewports(ri.viewport)); allocateShadowBuffers(configureShadowBufferViewports(ri.viewport));
renderShadowBuffers(ri); renderShadowBuffers(ri);
} }
if(ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES && ri.camera->settings.dust_particle_enable) { if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES && ri.camera->settings.dust_particle_enable) {
// Render brownian particles for dust floating in air // Render brownian particles for dust floating in air
if(m_cShadowBuffers >= 1 && shadowValid[0] && m_dust_particle_density > 0.0f && m_dust_particle_size > 0.0f && m_dust_particle_intensity > 0.0f) { if (m_cShadowBuffers >= 1 && shadowValid[0] && m_dust_particle_density > 0.0f && m_dust_particle_size > 0.0f && m_dust_particle_intensity > 0.0f) {
if(ri.viewport.visible(getBounds()) || true) { // FINDME, HACK need to remove "|| true"? if (ri.viewport.visible(getBounds()) || true) { // FINDME, HACK need to remove "|| true"?
float particle_range = 600.0f; float particle_range = 600.0f;
@@ -240,19 +251,19 @@ void KRLight::render(RenderInfo& ri) {
particleModelMatrix.scale(particle_range); // Scale the box symetrically to ensure that we don't have an uneven distribution of particles for different angles of the view frustrum particleModelMatrix.scale(particle_range); // Scale the box symetrically to ensure that we don't have an uneven distribution of particles for different angles of the view frustrum
particleModelMatrix.translate(ri.viewport.getCameraPosition()); particleModelMatrix.translate(ri.viewport.getCameraPosition());
std::vector<KRDirectionalLight *> this_directional_light; std::vector<KRDirectionalLight*> this_directional_light;
std::vector<KRSpotLight *> this_spot_light; std::vector<KRSpotLight*> this_spot_light;
std::vector<KRPointLight *> this_point_light; std::vector<KRPointLight*> this_point_light;
KRDirectionalLight *directional_light = dynamic_cast<KRDirectionalLight *>(this); KRDirectionalLight* directional_light = dynamic_cast<KRDirectionalLight*>(this);
KRSpotLight *spot_light = dynamic_cast<KRSpotLight *>(this); KRSpotLight* spot_light = dynamic_cast<KRSpotLight*>(this);
KRPointLight *point_light = dynamic_cast<KRPointLight *>(this); KRPointLight* point_light = dynamic_cast<KRPointLight*>(this);
if(directional_light) { if (directional_light) {
this_directional_light.push_back(directional_light); this_directional_light.push_back(directional_light);
} }
if(spot_light) { if (spot_light) {
this_spot_light.push_back(spot_light); this_spot_light.push_back(spot_light);
} }
if(point_light) { if (point_light) {
this_point_light.push_back(point_light); this_point_light.push_back(point_light);
} }
@@ -268,7 +279,7 @@ void KRLight::render(RenderInfo& ri) {
info.cullMode = CullMode::kCullNone; info.cullMode = CullMode::kCullNone;
info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA); info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA);
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline *pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
pParticleShader->setUniform(KRPipeline::Uniform::light_color, m_color * ri.camera->settings.dust_particle_intensity * m_dust_particle_intensity * m_intensity); pParticleShader->setUniform(KRPipeline::Uniform::light_color, m_color * ri.camera->settings.dust_particle_intensity * m_dust_particle_intensity * m_intensity);
pParticleShader->setUniform(KRPipeline::Uniform::particle_origin, Matrix4::DotWDiv(Matrix4::Invert(particleModelMatrix), Vector3::Zero())); pParticleShader->setUniform(KRPipeline::Uniform::particle_origin, Matrix4::DotWDiv(Matrix4::Invert(particleModelMatrix), Vector3::Zero()));
@@ -283,22 +294,22 @@ void KRLight::render(RenderInfo& ri) {
} }
if(ri.renderPass == KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && ri.camera->settings.volumetric_environment_enable && m_light_shafts) { if (ri.renderPass == KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && ri.camera->settings.volumetric_environment_enable && m_light_shafts) {
std::string shader_name = ri.camera->settings.volumetric_environment_downsample != 0 ? "volumetric_fog_downsampled" : "volumetric_fog"; std::string shader_name = ri.camera->settings.volumetric_environment_downsample != 0 ? "volumetric_fog_downsampled" : "volumetric_fog";
std::vector<KRDirectionalLight *> this_directional_light; std::vector<KRDirectionalLight*> this_directional_light;
std::vector<KRSpotLight *> this_spot_light; std::vector<KRSpotLight*> this_spot_light;
std::vector<KRPointLight *> this_point_light; std::vector<KRPointLight*> this_point_light;
KRDirectionalLight *directional_light = dynamic_cast<KRDirectionalLight *>(this); KRDirectionalLight* directional_light = dynamic_cast<KRDirectionalLight*>(this);
KRSpotLight *spot_light = dynamic_cast<KRSpotLight *>(this); KRSpotLight* spot_light = dynamic_cast<KRSpotLight*>(this);
KRPointLight *point_light = dynamic_cast<KRPointLight *>(this); KRPointLight* point_light = dynamic_cast<KRPointLight*>(this);
if(directional_light) { if (directional_light) {
this_directional_light.push_back(directional_light); this_directional_light.push_back(directional_light);
} }
if(spot_light) { if (spot_light) {
this_spot_light.push_back(spot_light); this_spot_light.push_back(spot_light);
} }
if(point_light) { if (point_light) {
this_point_light.push_back(point_light); this_point_light.push_back(point_light);
} }
@@ -314,7 +325,7 @@ void KRLight::render(RenderInfo& ri) {
info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX); info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX);
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline *pFogShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pFogShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
int slice_count = (int)(ri.camera->settings.volumetric_environment_quality * 495.0) + 5; int slice_count = (int)(ri.camera->settings.volumetric_environment_quality * 495.0) + 5;
@@ -331,15 +342,15 @@ void KRLight::render(RenderInfo& ri) {
} }
if(ri.renderPass == KRNode::RENDER_PASS_PARTICLE_OCCLUSION) { if (ri.renderPass == KRNode::RENDER_PASS_PARTICLE_OCCLUSION) {
if(m_flareTexture.size() && m_flareSize > 0.0f) { if (m_flareTexture.size() && m_flareSize > 0.0f) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere"); KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) { if (sphereModel) {
Matrix4 occlusion_test_sphere_matrix = Matrix4(); Matrix4 occlusion_test_sphere_matrix = Matrix4();
occlusion_test_sphere_matrix.scale(m_localScale * m_flareOcclusionSize); occlusion_test_sphere_matrix.scale(m_localScale * m_flareOcclusionSize);
occlusion_test_sphere_matrix.translate(m_localTranslation); occlusion_test_sphere_matrix.translate(m_localTranslation);
if(m_parentNode) { if (m_parentNode) {
occlusion_test_sphere_matrix *= m_parentNode->getModelMatrix(); occlusion_test_sphere_matrix *= m_parentNode->getModelMatrix();
} }
@@ -360,11 +371,11 @@ void KRLight::render(RenderInfo& ri) {
pPipeline->bind(ri.commandBuffer, *info.pCamera, ri.viewport, occlusion_test_sphere_matrix, info.point_lights, info.directional_lights, info.spot_lights, info.renderPass); pPipeline->bind(ri.commandBuffer, *info.pCamera, ri.viewport, occlusion_test_sphere_matrix, info.point_lights, info.directional_lights, info.spot_lights, info.renderPass);
GLDEBUG(glGenQueriesEXT(1, &m_occlusionQuery)); GLDEBUG(glGenQueriesEXT(1, &m_occlusionQuery));
#if TARGET_OS_IPHONE || defined(ANDROID) #if TARGET_OS_IPHONE || defined(ANDROID)
GLDEBUG(glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, m_occlusionQuery)); GLDEBUG(glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, m_occlusionQuery));
#else #else
GLDEBUG(glBeginQuery(GL_SAMPLES_PASSED, m_occlusionQuery)); GLDEBUG(glBeginQuery(GL_SAMPLES_PASSED, m_occlusionQuery));
#endif #endif
sphereModel->renderNoMaterials(ri.commandBuffer, ri.renderPass, getName(), "occlusion_test", 1.0f); sphereModel->renderNoMaterials(ri.commandBuffer, ri.renderPass, getName(), "occlusion_test", 1.0f);
@@ -378,21 +389,21 @@ void KRLight::render(RenderInfo& ri) {
} }
} }
if(ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) { if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) {
if(m_flareTexture.size() && m_flareSize > 0.0f) { if (m_flareTexture.size() && m_flareSize > 0.0f) {
if(m_occlusionQuery) { if (m_occlusionQuery) {
GLuint params = 0; GLuint params = 0;
GLDEBUG(glGetQueryObjectuivEXT(m_occlusionQuery, GL_QUERY_RESULT_EXT, &params)); GLDEBUG(glGetQueryObjectuivEXT(m_occlusionQuery, GL_QUERY_RESULT_EXT, &params));
GLDEBUG(glDeleteQueriesEXT(1, &m_occlusionQuery)); GLDEBUG(glDeleteQueriesEXT(1, &m_occlusionQuery));
if(params) { if (params) {
if(!m_pFlareTexture && m_flareTexture.size()) { if (!m_pFlareTexture && m_flareTexture.size()) {
m_pFlareTexture = getContext().getTextureManager()->getTexture(m_flareTexture); m_pFlareTexture = getContext().getTextureManager()->getTexture(m_flareTexture);
} }
if(m_pFlareTexture) { if (m_pFlareTexture) {
KRMeshManager::KRVBOData& vertices = getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES; KRMeshManager::KRVBOData& vertices = getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES;
// Render light flare on transparency pass // Render light flare on transparency pass
@@ -410,7 +421,7 @@ void KRLight::render(RenderInfo& ri) {
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->setUniform(KRPipeline::Uniform::material_alpha, 1.0f); pShader->setUniform(KRPipeline::Uniform::material_alpha, 1.0f);
pShader->setUniform(KRPipeline::Uniform::flare_size, m_flareSize); pShader->setUniform(KRPipeline::Uniform::flare_size, m_flareSize);
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);
@@ -426,9 +437,10 @@ void KRLight::render(RenderInfo& ri) {
} }
} }
void KRLight::allocateShadowBuffers(int cBuffers) { void KRLight::allocateShadowBuffers(int cBuffers)
{
// First deallocate buffers no longer needed // First deallocate buffers no longer needed
for(int iShadow = cBuffers; iShadow < KRENGINE_MAX_SHADOW_BUFFERS; iShadow++) { for (int iShadow = cBuffers; iShadow < KRENGINE_MAX_SHADOW_BUFFERS; iShadow++) {
if (shadowDepthTexture[iShadow]) { if (shadowDepthTexture[iShadow]) {
GLDEBUG(glDeleteTextures(1, shadowDepthTexture + iShadow)); GLDEBUG(glDeleteTextures(1, shadowDepthTexture + iShadow));
shadowDepthTexture[iShadow] = 0; shadowDepthTexture[iShadow] = 0;
@@ -441,10 +453,10 @@ void KRLight::allocateShadowBuffers(int cBuffers) {
} }
// Allocate newly required buffers // Allocate newly required buffers
for(int iShadow = 0; iShadow < cBuffers; iShadow++) { for (int iShadow = 0; iShadow < cBuffers; iShadow++) {
Vector2 viewportSize = m_shadowViewports[iShadow].getSize(); Vector2 viewportSize = m_shadowViewports[iShadow].getSize();
if(!shadowDepthTexture[iShadow]) { if (!shadowDepthTexture[iShadow]) {
shadowValid[iShadow] = false; shadowValid[iShadow] = false;
GLDEBUG(glGenFramebuffers(1, shadowFramebuffer + iShadow)); GLDEBUG(glGenFramebuffers(1, shadowFramebuffer + iShadow));
@@ -454,7 +466,7 @@ void KRLight::allocateShadowBuffers(int cBuffers) {
GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, shadowFramebuffer[iShadow])); GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, shadowFramebuffer[iShadow]));
// ----- Create Depth Texture for shadowFramebuffer ----- // ----- Create Depth Texture for shadowFramebuffer -----
GLDEBUG( glBindTexture(GL_TEXTURE_2D, shadowDepthTexture[iShadow])); GLDEBUG(glBindTexture(GL_TEXTURE_2D, shadowDepthTexture[iShadow]));
GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
m_pContext->getTextureManager()->_setWrapModeS(shadowDepthTexture[iShadow], GL_CLAMP_TO_EDGE); m_pContext->getTextureManager()->_setWrapModeS(shadowDepthTexture[iShadow], GL_CLAMP_TO_EDGE);
@@ -481,20 +493,20 @@ void KRLight::deleteBuffers()
void KRLight::invalidateShadowBuffers() void KRLight::invalidateShadowBuffers()
{ {
for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) { for (int iShadow = 0; iShadow < m_cShadowBuffers; iShadow++) {
shadowValid[iShadow] = false; shadowValid[iShadow] = false;
} }
} }
int KRLight::configureShadowBufferViewports(const KRViewport &viewport) int KRLight::configureShadowBufferViewports(const KRViewport& viewport)
{ {
return 0; return 0;
} }
void KRLight::renderShadowBuffers(RenderInfo& ri) void KRLight::renderShadowBuffers(RenderInfo& ri)
{ {
for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) { for (int iShadow = 0; iShadow < m_cShadowBuffers; iShadow++) {
if(!shadowValid[iShadow]) { if (!shadowValid[iShadow]) {
shadowValid[iShadow] = true; shadowValid[iShadow] = true;
GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, shadowFramebuffer[iShadow])); GLDEBUG(glBindFramebuffer(GL_FRAMEBUFFER, shadowFramebuffer[iShadow]));
@@ -521,7 +533,7 @@ void KRLight::renderShadowBuffers(RenderInfo& ri)
info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT; info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
info.rasterMode = RasterMode::kOpaqueLessTest; // TODO - This is sub-optimal. Evaluate increasing depth buffer resolution instead of disabling depth test. info.rasterMode = RasterMode::kOpaqueLessTest; // TODO - This is sub-optimal. Evaluate increasing depth buffer resolution instead of disabling depth test.
info.cullMode = CullMode::kCullNone; // Disabling culling, which eliminates some self-cast shadow artifacts info.cullMode = CullMode::kCullNone; // Disabling culling, which eliminates some self-cast shadow artifacts
KRPipeline *shadowShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* shadowShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
shadowShader->bind(ri.commandBuffer, *ri.camera, m_shadowViewports[iShadow], Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_SHADOWMAP); shadowShader->bind(ri.commandBuffer, *ri.camera, m_shadowViewports[iShadow], Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_SHADOWMAP);
@@ -534,9 +546,9 @@ void KRLight::renderShadowBuffers(RenderInfo& ri)
int KRLight::getShadowBufferCount() int KRLight::getShadowBufferCount()
{ {
int cBuffers=0; int cBuffers = 0;
for(int iBuffer=0; iBuffer < m_cShadowBuffers; iBuffer++) { for (int iBuffer = 0; iBuffer < m_cShadowBuffers; iBuffer++) {
if(shadowValid[iBuffer]) { if (shadowValid[iBuffer]) {
cBuffers++; cBuffers++;
} else { } else {
break; break;
@@ -545,12 +557,12 @@ int KRLight::getShadowBufferCount()
return cBuffers; return cBuffers;
} }
GLuint *KRLight::getShadowTextures() GLuint* KRLight::getShadowTextures()
{ {
return shadowDepthTexture; return shadowDepthTexture;
} }
KRViewport *KRLight::getShadowViewports() KRViewport* KRLight::getShadowViewports()
{ {
return m_shadowViewports; return m_shadowViewports;
} }

21
kraken/KRLight.h
View File

@@ -42,21 +42,22 @@ static const float KRLIGHT_MIN_INFLUENCE = 0.15f; // 0.05f
#define KRENGINE_SHADOW_MAP_WIDTH 1024 #define KRENGINE_SHADOW_MAP_WIDTH 1024
#define KRENGINE_SHADOW_MAP_HEIGHT 1024 #define KRENGINE_SHADOW_MAP_HEIGHT 1024
class KRLight : public KRNode { class KRLight : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
virtual ~KRLight(); virtual ~KRLight();
virtual std::string getElementName() = 0; virtual std::string getElementName() = 0;
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
void setIntensity(float intensity); void setIntensity(float intensity);
float getIntensity(); float getIntensity();
void setDecayStart(float decayStart); void setDecayStart(float decayStart);
float getDecayStart(); float getDecayStart();
const Vector3 &getColor(); const Vector3& getColor();
void setColor(const Vector3 &color); void setColor(const Vector3& color);
void setFlareTexture(std::string flare_texture); void setFlareTexture(std::string flare_texture);
void setFlareSize(float flare_size); void setFlareSize(float flare_size);
@@ -66,19 +67,19 @@ public:
virtual void render(RenderInfo& ri); virtual void render(RenderInfo& ri);
int getShadowBufferCount(); int getShadowBufferCount();
GLuint *getShadowTextures(); GLuint* getShadowTextures();
KRViewport *getShadowViewports(); KRViewport* getShadowViewports();
protected: protected:
KRLight(KRScene &scene, std::string name); KRLight(KRScene& scene, std::string name);
float m_intensity; float m_intensity;
float m_decayStart; float m_decayStart;
Vector3 m_color; Vector3 m_color;
std::string m_flareTexture; std::string m_flareTexture;
KRTexture *m_pFlareTexture; KRTexture* m_pFlareTexture;
float m_flareSize; float m_flareSize;
float m_flareOcclusionSize; float m_flareOcclusionSize;
@@ -100,6 +101,6 @@ protected:
void allocateShadowBuffers(int cBuffers); void allocateShadowBuffers(int cBuffers);
void invalidateShadowBuffers(); void invalidateShadowBuffers();
virtual int configureShadowBufferViewports(const KRViewport &viewport); virtual int configureShadowBufferViewports(const KRViewport& viewport);
void renderShadowBuffers(RenderInfo& ri); void renderShadowBuffers(RenderInfo& ri);
}; };

22
kraken/KRLocator.cpp
View File

@@ -39,47 +39,47 @@ void KRLocator::InitNodeInfo(KrNodeInfo* nodeInfo)
// No additional members // No additional members
} }
KRLocator::KRLocator(KRScene &scene, std::string name) : KRNode(scene, name) KRLocator::KRLocator(KRScene& scene, std::string name) : KRNode(scene, name)
{ {
} }
KRLocator::~KRLocator() KRLocator::~KRLocator()
{ {}
}
std::string KRLocator::getElementName() { std::string KRLocator::getElementName()
{
return "locator"; return "locator";
} }
tinyxml2::XMLElement *KRLocator::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRLocator::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
return e; return e;
} }
void KRLocator::loadXML(tinyxml2::XMLElement *e) void KRLocator::loadXML(tinyxml2::XMLElement* e)
{ {
KRNode::loadXML(e); KRNode::loadXML(e);
} }
unordered_map<std::string, int> &KRLocator::getUserIntAttributes() unordered_map<std::string, int>& KRLocator::getUserIntAttributes()
{ {
return m_userIntAttributes; return m_userIntAttributes;
} }
unordered_map<std::string, double> &KRLocator::getUserDoubleAttributes() unordered_map<std::string, double>& KRLocator::getUserDoubleAttributes()
{ {
return m_userDoubleAttributes; return m_userDoubleAttributes;
} }
unordered_map<std::string, bool> &KRLocator::getUserBoolAttributes() unordered_map<std::string, bool>& KRLocator::getUserBoolAttributes()
{ {
return m_userBoolAttributes; return m_userBoolAttributes;
} }
unordered_map<std::string, std::string> &KRLocator::getUserStringAttributes() unordered_map<std::string, std::string>& KRLocator::getUserStringAttributes()
{ {
return m_userStringAttributes; return m_userStringAttributes;
} }

17
kraken/KRLocator.h
View File

@@ -35,19 +35,20 @@
#include "KRNode.h" #include "KRNode.h"
#include "KRTexture.h" #include "KRTexture.h"
class KRLocator : public KRNode { class KRLocator : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRLocator(KRScene &scene, std::string name); KRLocator(KRScene& scene, std::string name);
virtual ~KRLocator(); virtual ~KRLocator();
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
unordered_map<std::string, int> &getUserIntAttributes(); unordered_map<std::string, int>& getUserIntAttributes();
unordered_map<std::string, double> &getUserDoubleAttributes(); unordered_map<std::string, double>& getUserDoubleAttributes();
unordered_map<std::string, bool> &getUserBoolAttributes(); unordered_map<std::string, bool>& getUserBoolAttributes();
unordered_map<std::string, std::string> &getUserStringAttributes(); unordered_map<std::string, std::string>& getUserStringAttributes();
private: private:
unordered_map<std::string, int> m_userIntAttributes; unordered_map<std::string, int> m_userIntAttributes;

159
kraken/KRMaterial.cpp
View File

@@ -36,7 +36,8 @@
#include "KRContext.h" #include "KRContext.h"
KRMaterial::KRMaterial(KRContext &context, const char *szName) : KRResource(context, szName) { KRMaterial::KRMaterial(KRContext& context, const char* szName) : KRResource(context, szName)
{
m_name = szName; m_name = szName;
m_pAmbientMap = NULL; m_pAmbientMap = NULL;
m_pDiffuseMap = NULL; m_pDiffuseMap = NULL;
@@ -67,11 +68,13 @@ KRMaterial::KRMaterial(KRContext &context, const char *szName) : KRResource(cont
m_alpha_mode = KRMATERIAL_ALPHA_MODE_OPAQUE; m_alpha_mode = KRMATERIAL_ALPHA_MODE_OPAQUE;
} }
KRMaterial::~KRMaterial() { KRMaterial::~KRMaterial()
{
} }
std::string KRMaterial::getExtension() { std::string KRMaterial::getExtension()
{
return "mtl"; return "mtl";
} }
@@ -80,10 +83,11 @@ bool KRMaterial::needsVertexTangents()
return m_normalMap.size() > 0; return m_normalMap.size() > 0;
} }
bool KRMaterial::save(KRDataBlock &data) { bool KRMaterial::save(KRDataBlock& data)
{
std::stringstream stream; std::stringstream stream;
stream.precision(std::numeric_limits<long double>::digits10); stream.precision(std::numeric_limits<long double>::digits10);
stream.setf(std::ios::fixed,std::ios::floatfield); stream.setf(std::ios::fixed, std::ios::floatfield);
stream << "newmtl " << m_name; stream << "newmtl " << m_name;
stream << "\nka " << m_ambientColor.x << " " << m_ambientColor.y << " " << m_ambientColor.z; stream << "\nka " << m_ambientColor.x << " " << m_ambientColor.y << " " << m_ambientColor.z;
@@ -92,37 +96,37 @@ bool KRMaterial::save(KRDataBlock &data) {
stream << "\nkr " << m_reflectionColor.x << " " << m_reflectionColor.y << " " << m_reflectionColor.z; stream << "\nkr " << m_reflectionColor.x << " " << m_reflectionColor.y << " " << m_reflectionColor.z;
stream << "\nTr " << m_tr; stream << "\nTr " << m_tr;
stream << "\nNs " << m_ns; stream << "\nNs " << m_ns;
if(m_ambientMap.size()) { if (m_ambientMap.size()) {
stream << "\nmap_Ka " << m_ambientMap << ".pvr -s " << m_ambientMapScale.x << " " << m_ambientMapScale.y << " -o " << m_ambientMapOffset.x << " " << m_ambientMapOffset.y; stream << "\nmap_Ka " << m_ambientMap << ".pvr -s " << m_ambientMapScale.x << " " << m_ambientMapScale.y << " -o " << m_ambientMapOffset.x << " " << m_ambientMapOffset.y;
} else { } else {
stream << "\n# map_Ka filename.pvr -s 1.0 1.0 -o 0.0 0.0"; stream << "\n# map_Ka filename.pvr -s 1.0 1.0 -o 0.0 0.0";
} }
if(m_diffuseMap.size()) { if (m_diffuseMap.size()) {
stream << "\nmap_Kd " << m_diffuseMap << ".pvr -s " << m_diffuseMapScale.x << " " << m_diffuseMapScale.y << " -o " << m_diffuseMapOffset.x << " " << m_diffuseMapOffset.y; stream << "\nmap_Kd " << m_diffuseMap << ".pvr -s " << m_diffuseMapScale.x << " " << m_diffuseMapScale.y << " -o " << m_diffuseMapOffset.x << " " << m_diffuseMapOffset.y;
} else { } else {
stream << "\n# map_Kd filename.pvr -s 1.0 1.0 -o 0.0 0.0"; stream << "\n# map_Kd filename.pvr -s 1.0 1.0 -o 0.0 0.0";
} }
if(m_specularMap.size()) { if (m_specularMap.size()) {
stream << "\nmap_Ks " << m_specularMap << ".pvr -s " << m_specularMapScale.x << " " << m_specularMapScale.y << " -o " << m_specularMapOffset.x << " " << m_specularMapOffset.y << "\n"; stream << "\nmap_Ks " << m_specularMap << ".pvr -s " << m_specularMapScale.x << " " << m_specularMapScale.y << " -o " << m_specularMapOffset.x << " " << m_specularMapOffset.y << "\n";
} else { } else {
stream << "\n# map_Ks filename.pvr -s 1.0 1.0 -o 0.0 0.0"; stream << "\n# map_Ks filename.pvr -s 1.0 1.0 -o 0.0 0.0";
} }
if(m_normalMap.size()) { if (m_normalMap.size()) {
stream << "\nmap_Normal " << m_normalMap << ".pvr -s " << m_normalMapScale.x << " " << m_normalMapScale.y << " -o " << m_normalMapOffset.x << " " << m_normalMapOffset.y; stream << "\nmap_Normal " << m_normalMap << ".pvr -s " << m_normalMapScale.x << " " << m_normalMapScale.y << " -o " << m_normalMapOffset.x << " " << m_normalMapOffset.y;
} else { } else {
stream << "\n# map_Normal filename.pvr -s 1.0 1.0 -o 0.0 0.0"; stream << "\n# map_Normal filename.pvr -s 1.0 1.0 -o 0.0 0.0";
} }
if(m_reflectionMap.size()) { if (m_reflectionMap.size()) {
stream << "\nmap_Reflection " << m_reflectionMap << ".pvr -s " << m_reflectionMapScale.x << " " << m_reflectionMapScale.y << " -o " << m_reflectionMapOffset.x << " " << m_reflectionMapOffset.y; stream << "\nmap_Reflection " << m_reflectionMap << ".pvr -s " << m_reflectionMapScale.x << " " << m_reflectionMapScale.y << " -o " << m_reflectionMapOffset.x << " " << m_reflectionMapOffset.y;
} else { } else {
stream << "\n# map_Reflection filename.pvr -s 1.0 1.0 -o 0.0 0.0"; stream << "\n# map_Reflection filename.pvr -s 1.0 1.0 -o 0.0 0.0";
} }
if(m_reflectionCube.size()) { if (m_reflectionCube.size()) {
stream << "\nmap_ReflectionCube " << m_reflectionCube << ".pvr"; stream << "\nmap_ReflectionCube " << m_reflectionCube << ".pvr";
} else { } else {
stream << "\n# map_ReflectionCube cubemapname"; stream << "\n# map_ReflectionCube cubemapname";
} }
switch(m_alpha_mode) { switch (m_alpha_mode) {
case KRMATERIAL_ALPHA_MODE_OPAQUE: case KRMATERIAL_ALPHA_MODE_OPAQUE:
stream << "\nalpha_mode opaque"; stream << "\nalpha_mode opaque";
break; break;
@@ -144,76 +148,91 @@ bool KRMaterial::save(KRDataBlock &data) {
return true; return true;
} }
void KRMaterial::setAmbientMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset) { void KRMaterial::setAmbientMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset)
{
m_ambientMap = texture_name; m_ambientMap = texture_name;
m_ambientMapScale = texture_scale; m_ambientMapScale = texture_scale;
m_ambientMapOffset = texture_offset; m_ambientMapOffset = texture_offset;
} }
void KRMaterial::setDiffuseMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset) { void KRMaterial::setDiffuseMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset)
{
m_diffuseMap = texture_name; m_diffuseMap = texture_name;
m_diffuseMapScale = texture_scale; m_diffuseMapScale = texture_scale;
m_diffuseMapOffset = texture_offset; m_diffuseMapOffset = texture_offset;
} }
void KRMaterial::setSpecularMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset) { void KRMaterial::setSpecularMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset)
{
m_specularMap = texture_name; m_specularMap = texture_name;
m_specularMapScale = texture_scale; m_specularMapScale = texture_scale;
m_specularMapOffset = texture_offset; m_specularMapOffset = texture_offset;
} }
void KRMaterial::setNormalMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset) { void KRMaterial::setNormalMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset)
{
m_normalMap = texture_name; m_normalMap = texture_name;
m_normalMapScale = texture_scale; m_normalMapScale = texture_scale;
m_normalMapOffset = texture_offset; m_normalMapOffset = texture_offset;
} }
void KRMaterial::setReflectionMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset) { void KRMaterial::setReflectionMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset)
{
m_reflectionMap = texture_name; m_reflectionMap = texture_name;
m_reflectionMapScale = texture_scale; m_reflectionMapScale = texture_scale;
m_reflectionMapOffset = texture_offset; m_reflectionMapOffset = texture_offset;
} }
void KRMaterial::setReflectionCube(std::string texture_name) { void KRMaterial::setReflectionCube(std::string texture_name)
{
m_reflectionCube = texture_name; m_reflectionCube = texture_name;
} }
void KRMaterial::setAlphaMode(KRMaterial::alpha_mode_type alpha_mode) { void KRMaterial::setAlphaMode(KRMaterial::alpha_mode_type alpha_mode)
{
m_alpha_mode = alpha_mode; m_alpha_mode = alpha_mode;
} }
KRMaterial::alpha_mode_type KRMaterial::getAlphaMode() { KRMaterial::alpha_mode_type KRMaterial::getAlphaMode()
{
return m_alpha_mode; return m_alpha_mode;
} }
void KRMaterial::setAmbient(const Vector3 &c) { void KRMaterial::setAmbient(const Vector3& c)
{
m_ambientColor = c; m_ambientColor = c;
} }
void KRMaterial::setDiffuse(const Vector3 &c) { void KRMaterial::setDiffuse(const Vector3& c)
{
m_diffuseColor = c; m_diffuseColor = c;
} }
void KRMaterial::setSpecular(const Vector3 &c) { void KRMaterial::setSpecular(const Vector3& c)
{
m_specularColor = c; m_specularColor = c;
} }
void KRMaterial::setReflection(const Vector3 &c) { void KRMaterial::setReflection(const Vector3& c)
{
m_reflectionColor = c; m_reflectionColor = c;
} }
void KRMaterial::setTransparency(float a) { void KRMaterial::setTransparency(float a)
if(a < 1.0f && m_alpha_mode == KRMaterial::KRMATERIAL_ALPHA_MODE_OPAQUE) { {
if (a < 1.0f && m_alpha_mode == KRMaterial::KRMATERIAL_ALPHA_MODE_OPAQUE) {
setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_BLENDONESIDE); setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_BLENDONESIDE);
} }
m_tr = a; m_tr = a;
} }
void KRMaterial::setShininess(float s) { void KRMaterial::setShininess(float s)
{
m_ns = s; m_ns = s;
} }
bool KRMaterial::isTransparent() { bool KRMaterial::isTransparent()
{
return m_tr < 1.0 || m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDONESIDE || m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE; return m_tr < 1.0 || m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDONESIDE || m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE;
} }
@@ -221,27 +240,27 @@ void KRMaterial::preStream(float lodCoverage)
{ {
getTextures(); getTextures();
if(m_pAmbientMap) { if (m_pAmbientMap) {
m_pAmbientMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_AMBIENT_MAP); m_pAmbientMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_AMBIENT_MAP);
} }
if(m_pDiffuseMap) { if (m_pDiffuseMap) {
m_pDiffuseMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_DIFFUSE_MAP); m_pDiffuseMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_DIFFUSE_MAP);
} }
if(m_pNormalMap) { if (m_pNormalMap) {
m_pNormalMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_NORMAL_MAP); m_pNormalMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_NORMAL_MAP);
} }
if(m_pSpecularMap) { if (m_pSpecularMap) {
m_pSpecularMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_SPECULAR_MAP); m_pSpecularMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_SPECULAR_MAP);
} }
if(m_pReflectionMap) { if (m_pReflectionMap) {
m_pReflectionMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_REFLECTION_MAP); m_pReflectionMap->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_REFLECTION_MAP);
} }
if(m_pReflectionCube) { if (m_pReflectionCube) {
m_pReflectionCube->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_REFECTION_CUBE); m_pReflectionCube->resetPoolExpiry(lodCoverage, KRTexture::TEXTURE_USAGE_REFECTION_CUBE);
} }
} }
@@ -253,27 +272,27 @@ kraken_stream_level KRMaterial::getStreamLevel()
getTextures(); getTextures();
if(m_pAmbientMap) { if (m_pAmbientMap) {
stream_level = KRMIN(stream_level, m_pAmbientMap->getStreamLevel(KRTexture::TEXTURE_USAGE_AMBIENT_MAP)); stream_level = KRMIN(stream_level, m_pAmbientMap->getStreamLevel(KRTexture::TEXTURE_USAGE_AMBIENT_MAP));
} }
if(m_pDiffuseMap) { if (m_pDiffuseMap) {
stream_level = KRMIN(stream_level, m_pDiffuseMap->getStreamLevel(KRTexture::TEXTURE_USAGE_DIFFUSE_MAP)); stream_level = KRMIN(stream_level, m_pDiffuseMap->getStreamLevel(KRTexture::TEXTURE_USAGE_DIFFUSE_MAP));
} }
if(m_pNormalMap) { if (m_pNormalMap) {
stream_level = KRMIN(stream_level, m_pNormalMap->getStreamLevel(KRTexture::TEXTURE_USAGE_NORMAL_MAP)); stream_level = KRMIN(stream_level, m_pNormalMap->getStreamLevel(KRTexture::TEXTURE_USAGE_NORMAL_MAP));
} }
if(m_pSpecularMap) { if (m_pSpecularMap) {
stream_level = KRMIN(stream_level, m_pSpecularMap->getStreamLevel(KRTexture::TEXTURE_USAGE_SPECULAR_MAP)); stream_level = KRMIN(stream_level, m_pSpecularMap->getStreamLevel(KRTexture::TEXTURE_USAGE_SPECULAR_MAP));
} }
if(m_pReflectionMap) { if (m_pReflectionMap) {
stream_level = KRMIN(stream_level, m_pReflectionMap->getStreamLevel(KRTexture::TEXTURE_USAGE_REFLECTION_MAP)); stream_level = KRMIN(stream_level, m_pReflectionMap->getStreamLevel(KRTexture::TEXTURE_USAGE_REFLECTION_MAP));
} }
if(m_pReflectionCube) { if (m_pReflectionCube) {
stream_level = KRMIN(stream_level, m_pReflectionCube->getStreamLevel(KRTexture::TEXTURE_USAGE_REFECTION_CUBE)); stream_level = KRMIN(stream_level, m_pReflectionCube->getStreamLevel(KRTexture::TEXTURE_USAGE_REFECTION_CUBE));
} }
@@ -282,27 +301,27 @@ kraken_stream_level KRMaterial::getStreamLevel()
void KRMaterial::getTextures() void KRMaterial::getTextures()
{ {
if(!m_pAmbientMap && m_ambientMap.size()) { if (!m_pAmbientMap && m_ambientMap.size()) {
m_pAmbientMap = getContext().getTextureManager()->getTexture(m_ambientMap); m_pAmbientMap = getContext().getTextureManager()->getTexture(m_ambientMap);
} }
if(!m_pDiffuseMap && m_diffuseMap.size()) { if (!m_pDiffuseMap && m_diffuseMap.size()) {
m_pDiffuseMap = getContext().getTextureManager()->getTexture(m_diffuseMap); m_pDiffuseMap = getContext().getTextureManager()->getTexture(m_diffuseMap);
} }
if(!m_pNormalMap && m_normalMap.size()) { if (!m_pNormalMap && m_normalMap.size()) {
m_pNormalMap = getContext().getTextureManager()->getTexture(m_normalMap); m_pNormalMap = getContext().getTextureManager()->getTexture(m_normalMap);
} }
if(!m_pSpecularMap && m_specularMap.size()) { if (!m_pSpecularMap && m_specularMap.size()) {
m_pSpecularMap = getContext().getTextureManager()->getTexture(m_specularMap); m_pSpecularMap = getContext().getTextureManager()->getTexture(m_specularMap);
} }
if(!m_pReflectionMap && m_reflectionMap.size()) { if (!m_pReflectionMap && m_reflectionMap.size()) {
m_pReflectionMap = getContext().getTextureManager()->getTexture(m_reflectionMap); m_pReflectionMap = getContext().getTextureManager()->getTexture(m_reflectionMap);
} }
if(!m_pReflectionCube && m_reflectionCube.size()) { if (!m_pReflectionCube && m_reflectionCube.size()) {
m_pReflectionCube = getContext().getTextureManager()->getTextureCube(m_reflectionCube.c_str()); m_pReflectionCube = getContext().getTextureManager()->getTextureCube(m_reflectionCube.c_str());
} }
} }
void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_t vertexAttributes, CullMode cullMode, const std::vector<KRBone *> &bones, const std::vector<Matrix4> &bind_poses, const Matrix4 &matModel, KRTexture *pLightMap, const Vector3 &rim_color, float rim_power, float lod_coverage) void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_t vertexAttributes, CullMode cullMode, const std::vector<KRBone*>& bones, const std::vector<Matrix4>& bind_poses, const Matrix4& matModel, KRTexture* pLightMap, const Vector3& rim_color, float rim_power, float lod_coverage)
{ {
bool bLightMap = pLightMap && ri.camera->settings.bEnableLightMap; bool bLightMap = pLightMap && ri.camera->settings.bEnableLightMap;
@@ -350,29 +369,29 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
info.modelFormat = modelFormat; info.modelFormat = modelFormat;
info.vertexAttributes = vertexAttributes; info.vertexAttributes = vertexAttributes;
info.cullMode = cullMode; info.cullMode = cullMode;
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
// Rim highlighting parameters // Rim highlighting parameters
pShader->setUniform(KRPipeline::Uniform::rim_color, rim_color); pShader->setUniform(KRPipeline::Uniform::rim_color, rim_color);
pShader->setUniform(KRPipeline::Uniform::rim_power, rim_power); pShader->setUniform(KRPipeline::Uniform::rim_power, rim_power);
// Bind bones // Bind bones
if(pShader->hasUniform(KRPipeline::Uniform::bone_transforms)) { if (pShader->hasUniform(KRPipeline::Uniform::bone_transforms)) {
float bone_mats[256 * 16]; float bone_mats[256 * 16];
float *bone_mat_component = bone_mats; float* bone_mat_component = bone_mats;
for(int bone_index=0; bone_index < bones.size(); bone_index++) { for (int bone_index = 0; bone_index < bones.size(); bone_index++) {
KRBone *bone = bones[bone_index]; KRBone* bone = bones[bone_index];
// Vector3 initialRotation = bone->getInitialLocalRotation(); // Vector3 initialRotation = bone->getInitialLocalRotation();
// Vector3 rotation = bone->getLocalRotation(); // Vector3 rotation = bone->getLocalRotation();
// Vector3 initialTranslation = bone->getInitialLocalTranslation(); // Vector3 initialTranslation = bone->getInitialLocalTranslation();
// Vector3 translation = bone->getLocalTranslation(); // Vector3 translation = bone->getLocalTranslation();
// Vector3 initialScale = bone->getInitialLocalScale(); // Vector3 initialScale = bone->getInitialLocalScale();
// Vector3 scale = bone->getLocalScale(); // Vector3 scale = bone->getLocalScale();
// //
//printf("%s - delta rotation: %.4f %.4f %.4f\n", bone->getName().c_str(), (rotation.x - initialRotation.x) * 180.0 / M_PI, (rotation.y - initialRotation.y) * 180.0 / M_PI, (rotation.z - initialRotation.z) * 180.0 / M_PI); //printf("%s - delta rotation: %.4f %.4f %.4f\n", bone->getName().c_str(), (rotation.x - initialRotation.x) * 180.0 / M_PI, (rotation.y - initialRotation.y) * 180.0 / M_PI, (rotation.z - initialRotation.z) * 180.0 / M_PI);
//printf("%s - delta translation: %.4f %.4f %.4f\n", bone->getName().c_str(), translation.x - initialTranslation.x, translation.y - initialTranslation.y, translation.z - initialTranslation.z); //printf("%s - delta translation: %.4f %.4f %.4f\n", bone->getName().c_str(), translation.x - initialTranslation.x, translation.y - initialTranslation.y, translation.z - initialTranslation.z);
// printf("%s - delta scale: %.4f %.4f %.4f\n", bone->getName().c_str(), scale.x - initialScale.x, scale.y - initialScale.y, scale.z - initialScale.z); // printf("%s - delta scale: %.4f %.4f %.4f\n", bone->getName().c_str(), scale.x - initialScale.x, scale.y - initialScale.y, scale.z - initialScale.z);
Matrix4 skin_bone_bind_pose = bind_poses[bone_index]; Matrix4 skin_bone_bind_pose = bind_poses[bone_index];
Matrix4 active_mat = bone->getActivePoseMatrix(); Matrix4 active_mat = bone->getActivePoseMatrix();
@@ -380,11 +399,11 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
Matrix4 inv_bind_mat2 = Matrix4::Invert(bind_poses[bone_index]); Matrix4 inv_bind_mat2 = Matrix4::Invert(bind_poses[bone_index]);
Matrix4 t = (inv_bind_mat * active_mat); Matrix4 t = (inv_bind_mat * active_mat);
Matrix4 t2 = inv_bind_mat2 * bone->getModelMatrix(); Matrix4 t2 = inv_bind_mat2 * bone->getModelMatrix();
for(int i=0; i < 16; i++) { for (int i = 0; i < 16; i++) {
*bone_mat_component++ = t[i]; *bone_mat_component++ = t[i];
} }
} }
if(pShader->hasUniform(KRPipeline::Uniform::bone_transforms)) { if (pShader->hasUniform(KRPipeline::Uniform::bone_transforms)) {
pShader->setUniform(KRPipeline::Uniform::bone_transforms, (Matrix4*)bone_mats, bones.size()); pShader->setUniform(KRPipeline::Uniform::bone_transforms, (Matrix4*)bone_mats, bones.size());
} }
} }
@@ -392,14 +411,14 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
pShader->setUniform(KRPipeline::Uniform::material_ambient, m_ambientColor + ri.camera->settings.ambient_intensity); pShader->setUniform(KRPipeline::Uniform::material_ambient, m_ambientColor + ri.camera->settings.ambient_intensity);
if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) { if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
// We pre-multiply the light color with the material color in the forward renderer // We pre-multiply the light color with the material color in the forward renderer
pShader->setUniform(KRPipeline::Uniform::material_diffuse, Vector3::Create(m_diffuseColor.x * ri.camera->settings.light_intensity.x, m_diffuseColor.y * ri.camera->settings.light_intensity.y, m_diffuseColor.z * ri.camera->settings.light_intensity.z)); pShader->setUniform(KRPipeline::Uniform::material_diffuse, Vector3::Create(m_diffuseColor.x * ri.camera->settings.light_intensity.x, m_diffuseColor.y * ri.camera->settings.light_intensity.y, m_diffuseColor.z * ri.camera->settings.light_intensity.z));
} else { } else {
pShader->setUniform(KRPipeline::Uniform::material_diffuse, m_diffuseColor); pShader->setUniform(KRPipeline::Uniform::material_diffuse, m_diffuseColor);
} }
if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) { if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
// We pre-multiply the light color with the material color in the forward renderer // We pre-multiply the light color with the material color in the forward renderer
pShader->setUniform(KRPipeline::Uniform::material_specular, Vector3::Create(m_specularColor.x * ri.camera->settings.light_intensity.x, m_specularColor.y * ri.camera->settings.light_intensity.y, m_specularColor.z * ri.camera->settings.light_intensity.z)); pShader->setUniform(KRPipeline::Uniform::material_specular, Vector3::Create(m_specularColor.x * ri.camera->settings.light_intensity.x, m_specularColor.y * ri.camera->settings.light_intensity.y, m_specularColor.z * ri.camera->settings.light_intensity.z));
} else { } else {
@@ -419,23 +438,23 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
pShader->setUniform(KRPipeline::Uniform::material_alpha, m_tr); pShader->setUniform(KRPipeline::Uniform::material_alpha, m_tr);
if(bDiffuseMap) { if (bDiffuseMap) {
m_pContext->getTextureManager()->selectTexture(0, m_pDiffuseMap, lod_coverage, KRTexture::TEXTURE_USAGE_DIFFUSE_MAP); m_pContext->getTextureManager()->selectTexture(0, m_pDiffuseMap, lod_coverage, KRTexture::TEXTURE_USAGE_DIFFUSE_MAP);
} }
if(bSpecMap) { if (bSpecMap) {
m_pContext->getTextureManager()->selectTexture(1, m_pSpecularMap, lod_coverage, KRTexture::TEXTURE_USAGE_SPECULAR_MAP); m_pContext->getTextureManager()->selectTexture(1, m_pSpecularMap, lod_coverage, KRTexture::TEXTURE_USAGE_SPECULAR_MAP);
} }
if(bNormalMap) { if (bNormalMap) {
m_pContext->getTextureManager()->selectTexture(2, m_pNormalMap, lod_coverage, KRTexture::TEXTURE_USAGE_NORMAL_MAP); m_pContext->getTextureManager()->selectTexture(2, m_pNormalMap, lod_coverage, KRTexture::TEXTURE_USAGE_NORMAL_MAP);
} }
if(bReflectionCubeMap && (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE || ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT || ri.renderPass == KRNode::RENDER_PASS_DEFERRED_OPAQUE)) { if (bReflectionCubeMap && (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE || ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT || ri.renderPass == KRNode::RENDER_PASS_DEFERRED_OPAQUE)) {
m_pContext->getTextureManager()->selectTexture(4, m_pReflectionCube, lod_coverage, KRTexture::TEXTURE_USAGE_REFECTION_CUBE); m_pContext->getTextureManager()->selectTexture(4, m_pReflectionCube, lod_coverage, KRTexture::TEXTURE_USAGE_REFECTION_CUBE);
} }
if(bReflectionMap && (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE || ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT || ri.renderPass == KRNode::RENDER_PASS_DEFERRED_OPAQUE)) { if (bReflectionMap && (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE || ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT || ri.renderPass == KRNode::RENDER_PASS_DEFERRED_OPAQUE)) {
// GL_TEXTURE7 is used for reading the depth buffer in gBuffer pass 2 and re-used for the reflection map in gBuffer Pass 3 and in forward rendering // GL_TEXTURE7 is used for reading the depth buffer in gBuffer pass 2 and re-used for the reflection map in gBuffer Pass 3 and in forward rendering
m_pContext->getTextureManager()->selectTexture(7, m_pReflectionMap, lod_coverage, KRTexture::TEXTURE_USAGE_REFLECTION_MAP); m_pContext->getTextureManager()->selectTexture(7, m_pReflectionMap, lod_coverage, KRTexture::TEXTURE_USAGE_REFLECTION_MAP);
} }
@@ -443,7 +462,7 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, matModel, &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, matModel, &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);
} }
const std::string &KRMaterial::getName() const const std::string& KRMaterial::getName() const
{ {
return m_name; return m_name;
} }

32
kraken/KRMaterial.h
View File

@@ -50,20 +50,22 @@ class KRTextureManager;
class KRContext; class KRContext;
class KRSurface; class KRSurface;
class KRMaterial : public KRResource { class KRMaterial : public KRResource
{
public: public:
typedef enum { typedef enum
{
KRMATERIAL_ALPHA_MODE_OPAQUE, // Non-transparent materials KRMATERIAL_ALPHA_MODE_OPAQUE, // Non-transparent materials
KRMATERIAL_ALPHA_MODE_TEST, // Alpha in diffuse texture is interpreted as punch-through when < 0.5 KRMATERIAL_ALPHA_MODE_TEST, // Alpha in diffuse texture is interpreted as punch-through when < 0.5
KRMATERIAL_ALPHA_MODE_BLENDONESIDE, // Blended alpha with backface culling KRMATERIAL_ALPHA_MODE_BLENDONESIDE, // Blended alpha with backface culling
KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE // Blended alpha rendered in two passes. First pass renders backfaces; second pass renders frontfaces. KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE // Blended alpha rendered in two passes. First pass renders backfaces; second pass renders frontfaces.
} alpha_mode_type; } alpha_mode_type;
KRMaterial(KRContext &context, const char *szName); KRMaterial(KRContext& context, const char* szName);
virtual ~KRMaterial(); virtual ~KRMaterial();
virtual std::string getExtension(); virtual std::string getExtension();
virtual bool save(KRDataBlock &data); virtual bool save(KRDataBlock& data);
void setAmbientMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset); void setAmbientMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset);
@@ -72,10 +74,10 @@ public:
void setReflectionMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset); void setReflectionMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset);
void setReflectionCube(std::string texture_name); void setReflectionCube(std::string texture_name);
void setNormalMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset); void setNormalMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset);
void setAmbient(const Vector3 &c); void setAmbient(const Vector3& c);
void setDiffuse(const Vector3 &c); void setDiffuse(const Vector3& c);
void setSpecular(const Vector3 &c); void setSpecular(const Vector3& c);
void setReflection(const Vector3 &c); void setReflection(const Vector3& c);
void setTransparency(float a); void setTransparency(float a);
void setShininess(float s); void setShininess(float s);
void setAlphaMode(alpha_mode_type blend_mode); void setAlphaMode(alpha_mode_type blend_mode);
@@ -83,7 +85,7 @@ public:
bool isTransparent(); bool isTransparent();
const std::string &getName() const; const std::string& getName() const;
void bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_t vertexAttributes, CullMode cullMode, const std::vector<KRBone*>& bones, const std::vector<Matrix4>& bind_poses, const Matrix4& matModel, KRTexture* pLightMap, const Vector3& rim_color, float rim_power, float lod_coverage = 0.0f); void bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_t vertexAttributes, CullMode cullMode, const std::vector<KRBone*>& bones, const std::vector<Matrix4>& bind_poses, const Matrix4& matModel, KRTexture* pLightMap, const Vector3& rim_color, float rim_power, float lod_coverage = 0.0f);
@@ -95,12 +97,12 @@ public:
private: private:
std::string m_name; std::string m_name;
KRTexture *m_pAmbientMap; // mtl map_Ka value KRTexture* m_pAmbientMap; // mtl map_Ka value
KRTexture *m_pDiffuseMap; // mtl map_Kd value KRTexture* m_pDiffuseMap; // mtl map_Kd value
KRTexture *m_pSpecularMap; // mtl map_Ks value KRTexture* m_pSpecularMap; // mtl map_Ks value
KRTexture *m_pReflectionMap; // mtl refl value KRTexture* m_pReflectionMap; // mtl refl value
KRTexture *m_pReflectionCube; KRTexture* m_pReflectionCube;
KRTexture *m_pNormalMap; // mtl map_Normal value KRTexture* m_pNormalMap; // mtl map_Normal value
std::string m_ambientMap; std::string m_ambientMap;
std::string m_diffuseMap; std::string m_diffuseMap;
std::string m_specularMap; std::string m_specularMap;

140
kraken/KRMaterialManager.cpp
View File

@@ -33,13 +33,14 @@
#include "KRMaterialManager.h" #include "KRMaterialManager.h"
KRMaterialManager::KRMaterialManager(KRContext &context, KRTextureManager *pTextureManager, KRPipelineManager *pPipelineManager) : KRResourceManager(context) KRMaterialManager::KRMaterialManager(KRContext& context, KRTextureManager* pTextureManager, KRPipelineManager* pPipelineManager) : KRResourceManager(context)
{ {
m_pTextureManager = pTextureManager; m_pTextureManager = pTextureManager;
m_pPipelineManager = pPipelineManager; m_pPipelineManager = pPipelineManager;
} }
KRMaterialManager::~KRMaterialManager() { KRMaterialManager::~KRMaterialManager()
{
} }
@@ -62,19 +63,20 @@ KRResource* KRMaterialManager::getResource(const std::string& name, const std::s
return nullptr; return nullptr;
} }
unordered_map<std::string, KRMaterial *> &KRMaterialManager::getMaterials() unordered_map<std::string, KRMaterial*>& KRMaterialManager::getMaterials()
{ {
return m_materials; return m_materials;
} }
KRMaterial *KRMaterialManager::getMaterial(const std::string &name) { KRMaterial* KRMaterialManager::getMaterial(const std::string& name)
{
std::string lowerName = name; std::string lowerName = name;
std::transform(lowerName.begin(), lowerName.end(), std::transform(lowerName.begin(), lowerName.end(),
lowerName.begin(), ::tolower); lowerName.begin(), ::tolower);
unordered_map<std::string, KRMaterial *>::iterator itr = m_materials.find(lowerName); unordered_map<std::string, KRMaterial*>::iterator itr = m_materials.find(lowerName);
if(itr == m_materials.end()) { if (itr == m_materials.end()) {
KRContext::Log(KRContext::LOG_LEVEL_WARNING, "Material not found: %s", name.c_str()); KRContext::Log(KRContext::LOG_LEVEL_WARNING, "Material not found: %s", name.c_str());
// Not found // Not found
return NULL; return NULL;
@@ -83,7 +85,8 @@ KRMaterial *KRMaterialManager::getMaterial(const std::string &name) {
} }
} }
void KRMaterialManager::add(KRMaterial *new_material) { void KRMaterialManager::add(KRMaterial* new_material)
{
// FINDME, TODO - Potential memory leak if multiple materials with the same name are added // FINDME, TODO - Potential memory leak if multiple materials with the same name are added
std::string lowerName = new_material->getName(); std::string lowerName = new_material->getName();
std::transform(lowerName.begin(), lowerName.end(), std::transform(lowerName.begin(), lowerName.end(),
@@ -92,34 +95,35 @@ void KRMaterialManager::add(KRMaterial *new_material) {
m_materials[lowerName] = new_material; m_materials[lowerName] = new_material;
} }
KRMaterial* KRMaterialManager::load(const char *szName, KRDataBlock *data) { KRMaterial* KRMaterialManager::load(const char* szName, KRDataBlock* data)
KRMaterial *pMaterial = NULL; {
KRMaterial* pMaterial = NULL;
char szSymbol[16][256]; char szSymbol[16][256];
data->lock(); data->lock();
char *pScan = (char *)data->getStart(); char* pScan = (char*)data->getStart();
char *pEnd = (char *)data->getEnd(); char* pEnd = (char*)data->getEnd();
while(pScan < pEnd) { while (pScan < pEnd) {
// Scan through whitespace // Scan through whitespace
while(pScan < pEnd && (*pScan == ' ' || *pScan == '\t' || *pScan == '\r' || *pScan == '\n')) { while (pScan < pEnd && (*pScan == ' ' || *pScan == '\t' || *pScan == '\r' || *pScan == '\n')) {
pScan++; pScan++;
} }
if(*pScan == '#') { if (*pScan == '#') {
// Line is a comment line // Line is a comment line
// Scan to the end of the line // Scan to the end of the line
while(pScan < pEnd && *pScan != '\r' && *pScan != '\n') { while (pScan < pEnd && *pScan != '\r' && *pScan != '\n') {
pScan++; pScan++;
} }
} else { } else {
int cSymbols = 0; int cSymbols = 0;
while(pScan < pEnd && *pScan != '\n' && *pScan != '\r') { while (pScan < pEnd && *pScan != '\n' && *pScan != '\r') {
char *pDest = szSymbol[cSymbols++]; char* pDest = szSymbol[cSymbols++];
while(pScan < pEnd && *pScan != ' ' && *pScan != '\n' && *pScan != '\r') { while (pScan < pEnd && *pScan != ' ' && *pScan != '\n' && *pScan != '\r') {
if(*pScan >= 'A' && *pScan <= 'Z') { if (*pScan >= 'A' && *pScan <= 'Z') {
*pDest++ = *pScan++ + 'a' - 'A'; // convert to lower case for case sensitve comparison later *pDest++ = *pScan++ + 'a' - 'A'; // convert to lower case for case sensitve comparison later
} else { } else {
*pDest++ = *pScan++; *pDest++ = *pScan++;
@@ -128,98 +132,98 @@ KRMaterial* KRMaterialManager::load(const char *szName, KRDataBlock *data) {
*pDest = '\0'; *pDest = '\0';
// Scan through whitespace, but don't advance to next line // Scan through whitespace, but don't advance to next line
while(pScan < pEnd && (*pScan == ' ' || *pScan == '\t')) { while (pScan < pEnd && (*pScan == ' ' || *pScan == '\t')) {
pScan++; pScan++;
} }
} }
if(cSymbols > 0) { if (cSymbols > 0) {
if(strcmp(szSymbol[0], "newmtl") == 0 && cSymbols >= 2) { if (strcmp(szSymbol[0], "newmtl") == 0 && cSymbols >= 2) {
pMaterial = new KRMaterial(*m_pContext, szSymbol[1]); pMaterial = new KRMaterial(*m_pContext, szSymbol[1]);
m_materials[szSymbol[1]] = pMaterial; m_materials[szSymbol[1]] = pMaterial;
} }
if(pMaterial != NULL) { if (pMaterial != NULL) {
if(strcmp(szSymbol[0], "alpha_mode") == 0) { if (strcmp(szSymbol[0], "alpha_mode") == 0) {
if(cSymbols == 2) { if (cSymbols == 2) {
if(strcmp(szSymbol[1], "test") == 0) { if (strcmp(szSymbol[1], "test") == 0) {
pMaterial->setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_TEST); pMaterial->setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_TEST);
} else if(strcmp(szSymbol[1], "blendoneside") == 0) { } else if (strcmp(szSymbol[1], "blendoneside") == 0) {
pMaterial->setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_BLENDONESIDE); pMaterial->setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_BLENDONESIDE);
} else if(strcmp(szSymbol[1], "blendtwoside") == 0) { } else if (strcmp(szSymbol[1], "blendtwoside") == 0) {
pMaterial->setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE); pMaterial->setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE);
} else { } else {
pMaterial->setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_OPAQUE); pMaterial->setAlphaMode(KRMaterial::KRMATERIAL_ALPHA_MODE_OPAQUE);
} }
} }
} else if(strcmp(szSymbol[0], "ka") == 0) { } else if (strcmp(szSymbol[0], "ka") == 0) {
char *pScan2 = szSymbol[1]; char* pScan2 = szSymbol[1];
float r = strtof(pScan2, &pScan2); float r = strtof(pScan2, &pScan2);
if(cSymbols == 2) { if (cSymbols == 2) {
pMaterial->setAmbient(Vector3::Create(r, r, r)); pMaterial->setAmbient(Vector3::Create(r, r, r));
} else if(cSymbols == 4) { } else if (cSymbols == 4) {
pScan2 = szSymbol[2]; pScan2 = szSymbol[2];
float g = strtof(pScan2, &pScan2); float g = strtof(pScan2, &pScan2);
pScan2 = szSymbol[3]; pScan2 = szSymbol[3];
float b = strtof(pScan2, &pScan2); float b = strtof(pScan2, &pScan2);
pMaterial->setAmbient(Vector3::Create(r, g, b)); pMaterial->setAmbient(Vector3::Create(r, g, b));
} }
} else if(strcmp(szSymbol[0], "kd") == 0) { } else if (strcmp(szSymbol[0], "kd") == 0) {
char *pScan2 = szSymbol[1]; char* pScan2 = szSymbol[1];
float r = strtof(pScan2, &pScan2); float r = strtof(pScan2, &pScan2);
if(cSymbols == 2) { if (cSymbols == 2) {
pMaterial->setDiffuse(Vector3::Create(r, r, r)); pMaterial->setDiffuse(Vector3::Create(r, r, r));
} else if(cSymbols == 4) { } else if (cSymbols == 4) {
pScan2 = szSymbol[2]; pScan2 = szSymbol[2];
float g = strtof(pScan2, &pScan2); float g = strtof(pScan2, &pScan2);
pScan2 = szSymbol[3]; pScan2 = szSymbol[3];
float b = strtof(pScan2, &pScan2); float b = strtof(pScan2, &pScan2);
pMaterial->setDiffuse(Vector3::Create(r, g, b)); pMaterial->setDiffuse(Vector3::Create(r, g, b));
} }
} else if(strcmp(szSymbol[0], "ks") == 0) { } else if (strcmp(szSymbol[0], "ks") == 0) {
char *pScan2 = szSymbol[1]; char* pScan2 = szSymbol[1];
float r = strtof(pScan2, &pScan2); float r = strtof(pScan2, &pScan2);
if(cSymbols == 2) { if (cSymbols == 2) {
pMaterial->setSpecular(Vector3::Create(r, r, r)); pMaterial->setSpecular(Vector3::Create(r, r, r));
} else if(cSymbols == 4) { } else if (cSymbols == 4) {
pScan2 = szSymbol[2]; pScan2 = szSymbol[2];
float g = strtof(pScan2, &pScan2); float g = strtof(pScan2, &pScan2);
pScan2 = szSymbol[3]; pScan2 = szSymbol[3];
float b = strtof(pScan2, &pScan2); float b = strtof(pScan2, &pScan2);
pMaterial->setSpecular(Vector3::Create(r, g, b)); pMaterial->setSpecular(Vector3::Create(r, g, b));
} }
} else if(strcmp(szSymbol[0], "kr") == 0) { } else if (strcmp(szSymbol[0], "kr") == 0) {
char *pScan2 = szSymbol[1]; char* pScan2 = szSymbol[1];
float r = strtof(pScan2, &pScan2); float r = strtof(pScan2, &pScan2);
if(cSymbols == 2) { if (cSymbols == 2) {
pMaterial->setReflection(Vector3::Create(r, r, r)); pMaterial->setReflection(Vector3::Create(r, r, r));
} else if(cSymbols == 4) { } else if (cSymbols == 4) {
pScan2 = szSymbol[2]; pScan2 = szSymbol[2];
float g = strtof(pScan2, &pScan2); float g = strtof(pScan2, &pScan2);
pScan2 = szSymbol[3]; pScan2 = szSymbol[3];
float b = strtof(pScan2, &pScan2); float b = strtof(pScan2, &pScan2);
pMaterial->setReflection(Vector3::Create(r, g, b)); pMaterial->setReflection(Vector3::Create(r, g, b));
} }
} else if(strcmp(szSymbol[0], "tr") == 0) { } else if (strcmp(szSymbol[0], "tr") == 0) {
char *pScan2 = szSymbol[1]; char* pScan2 = szSymbol[1];
float a = strtof(pScan2, &pScan2); float a = strtof(pScan2, &pScan2);
pMaterial->setTransparency(a); pMaterial->setTransparency(a);
} else if(strcmp(szSymbol[0], "ns") == 0) { } else if (strcmp(szSymbol[0], "ns") == 0) {
char *pScan2 = szSymbol[1]; char* pScan2 = szSymbol[1];
float a = strtof(pScan2, &pScan2); float a = strtof(pScan2, &pScan2);
pMaterial->setShininess(a); pMaterial->setShininess(a);
} else if(strncmp(szSymbol[0], "map", 3) == 0) { } else if (strncmp(szSymbol[0], "map", 3) == 0) {
// Truncate file extension // Truncate file extension
char *pScan2 = szSymbol[1]; char* pScan2 = szSymbol[1];
char *pLastPeriod = NULL; char* pLastPeriod = NULL;
while(*pScan2 != '\0') { while (*pScan2 != '\0') {
if(*pScan2 == '.') { if (*pScan2 == '.') {
pLastPeriod = pScan2; pLastPeriod = pScan2;
} }
pScan2++; pScan2++;
} }
if(pLastPeriod) { if (pLastPeriod) {
*pLastPeriod = '\0'; *pLastPeriod = '\0';
} }
@@ -229,28 +233,28 @@ KRMaterial* KRMaterialManager::load(const char *szName, KRDataBlock *data) {
int iScanSymbol = 2; int iScanSymbol = 2;
int iScaleParam = -1; int iScaleParam = -1;
int iOffsetParam = -1; int iOffsetParam = -1;
while(iScanSymbol < cSymbols) { while (iScanSymbol < cSymbols) {
if(strcmp(szSymbol[iScanSymbol], "-s") == 0) { if (strcmp(szSymbol[iScanSymbol], "-s") == 0) {
// Scale // Scale
iScaleParam = 0; iScaleParam = 0;
iOffsetParam = -1; iOffsetParam = -1;
} else if(strcmp(szSymbol[iScanSymbol], "-o") == 0) { } else if (strcmp(szSymbol[iScanSymbol], "-o") == 0) {
// Offset // Offset
iOffsetParam = 0; iOffsetParam = 0;
iScaleParam = -1; iScaleParam = -1;
} else { } else {
char *pScan3 = szSymbol[iScanSymbol]; char* pScan3 = szSymbol[iScanSymbol];
float v = strtof(pScan3, &pScan3); float v = strtof(pScan3, &pScan3);
if(iScaleParam == 0) { if (iScaleParam == 0) {
texture_scale.x = v; texture_scale.x = v;
iScaleParam++; iScaleParam++;
} else if(iScaleParam == 1) { } else if (iScaleParam == 1) {
texture_scale.y = v; texture_scale.y = v;
iScaleParam++; iScaleParam++;
} else if(iOffsetParam == 0) { } else if (iOffsetParam == 0) {
texture_offset.x = v; texture_offset.x = v;
iOffsetParam++; iOffsetParam++;
} else if(iOffsetParam == 1) { } else if (iOffsetParam == 1) {
texture_offset.y = v; texture_offset.y = v;
iOffsetParam++; iOffsetParam++;
} }
@@ -258,17 +262,17 @@ KRMaterial* KRMaterialManager::load(const char *szName, KRDataBlock *data) {
iScanSymbol++; iScanSymbol++;
} }
if(strcmp(szSymbol[0], "map_ka") == 0) { if (strcmp(szSymbol[0], "map_ka") == 0) {
pMaterial->setAmbientMap(szSymbol[1], texture_scale, texture_offset); pMaterial->setAmbientMap(szSymbol[1], texture_scale, texture_offset);
} else if(strcmp(szSymbol[0], "map_kd") == 0) { } else if (strcmp(szSymbol[0], "map_kd") == 0) {
pMaterial->setDiffuseMap(szSymbol[1], texture_scale, texture_offset); pMaterial->setDiffuseMap(szSymbol[1], texture_scale, texture_offset);
} else if(strcmp(szSymbol[0], "map_ks") == 0) { } else if (strcmp(szSymbol[0], "map_ks") == 0) {
pMaterial->setSpecularMap(szSymbol[1], texture_scale, texture_offset); pMaterial->setSpecularMap(szSymbol[1], texture_scale, texture_offset);
} else if(strcmp(szSymbol[0], "map_normal") == 0) { } else if (strcmp(szSymbol[0], "map_normal") == 0) {
pMaterial->setNormalMap(szSymbol[1], texture_scale, texture_offset); pMaterial->setNormalMap(szSymbol[1], texture_scale, texture_offset);
} else if(strcmp(szSymbol[0], "map_reflection") == 0) { } else if (strcmp(szSymbol[0], "map_reflection") == 0) {
pMaterial->setReflectionMap(szSymbol[1], texture_scale, texture_offset); pMaterial->setReflectionMap(szSymbol[1], texture_scale, texture_offset);
} else if(strcmp(szSymbol[0], "map_reflectioncube") == 0) { } else if (strcmp(szSymbol[0], "map_reflectioncube") == 0) {
pMaterial->setReflectionCube(szSymbol[1]); pMaterial->setReflectionCube(szSymbol[1]);
} }
} }

19
kraken/KRMaterialManager.h
View File

@@ -43,23 +43,24 @@ class KRMaterial;
using std::map; using std::map;
class KRMaterialManager : public KRResourceManager { class KRMaterialManager : public KRResourceManager
{
public: public:
KRMaterialManager(KRContext &context, KRTextureManager *pTextureManager, KRPipelineManager *pPipelineManager); KRMaterialManager(KRContext& context, KRTextureManager* pTextureManager, KRPipelineManager* pPipelineManager);
virtual ~KRMaterialManager(); virtual ~KRMaterialManager();
virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
virtual KRResource* getResource(const std::string& name, const std::string& extension) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override;
KRMaterial* load(const char *szName, KRDataBlock *data); KRMaterial* load(const char* szName, KRDataBlock* data);
void add(KRMaterial *new_material); void add(KRMaterial* new_material);
KRMaterial *getMaterial(const std::string &name); KRMaterial* getMaterial(const std::string& name);
unordered_map<std::string, KRMaterial *> &getMaterials(); unordered_map<std::string, KRMaterial*>& getMaterials();
private: private:
unordered_map<std::string, KRMaterial *> m_materials; unordered_map<std::string, KRMaterial*> m_materials;
KRTextureManager *m_pTextureManager; KRTextureManager* m_pTextureManager;
KRPipelineManager *m_pPipelineManager; KRPipelineManager* m_pPipelineManager;
}; };

652
kraken/KRMesh.cpp
View File

File diff suppressed because it is too large Load Diff

111
kraken/KRMesh.h
View File

@@ -65,13 +65,14 @@ enum class ModelFormat : __uint8_t
KRENGINE_MODEL_FORMAT_INDEXED_STRIP KRENGINE_MODEL_FORMAT_INDEXED_STRIP
}; };
class KRMesh : public KRResource { class KRMesh : public KRResource
{
public: public:
static void parseName(const std::string& name, std::string& lodBaseName, int& lodCoverage); static void parseName(const std::string& name, std::string& lodBaseName, int& lodCoverage);
KRMesh(KRContext &context, std::string name, KRDataBlock *data); KRMesh(KRContext& context, std::string name, KRDataBlock* data);
KRMesh(KRContext &context, std::string name); KRMesh(KRContext& context, std::string name);
virtual ~KRMesh(); virtual ~KRMesh();
kraken_stream_level getStreamLevel(); kraken_stream_level getStreamLevel();
@@ -79,7 +80,8 @@ public:
bool hasTransparency(); bool hasTransparency();
typedef enum { typedef enum
{
KRENGINE_ATTRIB_VERTEX = 0, KRENGINE_ATTRIB_VERTEX = 0,
KRENGINE_ATTRIB_NORMAL, KRENGINE_ATTRIB_NORMAL,
KRENGINE_ATTRIB_TANGENT, KRENGINE_ATTRIB_TANGENT,
@@ -97,7 +99,8 @@ public:
typedef struct { typedef struct
{
ModelFormat format; ModelFormat format;
std::vector<Vector3> vertices; std::vector<Vector3> vertices;
std::vector<__uint16_t> vertex_indexes; std::vector<__uint16_t> vertex_indexes;
@@ -115,16 +118,16 @@ public:
std::vector<std::vector<float> > bone_weights; std::vector<std::vector<float> > bone_weights;
} mesh_info; } mesh_info;
void render(const KRNode::RenderInfo& ri, const std::string &object_name, const Matrix4 &matModel, KRTexture *pLightMap, const std::vector<KRBone *> &bones, const Vector3 &rim_color, float rim_power, float lod_coverage = 0.0f); void render(const KRNode::RenderInfo& ri, const std::string& object_name, const Matrix4& matModel, KRTexture* pLightMap, const std::vector<KRBone*>& bones, const Vector3& rim_color, float rim_power, float lod_coverage = 0.0f);
std::string m_lodBaseName; std::string m_lodBaseName;
virtual std::string getExtension(); virtual std::string getExtension();
virtual bool save(const std::string& path); virtual bool save(const std::string& path);
virtual bool save(KRDataBlock &data); virtual bool save(KRDataBlock& data);
void LoadData(const mesh_info &mi, bool calculate_normals, bool calculate_tangents); void LoadData(const mesh_info& mi, bool calculate_normals, bool calculate_tangents);
void loadPack(KRDataBlock *data); void loadPack(KRDataBlock* data);
void convertToIndexed(); void convertToIndexed();
void optimize(); void optimize();
@@ -138,17 +141,20 @@ public:
Vector3 getMinPoint() const; Vector3 getMinPoint() const;
Vector3 getMaxPoint() const; Vector3 getMaxPoint() const;
class Submesh { class Submesh
{
public: public:
Submesh() {}; Submesh()
~Submesh() { {};
for(auto itr = vbo_data_blocks.begin(); itr != vbo_data_blocks.end(); itr++) { ~Submesh()
{
for (auto itr = vbo_data_blocks.begin(); itr != vbo_data_blocks.end(); itr++) {
delete (*itr); delete (*itr);
} }
for(auto itr = vertex_data_blocks.begin(); itr != vertex_data_blocks.end(); itr++) { for (auto itr = vertex_data_blocks.begin(); itr != vertex_data_blocks.end(); itr++) {
delete (*itr); delete (*itr);
} }
for(auto itr = index_data_blocks.begin(); itr != index_data_blocks.end(); itr++) { for (auto itr = index_data_blocks.begin(); itr != index_data_blocks.end(); itr++) {
delete (*itr); delete (*itr);
} }
}; };
@@ -156,14 +162,17 @@ public:
GLint start_vertex; GLint start_vertex;
GLsizei vertex_count; GLsizei vertex_count;
char szMaterialName[KRENGINE_MAX_NAME_LENGTH]; char szMaterialName[KRENGINE_MAX_NAME_LENGTH];
vector<KRDataBlock *> vertex_data_blocks; vector<KRDataBlock*> vertex_data_blocks;
vector<KRDataBlock *> index_data_blocks; vector<KRDataBlock*> index_data_blocks;
vector<KRMeshManager::KRVBOData *> vbo_data_blocks; vector<KRMeshManager::KRVBOData*> vbo_data_blocks;
}; };
typedef struct { typedef struct
union { {
struct { // For Indexed triangles / strips union
{
struct
{ // For Indexed triangles / strips
uint16_t index_group; uint16_t index_group;
uint16_t index_group_offset; uint16_t index_group_offset;
}; };
@@ -173,7 +182,8 @@ public:
char szName[KRENGINE_MAX_NAME_LENGTH]; char szName[KRENGINE_MAX_NAME_LENGTH];
} pack_material; } pack_material;
typedef struct { typedef struct
{
char szName[KRENGINE_MAX_NAME_LENGTH]; char szName[KRENGINE_MAX_NAME_LENGTH];
float bind_pose[16]; float bind_pose[16];
} pack_bone; } pack_bone;
@@ -182,7 +192,7 @@ public:
std::string getLODBaseName() const; std::string getLODBaseName() const;
static bool lod_sort_predicate(const KRMesh *m1, const KRMesh *m2); static bool lod_sort_predicate(const KRMesh* m1, const KRMesh* m2);
bool has_vertex_attribute(vertex_attrib_t attribute_type) const; bool has_vertex_attribute(vertex_attrib_t attribute_type) const;
static bool has_vertex_attribute(int vertex_attrib_flags, vertex_attrib_t attribute_type); static bool has_vertex_attribute(int vertex_attrib_flags, vertex_attrib_t attribute_type);
@@ -199,11 +209,11 @@ public:
int getBoneIndex(int index, int weight_index) const; int getBoneIndex(int index, int weight_index) const;
float getBoneWeight(int index, int weight_index) const; float getBoneWeight(int index, int weight_index) const;
void setVertexPosition(int index, const Vector3 &v); void setVertexPosition(int index, const Vector3& v);
void setVertexNormal(int index, const Vector3 &v); void setVertexNormal(int index, const Vector3& v);
void setVertexTangent(int index, const Vector3 & v); void setVertexTangent(int index, const Vector3& v);
void setVertexUVA(int index, const Vector2 &v); void setVertexUVA(int index, const Vector2& v);
void setVertexUVB(int index, const Vector2 &v); void setVertexUVB(int index, const Vector2& v);
void setBoneIndex(int index, int weight_index, int bone_index); void setBoneIndex(int index, int weight_index, int bone_index);
void setBoneWeight(int index, int weight_index, float bone_weight); void setBoneWeight(int index, int weight_index, float bone_weight);
@@ -212,36 +222,36 @@ public:
static VkFormat AttributeVulkanFormat(__int32 vertex_attrib); static VkFormat AttributeVulkanFormat(__int32 vertex_attrib);
int getBoneCount(); int getBoneCount();
char *getBoneName(int bone_index); char* getBoneName(int bone_index);
Matrix4 getBoneBindPose(int bone_index); Matrix4 getBoneBindPose(int bone_index);
ModelFormat getModelFormat() const; ModelFormat getModelFormat() const;
bool lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo) const; bool lineCast(const Vector3& v0, const Vector3& v1, HitInfo& hitinfo) const;
bool rayCast(const Vector3 &v0, const Vector3 &dir, HitInfo &hitinfo) const; bool rayCast(const Vector3& v0, const Vector3& dir, HitInfo& hitinfo) const;
bool sphereCast(const Matrix4 &model_to_world, const Vector3 &v0, const Vector3 &v1, float radius, HitInfo &hitinfo) const; bool sphereCast(const Matrix4& model_to_world, const Vector3& v0, const Vector3& v1, float radius, HitInfo& hitinfo) const;
static int GetLODCoverage(const std::string &name); static int GetLODCoverage(const std::string& name);
protected: protected:
bool m_constant; // TRUE if this should be always loaded and should not be passed through the streamer bool m_constant; // TRUE if this should be always loaded and should not be passed through the streamer
private: private:
KRDataBlock *m_pData; KRDataBlock* m_pData;
KRDataBlock *m_pMetaData; KRDataBlock* m_pMetaData;
KRDataBlock *m_pIndexBaseData; KRDataBlock* m_pIndexBaseData;
void getSubmeshes(); void getSubmeshes();
void getMaterials(); void getMaterials();
void renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage); void renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
static bool rayCast(const Vector3 &start, const Vector3 &dir, const Triangle3 &tri, const Vector3 &tri_n0, const Vector3 &tri_n1, const Vector3 &tri_n2, HitInfo &hitinfo); static bool rayCast(const Vector3& start, const Vector3& dir, const Triangle3& tri, const Vector3& tri_n0, const Vector3& tri_n1, const Vector3& tri_n2, HitInfo& hitinfo);
static bool sphereCast(const Matrix4 &model_to_world, const Vector3 &v0, const Vector3 &v1, float radius, const Triangle3 &tri, HitInfo &hitinfo); static bool sphereCast(const Matrix4& model_to_world, const Vector3& v0, const Vector3& v1, float radius, const Triangle3& tri, HitInfo& hitinfo);
int m_lodCoverage; // This LOD level is activated when the bounding box of the model will cover less than this percent of the screen (100 = highest detail model) int m_lodCoverage; // This LOD level is activated when the bounding box of the model will cover less than this percent of the screen (100 = highest detail model)
vector<KRMaterial *> m_materials; vector<KRMaterial*> m_materials;
set<KRMaterial *> m_uniqueMaterials; set<KRMaterial*> m_uniqueMaterials;
bool m_hasTransparency; bool m_hasTransparency;
@@ -251,7 +261,8 @@ private:
typedef struct { typedef struct
{
char szTag[16]; char szTag[16];
int32_t model_format; // 0 == Triangle list, 1 == Triangle strips, 2 == Indexed triangle list, 3 == Indexed triangle strips, rest are reserved (model_format_t enum) int32_t model_format; // 0 == Triangle list, 1 == Triangle strips, 2 == Indexed triangle list, 3 == Indexed triangle strips, rest are reserved (model_format_t enum)
int32_t vertex_attrib_flags; int32_t vertex_attrib_flags;
@@ -264,7 +275,7 @@ private:
unsigned char reserved[444]; // Pad out to 512 bytes unsigned char reserved[444]; // Pad out to 512 bytes
} pack_header; } pack_header;
vector<Submesh *> m_submeshes; vector<Submesh*> m_submeshes;
int m_vertex_attribute_offset[KRENGINE_NUM_ATTRIBUTES]; int m_vertex_attribute_offset[KRENGINE_NUM_ATTRIBUTES];
int m_vertex_size; int m_vertex_size;
void updateAttributeOffsets(); void updateAttributeOffsets();
@@ -273,18 +284,18 @@ private:
pack_material *getSubmesh(int mesh_index) const; pack_material* getSubmesh(int mesh_index) const;
unsigned char *getVertexData() const; unsigned char* getVertexData() const;
size_t getVertexDataOffset() const; size_t getVertexDataOffset() const;
unsigned char *getVertexData(int index) const; unsigned char* getVertexData(int index) const;
__uint16_t *getIndexData() const; __uint16_t* getIndexData() const;
size_t getIndexDataOffset() const; size_t getIndexDataOffset() const;
__uint32_t *getIndexBaseData() const; __uint32_t* getIndexBaseData() const;
pack_header *getHeader() const; pack_header* getHeader() const;
pack_bone *getBone(int index); pack_bone* getBone(int index);
void getIndexedRange(int index_group, int &start_index_offset, int &start_vertex_offset, int &index_count, int &vertex_count) const; void getIndexedRange(int index_group, int& start_index_offset, int& start_vertex_offset, int& index_count, int& vertex_count) const;
void releaseData(); void releaseData();

22
kraken/KRMeshCube.cpp
View File

@@ -32,7 +32,7 @@
#include "KRMeshCube.h" #include "KRMeshCube.h"
KRMeshCube::KRMeshCube(KRContext &context) : KRMesh(context, "__cube") KRMeshCube::KRMeshCube(KRContext& context) : KRMesh(context, "__cube")
{ {
m_constant = true; m_constant = true;
@@ -40,18 +40,18 @@ KRMeshCube::KRMeshCube(KRContext &context) : KRMesh(context, "__cube")
mi.vertices.push_back(Vector3::Create(1.0, 1.0, 1.0)); mi.vertices.push_back(Vector3::Create(1.0, 1.0, 1.0));
mi.vertices.push_back(Vector3::Create(-1.0, 1.0, 1.0)); mi.vertices.push_back(Vector3::Create(-1.0, 1.0, 1.0));
mi.vertices.push_back(Vector3::Create(1.0,-1.0, 1.0)); mi.vertices.push_back(Vector3::Create(1.0, -1.0, 1.0));
mi.vertices.push_back(Vector3::Create(-1.0,-1.0, 1.0)); mi.vertices.push_back(Vector3::Create(-1.0, -1.0, 1.0));
mi.vertices.push_back(Vector3::Create(-1.0,-1.0,-1.0)); mi.vertices.push_back(Vector3::Create(-1.0, -1.0, -1.0));
mi.vertices.push_back(Vector3::Create(-1.0, 1.0, 1.0)); mi.vertices.push_back(Vector3::Create(-1.0, 1.0, 1.0));
mi.vertices.push_back(Vector3::Create(-1.0, 1.0,-1.0)); mi.vertices.push_back(Vector3::Create(-1.0, 1.0, -1.0));
mi.vertices.push_back(Vector3::Create(1.0, 1.0, 1.0)); mi.vertices.push_back(Vector3::Create(1.0, 1.0, 1.0));
mi.vertices.push_back(Vector3::Create(1.0, 1.0,-1.0)); mi.vertices.push_back(Vector3::Create(1.0, 1.0, -1.0));
mi.vertices.push_back(Vector3::Create(1.0,-1.0, 1.0)); mi.vertices.push_back(Vector3::Create(1.0, -1.0, 1.0));
mi.vertices.push_back(Vector3::Create(1.0,-1.0,-1.0)); mi.vertices.push_back(Vector3::Create(1.0, -1.0, -1.0));
mi.vertices.push_back(Vector3::Create(-1.0,-1.0,-1.0)); mi.vertices.push_back(Vector3::Create(-1.0, -1.0, -1.0));
mi.vertices.push_back(Vector3::Create(1.0, 1.0,-1.0)); mi.vertices.push_back(Vector3::Create(1.0, 1.0, -1.0));
mi.vertices.push_back(Vector3::Create(-1.0, 1.0,-1.0)); mi.vertices.push_back(Vector3::Create(-1.0, 1.0, -1.0));
mi.submesh_starts.push_back(0); mi.submesh_starts.push_back(0);

5
kraken/KRMeshCube.h
View File

@@ -33,9 +33,10 @@
#include "KRMesh.h" #include "KRMesh.h"
class KRMeshCube : public KRMesh { class KRMeshCube : public KRMesh
{
public: public:
KRMeshCube(KRContext &context); KRMeshCube(KRContext& context);
virtual ~KRMeshCube(); virtual ~KRMeshCube();
private: private:
}; };

139
kraken/KRMeshManager.cpp
View File

@@ -50,7 +50,8 @@ KRMeshManager::KRMeshManager(KRContext& context)
} }
void KRMeshManager::init() { void KRMeshManager::init()
{
addModel(new KRMeshCube(*m_pContext)); addModel(new KRMeshCube(*m_pContext));
addModel(new KRMeshQuad(*m_pContext)); addModel(new KRMeshQuad(*m_pContext));
addModel(new KRMeshSphere(*m_pContext)); addModel(new KRMeshSphere(*m_pContext));
@@ -108,8 +109,9 @@ void KRMeshManager::init() {
} }
KRMeshManager::~KRMeshManager() { KRMeshManager::~KRMeshManager()
for(unordered_multimap<std::string, KRMesh *>::iterator itr = m_models.begin(); itr != m_models.end(); ++itr){ {
for (unordered_multimap<std::string, KRMesh*>::iterator itr = m_models.begin(); itr != m_models.end(); ++itr) {
delete (*itr).second; delete (*itr).second;
} }
m_models.clear(); m_models.clear();
@@ -138,21 +140,24 @@ KRResource* KRMeshManager::getResource(const std::string& name, const std::strin
return nullptr; return nullptr;
} }
KRMesh *KRMeshManager::loadModel(const char *szName, KRDataBlock *pData) { KRMesh* KRMeshManager::loadModel(const char* szName, KRDataBlock* pData)
KRMesh *pModel = new KRMesh(*m_pContext, szName, pData); {
KRMesh* pModel = new KRMesh(*m_pContext, szName, pData);
addModel(pModel); addModel(pModel);
return pModel; return pModel;
} }
void KRMeshManager::addModel(KRMesh *model) { void KRMeshManager::addModel(KRMesh* model)
{
std::string lowerName = model->getLODBaseName(); std::string lowerName = model->getLODBaseName();
std::transform(lowerName.begin(), lowerName.end(), std::transform(lowerName.begin(), lowerName.end(),
lowerName.begin(), ::tolower); lowerName.begin(), ::tolower);
m_models.insert(std::pair<std::string, KRMesh *>(lowerName, model)); m_models.insert(std::pair<std::string, KRMesh*>(lowerName, model));
} }
KRMesh* KRMeshManager::getMaxLODModel(const char* szName) { KRMesh* KRMeshManager::getMaxLODModel(const char* szName)
{
std::vector<KRMesh*> models = getModel(szName); std::vector<KRMesh*> models = getModel(szName);
// models are always in order of highest LOD first // models are always in order of highest LOD first
if (models.size()) { if (models.size()) {
@@ -161,46 +166,48 @@ KRMesh* KRMeshManager::getMaxLODModel(const char* szName) {
return nullptr; return nullptr;
} }
std::vector<KRMesh *> KRMeshManager::getModel(const char *szName) { std::vector<KRMesh*> KRMeshManager::getModel(const char* szName)
{
std::string lowerName = szName; std::string lowerName = szName;
std::transform(lowerName.begin(), lowerName.end(), std::transform(lowerName.begin(), lowerName.end(),
lowerName.begin(), ::tolower); lowerName.begin(), ::tolower);
std::vector<KRMesh *> matching_models; std::vector<KRMesh*> matching_models;
std::pair<unordered_multimap<std::string, KRMesh *>::iterator, unordered_multimap<std::string, KRMesh *>::iterator> range = m_models.equal_range(lowerName); std::pair<unordered_multimap<std::string, KRMesh*>::iterator, unordered_multimap<std::string, KRMesh*>::iterator> range = m_models.equal_range(lowerName);
for(unordered_multimap<std::string, KRMesh *>::iterator itr_match = range.first; itr_match != range.second; itr_match++) { for (unordered_multimap<std::string, KRMesh*>::iterator itr_match = range.first; itr_match != range.second; itr_match++) {
matching_models.push_back(itr_match->second); matching_models.push_back(itr_match->second);
} }
std::sort(matching_models.begin(), matching_models.end(), KRMesh::lod_sort_predicate); std::sort(matching_models.begin(), matching_models.end(), KRMesh::lod_sort_predicate);
if(matching_models.size() == 0) { if (matching_models.size() == 0) {
KRContext::Log(KRContext::LOG_LEVEL_INFORMATION, "Model not found: %s", lowerName.c_str()); KRContext::Log(KRContext::LOG_LEVEL_INFORMATION, "Model not found: %s", lowerName.c_str());
} }
return matching_models; return matching_models;
} }
unordered_multimap<std::string, KRMesh *> &KRMeshManager::getModels() { unordered_multimap<std::string, KRMesh*>& KRMeshManager::getModels()
{
return m_models; return m_models;
} }
void KRMeshManager::bindVBO(VkCommandBuffer& commandBuffer, KRVBOData *vbo_data, float lodCoverage) void KRMeshManager::bindVBO(VkCommandBuffer& commandBuffer, KRVBOData* vbo_data, float lodCoverage)
{ {
vbo_data->resetPoolExpiry(lodCoverage); vbo_data->resetPoolExpiry(lodCoverage);
bool vbo_changed = false; bool vbo_changed = false;
if(m_currentVBO == NULL) { if (m_currentVBO == NULL) {
vbo_changed = true; vbo_changed = true;
} else if(m_currentVBO->m_data != vbo_data->m_data) { } else if (m_currentVBO->m_data != vbo_data->m_data) {
vbo_changed = true; vbo_changed = true;
} }
if(vbo_changed) { if (vbo_changed) {
if(m_vbosActive.find(vbo_data->m_data) != m_vbosActive.end()) { if (m_vbosActive.find(vbo_data->m_data) != m_vbosActive.end()) {
m_currentVBO = m_vbosActive[vbo_data->m_data]; m_currentVBO = m_vbosActive[vbo_data->m_data];
} else { } else {
m_currentVBO = vbo_data; m_currentVBO = vbo_data;
@@ -215,7 +222,7 @@ void KRMeshManager::bindVBO(VkCommandBuffer& commandBuffer, KRVBOData *vbo_data,
void KRMeshManager::startFrame(float deltaTime) void KRMeshManager::startFrame(float deltaTime)
{ {
m_memoryTransferredThisFrame = 0; m_memoryTransferredThisFrame = 0;
if(m_draw_call_log_used) { if (m_draw_call_log_used) {
// Only log draw calls on the next frame if the draw call log was used on last frame // Only log draw calls on the next frame if the draw call log was used on last frame
m_draw_call_log_used = false; m_draw_call_log_used = false;
m_draw_call_logging_enabled = true; m_draw_call_logging_enabled = true;
@@ -225,23 +232,23 @@ void KRMeshManager::startFrame(float deltaTime)
// TODO - Implement proper double-buffering to reduce copy operations // TODO - Implement proper double-buffering to reduce copy operations
m_streamerFenceMutex.lock(); m_streamerFenceMutex.lock();
if(m_streamerComplete) { if (m_streamerComplete) {
assert(m_activeVBOs_streamer_copy.size() == 0); // The streamer should have emptied this if it really did complete assert(m_activeVBOs_streamer_copy.size() == 0); // The streamer should have emptied this if it really did complete
const long KRENGINE_VBO_EXPIRY_FRAMES = 1; const long KRENGINE_VBO_EXPIRY_FRAMES = 1;
std::set<KRVBOData *> expiredVBOs; std::set<KRVBOData*> expiredVBOs;
for(auto itr=m_vbosActive.begin(); itr != m_vbosActive.end(); itr++) { for (auto itr = m_vbosActive.begin(); itr != m_vbosActive.end(); itr++) {
KRVBOData *activeVBO = (*itr).second; KRVBOData* activeVBO = (*itr).second;
activeVBO->_swapHandles(); activeVBO->_swapHandles();
if (activeVBO->getType() == KRVBOData::CONSTANT) { if (activeVBO->getType() == KRVBOData::CONSTANT) {
// Ensure that CONSTANT data is always loaded // Ensure that CONSTANT data is always loaded
float priority = std::numeric_limits<float>::max(); float priority = std::numeric_limits<float>::max();
m_activeVBOs_streamer_copy.push_back(std::pair<float, KRVBOData*>(priority, activeVBO)); m_activeVBOs_streamer_copy.push_back(std::pair<float, KRVBOData*>(priority, activeVBO));
} else if(activeVBO->getLastFrameUsed() + KRENGINE_VBO_EXPIRY_FRAMES < getContext().getCurrentFrame()) { } else if (activeVBO->getLastFrameUsed() + KRENGINE_VBO_EXPIRY_FRAMES < getContext().getCurrentFrame()) {
// Expire VBO's that haven't been used in a long time // Expire VBO's that haven't been used in a long time
switch(activeVBO->getType()) { switch (activeVBO->getType()) {
case KRVBOData::STREAMING: case KRVBOData::STREAMING:
case KRVBOData::IMMEDIATE: case KRVBOData::IMMEDIATE:
activeVBO->unload(); activeVBO->unload();
@@ -252,16 +259,16 @@ void KRMeshManager::startFrame(float deltaTime)
} }
expiredVBOs.insert(activeVBO); expiredVBOs.insert(activeVBO);
} else if(activeVBO->getType() == KRVBOData::STREAMING) { } else if (activeVBO->getType() == KRVBOData::STREAMING) {
float priority = activeVBO->getStreamPriority(); float priority = activeVBO->getStreamPriority();
m_activeVBOs_streamer_copy.push_back(std::pair<float, KRVBOData *>(priority, activeVBO)); m_activeVBOs_streamer_copy.push_back(std::pair<float, KRVBOData*>(priority, activeVBO));
} }
} }
for(std::set<KRVBOData *>::iterator itr=expiredVBOs.begin(); itr != expiredVBOs.end(); itr++) { for (std::set<KRVBOData*>::iterator itr = expiredVBOs.begin(); itr != expiredVBOs.end(); itr++) {
m_vbosActive.erase((*itr)->m_data); m_vbosActive.erase((*itr)->m_data);
} }
if(m_activeVBOs_streamer_copy.size() > 0) { if (m_activeVBOs_streamer_copy.size() > 0) {
m_streamerComplete = false; m_streamerComplete = false;
} }
} }
@@ -274,7 +281,7 @@ void KRMeshManager::endFrame(float deltaTime)
m_currentVBO = nullptr; m_currentVBO = nullptr;
} }
void KRMeshManager::doStreaming(long &memoryRemaining, long &memoryRemainingThisFrame) void KRMeshManager::doStreaming(long& memoryRemaining, long& memoryRemainingThisFrame)
{ {
// TODO - Implement proper double-buffering to reduce copy operations // TODO - Implement proper double-buffering to reduce copy operations
@@ -282,7 +289,7 @@ void KRMeshManager::doStreaming(long &memoryRemaining, long &memoryRemainingThis
m_activeVBOs_streamer = std::move(m_activeVBOs_streamer_copy); m_activeVBOs_streamer = std::move(m_activeVBOs_streamer_copy);
m_streamerFenceMutex.unlock(); m_streamerFenceMutex.unlock();
if(m_activeVBOs_streamer.size() > 0) { if (m_activeVBOs_streamer.size() > 0) {
balanceVBOMemory(memoryRemaining, memoryRemainingThisFrame); balanceVBOMemory(memoryRemaining, memoryRemainingThisFrame);
m_streamerFenceMutex.lock(); m_streamerFenceMutex.lock();
@@ -293,16 +300,16 @@ void KRMeshManager::doStreaming(long &memoryRemaining, long &memoryRemainingThis
} }
} }
void KRMeshManager::balanceVBOMemory(long &memoryRemaining, long &memoryRemainingThisFrame) void KRMeshManager::balanceVBOMemory(long& memoryRemaining, long& memoryRemainingThisFrame)
{ {
std::sort(m_activeVBOs_streamer.begin(), m_activeVBOs_streamer.end(), std::greater<std::pair<float, KRVBOData *>>()); std::sort(m_activeVBOs_streamer.begin(), m_activeVBOs_streamer.end(), std::greater<std::pair<float, KRVBOData*>>());
for(auto vbo_itr = m_activeVBOs_streamer.begin(); vbo_itr != m_activeVBOs_streamer.end(); vbo_itr++) { for (auto vbo_itr = m_activeVBOs_streamer.begin(); vbo_itr != m_activeVBOs_streamer.end(); vbo_itr++) {
KRVBOData *vbo_data = (*vbo_itr).second; KRVBOData* vbo_data = (*vbo_itr).second;
long vbo_size = vbo_data->getSize(); long vbo_size = vbo_data->getSize();
if(!vbo_data->isVBOLoaded()) { if (!vbo_data->isVBOLoaded()) {
if(memoryRemainingThisFrame > vbo_size) { if (memoryRemainingThisFrame > vbo_size) {
vbo_data->load(); vbo_data->load();
memoryRemainingThisFrame -= vbo_size; memoryRemainingThisFrame -= vbo_size;
} }
@@ -319,7 +326,7 @@ long KRMeshManager::getMemUsed()
long KRMeshManager::getMemActive() long KRMeshManager::getMemActive()
{ {
long mem_active = 0; long mem_active = 0;
for(unordered_map<KRDataBlock *, KRVBOData *>::iterator itr = m_vbosActive.begin(); itr != m_vbosActive.end(); itr++) { for (unordered_map<KRDataBlock*, KRVBOData*>::iterator itr = m_vbosActive.begin(); itr != m_vbosActive.end(); itr++) {
mem_active += (*itr).second->getSize(); mem_active += (*itr).second->getSize();
} }
return mem_active; return mem_active;
@@ -327,12 +334,12 @@ long KRMeshManager::getMemActive()
void KRMeshManager::initVolumetricLightingVertexes() void KRMeshManager::initVolumetricLightingVertexes()
{ {
if(m_volumetricLightingVertexData.getSize() == 0) { if (m_volumetricLightingVertexData.getSize() == 0) {
m_volumetricLightingVertexData.expand(sizeof(VolumetricLightingVertexData) * KRENGINE_MAX_VOLUMETRIC_PLANES * 6); m_volumetricLightingVertexData.expand(sizeof(VolumetricLightingVertexData) * KRENGINE_MAX_VOLUMETRIC_PLANES * 6);
m_volumetricLightingVertexData.lock(); m_volumetricLightingVertexData.lock();
VolumetricLightingVertexData * vertex_data = (VolumetricLightingVertexData *)m_volumetricLightingVertexData.getStart(); VolumetricLightingVertexData* vertex_data = (VolumetricLightingVertexData*)m_volumetricLightingVertexData.getStart();
int iVertex=0; int iVertex = 0;
for(int iPlane=0; iPlane < KRENGINE_MAX_VOLUMETRIC_PLANES; iPlane++) { for (int iPlane = 0; iPlane < KRENGINE_MAX_VOLUMETRIC_PLANES; iPlane++) {
vertex_data[iVertex].vertex.x = -1.0f; vertex_data[iVertex].vertex.x = -1.0f;
vertex_data[iVertex].vertex.y = -1.0f; vertex_data[iVertex].vertex.y = -1.0f;
vertex_data[iVertex].vertex.z = (float)iPlane; vertex_data[iVertex].vertex.z = (float)iPlane;
@@ -377,18 +384,18 @@ void KRMeshManager::initVolumetricLightingVertexes()
void KRMeshManager::initRandomParticles() void KRMeshManager::initRandomParticles()
{ {
if(m_randomParticleVertexData.getSize() == 0) { if (m_randomParticleVertexData.getSize() == 0) {
m_randomParticleVertexData.expand(sizeof(RandomParticleVertexData) * KRENGINE_MAX_RANDOM_PARTICLES * 3); m_randomParticleVertexData.expand(sizeof(RandomParticleVertexData) * KRENGINE_MAX_RANDOM_PARTICLES * 3);
m_randomParticleVertexData.lock(); m_randomParticleVertexData.lock();
RandomParticleVertexData *vertex_data = (RandomParticleVertexData *)m_randomParticleVertexData.getStart(); RandomParticleVertexData* vertex_data = (RandomParticleVertexData*)m_randomParticleVertexData.getStart();
// Generate vertices for randomly placed equilateral triangles with a side length of 1 and an origin point centered so that an inscribed circle can be efficiently rendered without wasting fill // Generate vertices for randomly placed equilateral triangles with a side length of 1 and an origin point centered so that an inscribed circle can be efficiently rendered without wasting fill
float equilateral_triangle_height = sqrt(3.0f) * 0.5f; float equilateral_triangle_height = sqrt(3.0f) * 0.5f;
float inscribed_circle_radius = 1.0f / (2.0f * sqrt(3.0f)); float inscribed_circle_radius = 1.0f / (2.0f * sqrt(3.0f));
int iVertex=0; int iVertex = 0;
for(int iParticle=0; iParticle < KRENGINE_MAX_RANDOM_PARTICLES; iParticle++) { for (int iParticle = 0; iParticle < KRENGINE_MAX_RANDOM_PARTICLES; iParticle++) {
vertex_data[iVertex].vertex.x = (float)(rand() % 2000) / 1000.0f - 1000.0f; vertex_data[iVertex].vertex.x = (float)(rand() % 2000) / 1000.0f - 1000.0f;
vertex_data[iVertex].vertex.y = (float)(rand() % 2000) / 1000.0f - 1000.0f; vertex_data[iVertex].vertex.y = (float)(rand() % 2000) / 1000.0f - 1000.0f;
vertex_data[iVertex].vertex.z = (float)(rand() % 2000) / 1000.0f - 1000.0f; vertex_data[iVertex].vertex.z = (float)(rand() % 2000) / 1000.0f - 1000.0f;
@@ -396,16 +403,16 @@ void KRMeshManager::initRandomParticles()
vertex_data[iVertex].uva.y = -inscribed_circle_radius; vertex_data[iVertex].uva.y = -inscribed_circle_radius;
iVertex++; iVertex++;
vertex_data[iVertex].vertex.x = vertex_data[iVertex-1].vertex.x; vertex_data[iVertex].vertex.x = vertex_data[iVertex - 1].vertex.x;
vertex_data[iVertex].vertex.y = vertex_data[iVertex-1].vertex.y; vertex_data[iVertex].vertex.y = vertex_data[iVertex - 1].vertex.y;
vertex_data[iVertex].vertex.z = vertex_data[iVertex-1].vertex.z; vertex_data[iVertex].vertex.z = vertex_data[iVertex - 1].vertex.z;
vertex_data[iVertex].uva.x = 0.5f; vertex_data[iVertex].uva.x = 0.5f;
vertex_data[iVertex].uva.y = -inscribed_circle_radius; vertex_data[iVertex].uva.y = -inscribed_circle_radius;
iVertex++; iVertex++;
vertex_data[iVertex].vertex.x = vertex_data[iVertex-1].vertex.x; vertex_data[iVertex].vertex.x = vertex_data[iVertex - 1].vertex.x;
vertex_data[iVertex].vertex.y = vertex_data[iVertex-1].vertex.y; vertex_data[iVertex].vertex.y = vertex_data[iVertex - 1].vertex.y;
vertex_data[iVertex].vertex.z = vertex_data[iVertex-1].vertex.z; vertex_data[iVertex].vertex.z = vertex_data[iVertex - 1].vertex.z;
vertex_data[iVertex].uva.x = 0.0f; vertex_data[iVertex].uva.x = 0.0f;
vertex_data[iVertex].uva.y = -inscribed_circle_radius + equilateral_triangle_height; vertex_data[iVertex].uva.y = -inscribed_circle_radius + equilateral_triangle_height;
iVertex++; iVertex++;
@@ -432,9 +439,9 @@ size_t KRMeshManager::getActiveVBOCount()
return m_vbosActive.size(); return m_vbosActive.size();
} }
void KRMeshManager::log_draw_call(KRNode::RenderPass pass, const std::string &object_name, const std::string &material_name, int vertex_count) void KRMeshManager::log_draw_call(KRNode::RenderPass pass, const std::string& object_name, const std::string& material_name, int vertex_count)
{ {
if(m_draw_call_logging_enabled) { if (m_draw_call_logging_enabled) {
draw_call_info info; draw_call_info info;
info.pass = pass; info.pass = pass;
strncpy(info.object_name, object_name.c_str(), 256); strncpy(info.object_name, object_name.c_str(), 256);
@@ -468,7 +475,7 @@ KRMeshManager::KRVBOData::KRVBOData()
memset(m_allocations, 0, sizeof(AllocationInfo) * KRENGINE_MAX_GPU_COUNT); memset(m_allocations, 0, sizeof(AllocationInfo) * KRENGINE_MAX_GPU_COUNT);
} }
KRMeshManager::KRVBOData::KRVBOData(KRMeshManager *manager, KRDataBlock *data, KRDataBlock *index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t KRMeshManager::KRVBOData::KRVBOData(KRMeshManager* manager, KRDataBlock* data, KRDataBlock* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t
#if KRENGINE_DEBUG_GPU_LABELS #if KRENGINE_DEBUG_GPU_LABELS
, const char* debug_label , const char* debug_label
#endif #endif
@@ -478,14 +485,14 @@ KRMeshManager::KRVBOData::KRVBOData(KRMeshManager *manager, KRDataBlock *data, K
memset(m_allocations, 0, sizeof(AllocationInfo) * KRENGINE_MAX_GPU_COUNT); memset(m_allocations, 0, sizeof(AllocationInfo) * KRENGINE_MAX_GPU_COUNT);
m_is_vbo_loaded = false; m_is_vbo_loaded = false;
m_is_vbo_ready = false; m_is_vbo_ready = false;
init(manager, data,index_data,vertex_attrib_flags, static_vbo, t init(manager, data, index_data, vertex_attrib_flags, static_vbo, t
#if KRENGINE_DEBUG_GPU_LABELS #if KRENGINE_DEBUG_GPU_LABELS
, debug_label , debug_label
#endif #endif
); );
} }
void KRMeshManager::KRVBOData::init(KRMeshManager *manager, KRDataBlock *data, KRDataBlock *index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t void KRMeshManager::KRVBOData::init(KRMeshManager* manager, KRDataBlock* data, KRDataBlock* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t
#if KRENGINE_DEBUG_GPU_LABELS #if KRENGINE_DEBUG_GPU_LABELS
, const char* debug_label , const char* debug_label
#endif #endif
@@ -502,7 +509,7 @@ void KRMeshManager::KRVBOData::init(KRMeshManager *manager, KRDataBlock *data, K
m_vertex_attrib_flags = vertex_attrib_flags; m_vertex_attrib_flags = vertex_attrib_flags;
m_size = m_data->getSize(); m_size = m_data->getSize();
if(m_index_data != NULL) { if (m_index_data != NULL) {
m_size += m_index_data->getSize(); m_size += m_index_data->getSize();
} }
@@ -527,7 +534,7 @@ void KRMeshManager::KRVBOData::load()
void KRMeshManager::KRVBOData::load(VkCommandBuffer& commandBuffer) void KRMeshManager::KRVBOData::load(VkCommandBuffer& commandBuffer)
{ {
// TODO - We should load on each GPU only if there is a surface using the mesh // TODO - We should load on each GPU only if there is a surface using the mesh
if(isVBOLoaded()) { if (isVBOLoaded()) {
return; return;
} }
@@ -607,7 +614,7 @@ void KRMeshManager::KRVBOData::load(VkCommandBuffer& commandBuffer)
m_manager->m_vboMemUsed += getSize(); m_manager->m_vboMemUsed += getSize();
m_manager->m_memoryTransferredThisFrame += getSize(); m_manager->m_memoryTransferredThisFrame += getSize();
if(m_type != STREAMING) { if (m_type != STREAMING) {
_swapHandles(); _swapHandles();
} }
} }
@@ -630,7 +637,7 @@ void KRMeshManager::KRVBOData::unload()
memset(&allocation, 0, sizeof(AllocationInfo)); memset(&allocation, 0, sizeof(AllocationInfo));
} }
if(isVBOLoaded()) { if (isVBOLoaded()) {
m_manager->m_vboMemUsed -= getSize(); m_manager->m_vboMemUsed -= getSize();
} }
@@ -653,7 +660,7 @@ void KRMeshManager::KRVBOData::bind(VkCommandBuffer& commandBuffer)
void KRMeshManager::KRVBOData::resetPoolExpiry(float lodCoverage) void KRMeshManager::KRVBOData::resetPoolExpiry(float lodCoverage)
{ {
long current_frame = m_manager->getContext().getCurrentFrame(); long current_frame = m_manager->getContext().getCurrentFrame();
if(current_frame != m_last_frame_used) { if (current_frame != m_last_frame_used) {
m_last_frame_used = current_frame; m_last_frame_used = current_frame;
m_last_frame_max_lod_coverage = 0.0f; m_last_frame_max_lod_coverage = 0.0f;
@@ -666,7 +673,7 @@ void KRMeshManager::KRVBOData::resetPoolExpiry(float lodCoverage)
float KRMeshManager::KRVBOData::getStreamPriority() float KRMeshManager::KRVBOData::getStreamPriority()
{ {
long current_frame = m_manager->getContext().getCurrentFrame(); long current_frame = m_manager->getContext().getCurrentFrame();
if(current_frame > m_last_frame_used + 5) { if (current_frame > m_last_frame_used + 5) {
return 1.0f - KRCLAMP((float)(current_frame - m_last_frame_used) / 60.0f, 0.0f, 1.0f); return 1.0f - KRCLAMP((float)(current_frame - m_last_frame_used) / 60.0f, 0.0f, 1.0f);
} else { } else {
return 10000.0f + m_last_frame_max_lod_coverage * 10.0f; return 10000.0f + m_last_frame_max_lod_coverage * 10.0f;
@@ -678,9 +685,9 @@ void KRMeshManager::KRVBOData::_swapHandles()
m_is_vbo_ready = m_is_vbo_loaded; m_is_vbo_ready = m_is_vbo_loaded;
} }
void KRMeshManager::primeVBO(KRVBOData *vbo_data) void KRMeshManager::primeVBO(KRVBOData* vbo_data)
{ {
if(m_vbosActive.find(vbo_data->m_data) == m_vbosActive.end()) { if (m_vbosActive.find(vbo_data->m_data) == m_vbosActive.end()) {
m_vbosActive[vbo_data->m_data] = vbo_data; m_vbosActive[vbo_data->m_data] = vbo_data;
} }
} }

90
kraken/KRMeshManager.h
View File

@@ -41,12 +41,13 @@
class KRContext; class KRContext;
class KRMesh; class KRMesh;
class KRMeshManager : public KRResourceManager { class KRMeshManager : public KRResourceManager
{
public: public:
static const int KRENGINE_MAX_VOLUMETRIC_PLANES=500; static const int KRENGINE_MAX_VOLUMETRIC_PLANES = 500;
static const int KRENGINE_MAX_RANDOM_PARTICLES=150000; static const int KRENGINE_MAX_RANDOM_PARTICLES = 150000;
KRMeshManager(KRContext &context); KRMeshManager(KRContext& context);
void init(); void init();
virtual ~KRMeshManager(); virtual ~KRMeshManager();
@@ -56,19 +57,21 @@ public:
void startFrame(float deltaTime); void startFrame(float deltaTime);
void endFrame(float deltaTime); void endFrame(float deltaTime);
KRMesh *loadModel(const char *szName, KRDataBlock *pData); KRMesh* loadModel(const char* szName, KRDataBlock* pData);
std::vector<KRMesh *> getModel(const char *szName); std::vector<KRMesh*> getModel(const char* szName);
KRMesh* KRMeshManager::getMaxLODModel(const char* szName); KRMesh* KRMeshManager::getMaxLODModel(const char* szName);
void addModel(KRMesh *model); void addModel(KRMesh* model);
std::vector<std::string> getModelNames(); std::vector<std::string> getModelNames();
unordered_multimap<std::string, KRMesh *> &getModels(); unordered_multimap<std::string, KRMesh*>& getModels();
class KRVBOData { class KRVBOData
{
public: public:
typedef enum { typedef enum
{
STREAMING, STREAMING,
// STREAMING data is loaded asynchronously, with transfer queues in the streamer thread. // STREAMING data is loaded asynchronously, with transfer queues in the streamer thread.
@@ -81,12 +84,12 @@ public:
} vbo_type; } vbo_type;
KRVBOData(); KRVBOData();
KRVBOData(KRMeshManager *manager, KRDataBlock *data, KRDataBlock *index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t KRVBOData(KRMeshManager* manager, KRDataBlock* data, KRDataBlock* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t
#if KRENGINE_DEBUG_GPU_LABELS #if KRENGINE_DEBUG_GPU_LABELS
, const char* debug_label , const char* debug_label
#endif #endif
); );
void init(KRMeshManager *manager, KRDataBlock *data, KRDataBlock *index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t void init(KRMeshManager* manager, KRDataBlock* data, KRDataBlock* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t
#if KRENGINE_DEBUG_GPU_LABELS #if KRENGINE_DEBUG_GPU_LABELS
, const char* debug_label , const char* debug_label
#endif #endif
@@ -94,11 +97,17 @@ public:
~KRVBOData(); ~KRVBOData();
KRDataBlock *m_data; KRDataBlock* m_data;
KRDataBlock *m_index_data; KRDataBlock* m_index_data;
bool isVBOLoaded() { return m_is_vbo_loaded; } bool isVBOLoaded()
bool isVBOReady() { return m_is_vbo_ready; } {
return m_is_vbo_loaded;
}
bool isVBOReady()
{
return m_is_vbo_ready;
}
void load(); void load();
void load(VkCommandBuffer& commandBuffer); void load(VkCommandBuffer& commandBuffer);
void unload(); void unload();
@@ -108,12 +117,21 @@ public:
KRVBOData(const KRVBOData& o) = delete; KRVBOData(const KRVBOData& o) = delete;
KRVBOData& operator=(const KRVBOData& o) = delete; KRVBOData& operator=(const KRVBOData& o) = delete;
long getSize() { return (long)m_size; } long getSize()
{
return (long)m_size;
}
void resetPoolExpiry(float lodCoverage); void resetPoolExpiry(float lodCoverage);
long getLastFrameUsed() { return m_last_frame_used; } long getLastFrameUsed()
{
return m_last_frame_used;
}
vbo_type getType() { return m_type; } vbo_type getType()
{
return m_type;
}
float getStreamPriority(); float getStreamPriority();
@@ -124,7 +142,7 @@ public:
uint32_t getVertexAttributes(); uint32_t getVertexAttributes();
private: private:
KRMeshManager *m_manager; KRMeshManager* m_manager;
int m_vertex_attrib_flags; int m_vertex_attrib_flags;
long m_size; long m_size;
@@ -135,7 +153,8 @@ public:
bool m_is_vbo_loaded; bool m_is_vbo_loaded;
bool m_is_vbo_ready; bool m_is_vbo_ready;
typedef struct { typedef struct
{
KrDeviceHandle device; KrDeviceHandle device;
VkBuffer vertex_buffer; VkBuffer vertex_buffer;
VmaAllocation vertex_allocation; VmaAllocation vertex_allocation;
@@ -150,16 +169,18 @@ public:
#endif #endif
}; };
void bindVBO(VkCommandBuffer& commandBuffer, KRVBOData *vbo_data, float lodCoverage); void bindVBO(VkCommandBuffer& commandBuffer, KRVBOData* vbo_data, float lodCoverage);
long getMemUsed(); long getMemUsed();
long getMemActive(); long getMemActive();
typedef struct { typedef struct
{
Vector3 vertex; Vector3 vertex;
Vector2 uva; Vector2 uva;
} RandomParticleVertexData; } RandomParticleVertexData;
typedef struct { typedef struct
{
Vector3 vertex; Vector3 vertex;
} VolumetricLightingVertexData; } VolumetricLightingVertexData;
@@ -167,14 +188,15 @@ public:
size_t getActiveVBOCount(); size_t getActiveVBOCount();
struct draw_call_info { struct draw_call_info
{
KRNode::RenderPass pass; KRNode::RenderPass pass;
char object_name[256]; char object_name[256];
char material_name[256]; char material_name[256];
int vertex_count; int vertex_count;
}; };
void log_draw_call(KRNode::RenderPass pass, const std::string &object_name, const std::string &material_name, int vertex_count); void log_draw_call(KRNode::RenderPass pass, const std::string& object_name, const std::string& material_name, int vertex_count);
std::vector<draw_call_info> getDrawCalls(); std::vector<draw_call_info> getDrawCalls();
@@ -185,7 +207,7 @@ public:
KRVBOData KRENGINE_VBO_DATA_VOLUMETRIC_LIGHTING; KRVBOData KRENGINE_VBO_DATA_VOLUMETRIC_LIGHTING;
void doStreaming(long &memoryRemaining, long &memoryRemainingThisFrame); void doStreaming(long& memoryRemaining, long& memoryRemainingThisFrame);
private: private:
KRDataBlock KRENGINE_VBO_3D_CUBE_VERTICES; KRDataBlock KRENGINE_VBO_3D_CUBE_VERTICES;
@@ -193,14 +215,14 @@ private:
KRDataBlock KRENGINE_VBO_2D_SQUARE_VERTICES; KRDataBlock KRENGINE_VBO_2D_SQUARE_VERTICES;
__int32_t KRENGINE_VBO_2D_SQUARE_ATTRIBS; __int32_t KRENGINE_VBO_2D_SQUARE_ATTRIBS;
unordered_multimap<std::string, KRMesh *> m_models; // Multiple models with the same name/key may be inserted, representing multiple LOD levels of the model unordered_multimap<std::string, KRMesh*> m_models; // Multiple models with the same name/key may be inserted, representing multiple LOD levels of the model
long m_vboMemUsed; long m_vboMemUsed;
KRVBOData *m_currentVBO; KRVBOData* m_currentVBO;
unordered_map<KRDataBlock *, KRVBOData *> m_vbosActive; unordered_map<KRDataBlock*, KRVBOData*> m_vbosActive;
std::vector<std::pair<float, KRVBOData *> > m_activeVBOs_streamer; std::vector<std::pair<float, KRVBOData*> > m_activeVBOs_streamer;
std::vector<std::pair<float, KRVBOData *> > m_activeVBOs_streamer_copy; std::vector<std::pair<float, KRVBOData*> > m_activeVBOs_streamer_copy;
KRDataBlock m_randomParticleVertexData; KRDataBlock m_randomParticleVertexData;
KRDataBlock m_volumetricLightingVertexData; KRDataBlock m_volumetricLightingVertexData;
@@ -214,9 +236,9 @@ private:
std::mutex m_streamerFenceMutex; std::mutex m_streamerFenceMutex;
bool m_streamerComplete; bool m_streamerComplete;
void balanceVBOMemory(long &memoryRemaining, long &memoryRemainingThisFrame); void balanceVBOMemory(long& memoryRemaining, long& memoryRemainingThisFrame);
void primeVBO(KRVBOData *vbo_data); void primeVBO(KRVBOData* vbo_data);
void initRandomParticles(); void initRandomParticles();
void initVolumetricLightingVertexes(); void initVolumetricLightingVertexes();

2
kraken/KRMeshQuad.cpp
View File

@@ -32,7 +32,7 @@
#include "KRMeshQuad.h" #include "KRMeshQuad.h"
KRMeshQuad::KRMeshQuad(KRContext &context) : KRMesh(context, "__quad") KRMeshQuad::KRMeshQuad(KRContext& context) : KRMesh(context, "__quad")
{ {
m_constant = true; m_constant = true;

5
kraken/KRMeshQuad.h
View File

@@ -33,9 +33,10 @@
#include "KRMesh.h" #include "KRMesh.h"
class KRMeshQuad : public KRMesh { class KRMeshQuad : public KRMesh
{
public: public:
KRMeshQuad(KRContext &context); KRMeshQuad(KRContext& context);
virtual ~KRMeshQuad(); virtual ~KRMeshQuad();
private: private:
}; };

16
kraken/KRMeshSphere.cpp
View File

@@ -32,7 +32,7 @@
#include "KRMeshSphere.h" #include "KRMeshSphere.h"
KRMeshSphere::KRMeshSphere(KRContext &context) : KRMesh(context, "__sphere") KRMeshSphere::KRMeshSphere(KRContext& context) : KRMesh(context, "__sphere")
{ {
m_constant = true; m_constant = true;
@@ -46,7 +46,7 @@ KRMeshSphere::KRMeshSphere(KRContext &context) : KRMesh(context, "__sphere")
std::vector<Triangle3> f = std::vector<Triangle3>(facet_count); std::vector<Triangle3> f = std::vector<Triangle3>(facet_count);
int i,it; int i, it;
float a; float a;
Vector3 p[6] = { Vector3 p[6] = {
Vector3::Create(0,0,1), Vector3::Create(0,0,1),
@@ -57,12 +57,12 @@ KRMeshSphere::KRMeshSphere(KRContext &context) : KRMesh(context, "__sphere")
Vector3::Create(-1,1,0) Vector3::Create(-1,1,0)
}; };
Vector3 pa,pb,pc; Vector3 pa, pb, pc;
int nt = 0,ntold; int nt = 0, ntold;
/* Create the level 0 object */ /* Create the level 0 object */
a = 1.0f / sqrtf(2.0f); a = 1.0f / sqrtf(2.0f);
for (i=0;i<6;i++) { for (i = 0; i < 6; i++) {
p[i].x *= a; p[i].x *= a;
p[i].y *= a; p[i].y *= a;
} }
@@ -77,9 +77,9 @@ KRMeshSphere::KRMeshSphere(KRContext &context) : KRMesh(context, "__sphere")
nt = 8; nt = 8;
/* Bisect each edge and move to the surface of a unit sphere */ /* Bisect each edge and move to the surface of a unit sphere */
for (it=0;it<iterations;it++) { for (it = 0; it < iterations; it++) {
ntold = nt; ntold = nt;
for (i=0;i<ntold;i++) { for (i = 0; i < ntold; i++) {
pa.x = (f[i][0].x + f[i][1].x) / 2; pa.x = (f[i][0].x + f[i][1].x) / 2;
pa.y = (f[i][0].y + f[i][1].y) / 2; pa.y = (f[i][0].y + f[i][1].y) / 2;
pa.z = (f[i][0].z + f[i][1].z) / 2; pa.z = (f[i][0].z + f[i][1].z) / 2;
@@ -101,7 +101,7 @@ KRMeshSphere::KRMeshSphere(KRContext &context) : KRMesh(context, "__sphere")
} }
} }
for(int facet_index=0; facet_index < facet_count; facet_index++) { for (int facet_index = 0; facet_index < facet_count; facet_index++) {
mi.vertices.push_back(f[facet_index][0]); mi.vertices.push_back(f[facet_index][0]);
mi.vertices.push_back(f[facet_index][1]); mi.vertices.push_back(f[facet_index][1]);
mi.vertices.push_back(f[facet_index][2]); mi.vertices.push_back(f[facet_index][2]);

5
kraken/KRMeshSphere.h
View File

@@ -33,9 +33,10 @@
#include "KRMesh.h" #include "KRMesh.h"
class KRMeshSphere : public KRMesh { class KRMeshSphere : public KRMesh
{
public: public:
KRMeshSphere(KRContext &context); KRMeshSphere(KRContext& context);
virtual ~KRMeshSphere(); virtual ~KRMeshSphere();
private: private:
}; };

94
kraken/KRModel.cpp
View File

@@ -49,7 +49,8 @@ void KRModel::InitNodeInfo(KrNodeInfo* nodeInfo)
nodeInfo->model.rim_power = 0.0f; nodeInfo->model.rim_power = 0.0f;
} }
KRModel::KRModel(KRScene &scene, std::string instance_name, std::string model_name, std::string light_map, float lod_min_coverage, bool receives_shadow, bool faces_camera, Vector3 rim_color, float rim_power) : KRNode(scene, instance_name) { KRModel::KRModel(KRScene& scene, std::string instance_name, std::string model_name, std::string light_map, float lod_min_coverage, bool receives_shadow, bool faces_camera, Vector3 rim_color, float rim_power) : KRNode(scene, instance_name)
{
m_lightMap = light_map; m_lightMap = light_map;
m_pLightMap = NULL; m_pLightMap = NULL;
m_model_name = model_name; m_model_name = model_name;
@@ -77,17 +78,19 @@ KRModel::KRModel(KRScene &scene, std::string instance_name, std::string model_na
m_boundsCachedMat.c[15] = -1.0f; m_boundsCachedMat.c[15] = -1.0f;
} }
KRModel::~KRModel() { KRModel::~KRModel()
{
} }
std::string KRModel::getElementName() { std::string KRModel::getElementName()
{
return "model"; return "model";
} }
tinyxml2::XMLElement *KRModel::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRModel::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
e->SetAttribute("mesh", m_model_name.c_str()); e->SetAttribute("mesh", m_model_name.c_str());
e->SetAttribute("light_map", m_lightMap.c_str()); e->SetAttribute("light_map", m_lightMap.c_str());
e->SetAttribute("lod_min_coverage", m_min_lod_coverage); e->SetAttribute("lod_min_coverage", m_min_lod_coverage);
@@ -98,7 +101,7 @@ tinyxml2::XMLElement *KRModel::saveXML( tinyxml2::XMLNode *parent)
return e; return e;
} }
void KRModel::setRimColor(const Vector3 &rim_color) void KRModel::setRimColor(const Vector3& rim_color)
{ {
m_rim_color = rim_color; m_rim_color = rim_color;
} }
@@ -118,7 +121,7 @@ float KRModel::getRimPower()
return m_rim_power; return m_rim_power;
} }
void KRModel::setLightMap(const std::string &name) void KRModel::setLightMap(const std::string& name)
{ {
m_lightMap = name; m_lightMap = name;
m_pLightMap = NULL; m_pLightMap = NULL;
@@ -129,19 +132,20 @@ std::string KRModel::getLightMap()
return m_lightMap; return m_lightMap;
} }
void KRModel::loadModel() { void KRModel::loadModel()
if(m_models.size() == 0) { {
std::vector<KRMesh *> models = m_pContext->getMeshManager()->getModel(m_model_name.c_str()); // The model manager returns the LOD levels in sorted order, with the highest detail first if (m_models.size() == 0) {
unordered_map<KRMesh *, std::vector<KRBone *> > bones; std::vector<KRMesh*> models = m_pContext->getMeshManager()->getModel(m_model_name.c_str()); // The model manager returns the LOD levels in sorted order, with the highest detail first
if(models.size() > 0) { unordered_map<KRMesh*, std::vector<KRBone*> > bones;
if (models.size() > 0) {
bool all_bones_found = true; bool all_bones_found = true;
for(std::vector<KRMesh *>::iterator model_itr = models.begin(); model_itr != models.end(); model_itr++) { for (std::vector<KRMesh*>::iterator model_itr = models.begin(); model_itr != models.end(); model_itr++) {
KRMesh *model = *model_itr; KRMesh* model = *model_itr;
std::vector<KRBone *> model_bones; std::vector<KRBone*> model_bones;
int bone_count = model->getBoneCount(); int bone_count = model->getBoneCount();
for(int bone_index=0; bone_index < bone_count; bone_index++) { for (int bone_index = 0; bone_index < bone_count; bone_index++) {
KRBone *matching_bone = dynamic_cast<KRBone *>(getScene().getRootNode()->find<KRNode>(model->getBoneName(bone_index))); KRBone* matching_bone = dynamic_cast<KRBone*>(getScene().getRootNode()->find<KRNode>(model->getBoneName(bone_index)));
if(matching_bone) { if (matching_bone) {
model_bones.push_back(matching_bone); model_bones.push_back(matching_bone);
} else { } else {
all_bones_found = false; // Reject when there are any missing bones or multiple matches all_bones_found = false; // Reject when there are any missing bones or multiple matches
@@ -149,7 +153,7 @@ void KRModel::loadModel() {
} }
bones[model] = model_bones; bones[model] = model_bones;
} }
if(all_bones_found) { if (all_bones_found) {
m_models = models; m_models = models;
m_bones = bones; m_bones = bones;
getScene().notify_sceneGraphModify(this); getScene().notify_sceneGraphModify(this);
@@ -160,17 +164,18 @@ void KRModel::loadModel() {
} }
} }
void KRModel::render(KRNode::RenderInfo& ri) { void KRModel::render(KRNode::RenderInfo& ri)
{
if(m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass == KRNode::RENDER_PASS_PRESTREAM) { if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass == KRNode::RENDER_PASS_PRESTREAM) {
preStream(ri.viewport); preStream(ri.viewport);
} }
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRNode::render(ri); KRNode::render(ri);
if(ri.renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS if (ri.renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS
&& ri.renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES && ri.renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES
&& ri.renderPass != KRNode::RENDER_PASS_PARTICLE_OCCLUSION && ri.renderPass != KRNode::RENDER_PASS_PARTICLE_OCCLUSION
&& ri.renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && ri.renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE
@@ -178,7 +183,7 @@ void KRModel::render(KRNode::RenderInfo& ri) {
&& ri.renderPass != KRNode::RENDER_PASS_PRESTREAM) { && ri.renderPass != KRNode::RENDER_PASS_PRESTREAM) {
loadModel(); loadModel();
if(m_models.size() > 0) { if (m_models.size() > 0) {
// Don't render meshes on second pass of the deferred lighting renderer, as only lights will be applied // Don't render meshes on second pass of the deferred lighting renderer, as only lights will be applied
/* /*
@@ -192,31 +197,31 @@ void KRModel::render(KRNode::RenderInfo& ri) {
float lod_coverage = ri.viewport.coverage(getBounds()); // This also checks the view frustrum culling float lod_coverage = ri.viewport.coverage(getBounds()); // This also checks the view frustrum culling
if(lod_coverage > m_min_lod_coverage) { if (lod_coverage > m_min_lod_coverage) {
// ---===--- Select the best LOD model based on screen coverage ---===--- // ---===--- Select the best LOD model based on screen coverage ---===---
std::vector<KRMesh *>::iterator itr=m_models.begin(); std::vector<KRMesh*>::iterator itr = m_models.begin();
KRMesh *pModel = *itr++; KRMesh* pModel = *itr++;
while(itr != m_models.end()) { while (itr != m_models.end()) {
KRMesh *pLODModel = *itr++; KRMesh* pLODModel = *itr++;
if((float)pLODModel->getLODCoverage() / 100.0f > lod_coverage && pLODModel->getLODCoverage() < pModel->getLODCoverage()) { if ((float)pLODModel->getLODCoverage() / 100.0f > lod_coverage && pLODModel->getLODCoverage() < pModel->getLODCoverage()) {
pModel = pLODModel; pModel = pLODModel;
} else { } else {
break; break;
} }
} }
if(m_pLightMap == NULL && m_lightMap.size()) { if (m_pLightMap == NULL && m_lightMap.size()) {
m_pLightMap = getContext().getTextureManager()->getTexture(m_lightMap); m_pLightMap = getContext().getTextureManager()->getTexture(m_lightMap);
} }
if(m_pLightMap && ri.camera->settings.bEnableLightMap && ri.renderPass != RENDER_PASS_SHADOWMAP && ri.renderPass != RENDER_PASS_GENERATE_SHADOWMAPS) { if (m_pLightMap && ri.camera->settings.bEnableLightMap && ri.renderPass != RENDER_PASS_SHADOWMAP && ri.renderPass != RENDER_PASS_GENERATE_SHADOWMAPS) {
m_pContext->getTextureManager()->selectTexture(5, m_pLightMap, lod_coverage, KRTexture::TEXTURE_USAGE_LIGHT_MAP); m_pContext->getTextureManager()->selectTexture(5, m_pLightMap, lod_coverage, KRTexture::TEXTURE_USAGE_LIGHT_MAP);
} }
Matrix4 matModel = getModelMatrix(); Matrix4 matModel = getModelMatrix();
if(m_faces_camera) { if (m_faces_camera) {
Vector3 model_center = Matrix4::Dot(matModel, Vector3::Zero()); Vector3 model_center = Matrix4::Dot(matModel, Vector3::Zero());
Vector3 camera_pos = ri.viewport.getCameraPosition(); Vector3 camera_pos = ri.viewport.getCameraPosition();
matModel = Quaternion::Create(Vector3::Forward(), Vector3::Normalize(camera_pos - model_center)).rotationMatrix() * matModel; matModel = Quaternion::Create(Vector3::Forward(), Vector3::Normalize(camera_pos - model_center)).rotationMatrix() * matModel;
@@ -228,48 +233,49 @@ void KRModel::render(KRNode::RenderInfo& ri) {
} }
} }
void KRModel::preStream(const KRViewport &viewport) void KRModel::preStream(const KRViewport& viewport)
{ {
loadModel(); loadModel();
float lod_coverage = viewport.coverage(getBounds()); float lod_coverage = viewport.coverage(getBounds());
for(auto itr = m_models.begin(); itr != m_models.end(); itr++) { for (auto itr = m_models.begin(); itr != m_models.end(); itr++) {
(*itr)->preStream(lod_coverage); (*itr)->preStream(lod_coverage);
} }
if(m_pLightMap == NULL && m_lightMap.size()) { if (m_pLightMap == NULL && m_lightMap.size()) {
m_pLightMap = getContext().getTextureManager()->getTexture(m_lightMap); m_pLightMap = getContext().getTextureManager()->getTexture(m_lightMap);
} }
if(m_pLightMap) { if (m_pLightMap) {
m_pLightMap->resetPoolExpiry(lod_coverage, KRTexture::TEXTURE_USAGE_LIGHT_MAP); m_pLightMap->resetPoolExpiry(lod_coverage, KRTexture::TEXTURE_USAGE_LIGHT_MAP);
} }
} }
kraken_stream_level KRModel::getStreamLevel(const KRViewport &viewport) kraken_stream_level KRModel::getStreamLevel(const KRViewport& viewport)
{ {
kraken_stream_level stream_level = KRNode::getStreamLevel(viewport); kraken_stream_level stream_level = KRNode::getStreamLevel(viewport);
loadModel(); loadModel();
for(auto itr = m_models.begin(); itr != m_models.end(); itr++) { for (auto itr = m_models.begin(); itr != m_models.end(); itr++) {
stream_level = KRMIN(stream_level, (*itr)->getStreamLevel()); stream_level = KRMIN(stream_level, (*itr)->getStreamLevel());
} }
return stream_level; return stream_level;
} }
AABB KRModel::getBounds() { AABB KRModel::getBounds()
{
loadModel(); loadModel();
if(m_models.size() > 0) { if (m_models.size() > 0) {
if(m_faces_camera) { if (m_faces_camera) {
AABB normal_bounds = AABB::Create(m_models[0]->getMinPoint(), m_models[0]->getMaxPoint(), getModelMatrix()); AABB normal_bounds = AABB::Create(m_models[0]->getMinPoint(), m_models[0]->getMaxPoint(), getModelMatrix());
float max_dimension = normal_bounds.longest_radius(); float max_dimension = normal_bounds.longest_radius();
return AABB::Create(normal_bounds.center()-Vector3::Create(max_dimension), normal_bounds.center() + Vector3::Create(max_dimension)); return AABB::Create(normal_bounds.center() - Vector3::Create(max_dimension), normal_bounds.center() + Vector3::Create(max_dimension));
} else { } else {
if(!(m_boundsCachedMat == getModelMatrix())) { if (!(m_boundsCachedMat == getModelMatrix())) {
m_boundsCachedMat = getModelMatrix(); m_boundsCachedMat = getModelMatrix();
m_boundsCached = AABB::Create(m_models[0]->getMinPoint(), m_models[0]->getMaxPoint(), getModelMatrix()); m_boundsCached = AABB::Create(m_models[0]->getMinPoint(), m_models[0]->getMaxPoint(), getModelMatrix());
} }

21
kraken/KRModel.h
View File

@@ -43,37 +43,38 @@
#include "KRTexture.h" #include "KRTexture.h"
#include "KRBone.h" #include "KRBone.h"
class KRModel : public KRNode { class KRModel : public KRNode
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRModel(KRScene &scene, std::string instance_name, std::string model_name, std::string light_map, float lod_min_coverage, bool receives_shadow, bool faces_camera, Vector3 rim_color = Vector3::Zero(), float rim_power = 0.0f); KRModel(KRScene& scene, std::string instance_name, std::string model_name, std::string light_map, float lod_min_coverage, bool receives_shadow, bool faces_camera, Vector3 rim_color = Vector3::Zero(), float rim_power = 0.0f);
virtual ~KRModel(); virtual ~KRModel();
virtual std::string getElementName(); virtual std::string getElementName();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual void render(KRNode::RenderInfo& ri); virtual void render(KRNode::RenderInfo& ri);
virtual AABB getBounds(); virtual AABB getBounds();
void setRimColor(const Vector3 &rim_color); void setRimColor(const Vector3& rim_color);
void setRimPower(float rim_power); void setRimPower(float rim_power);
Vector3 getRimColor(); Vector3 getRimColor();
float getRimPower(); float getRimPower();
void setLightMap(const std::string &name); void setLightMap(const std::string& name);
std::string getLightMap(); std::string getLightMap();
virtual kraken_stream_level getStreamLevel(const KRViewport &viewport); virtual kraken_stream_level getStreamLevel(const KRViewport& viewport);
private: private:
void preStream(const KRViewport &viewport); void preStream(const KRViewport& viewport);
std::vector<KRMesh *> m_models; std::vector<KRMesh*> m_models;
unordered_map<KRMesh *, std::vector<KRBone *> > m_bones; // Outer std::map connects model to set of bones unordered_map<KRMesh*, std::vector<KRBone*> > m_bones; // Outer std::map connects model to set of bones
KRTexture *m_pLightMap; KRTexture* m_pLightMap;
std::string m_lightMap; std::string m_lightMap;
std::string m_model_name; std::string m_model_name;

349
kraken/KRNode.cpp
View File

@@ -63,7 +63,7 @@ void KRNode::InitNodeInfo(KrNodeInfo* nodeInfo)
nodeInfo->scale_pivot = Vector3::Zero(); nodeInfo->scale_pivot = Vector3::Zero();
} }
KRNode::KRNode(KRScene &scene, std::string name) : KRContextObject(scene.getContext()) KRNode::KRNode(KRScene& scene, std::string name) : KRContextObject(scene.getContext())
{ {
m_name = name; m_name = name;
m_localScale = Vector3::One(); m_localScale = Vector3::One();
@@ -104,24 +104,25 @@ KRNode::KRNode(KRScene &scene, std::string name) : KRContextObject(scene.getCont
m_boundsValid = false; m_boundsValid = false;
m_lastRenderFrame = -1000; m_lastRenderFrame = -1000;
for(int i=0; i < KRENGINE_NODE_ATTRIBUTE_COUNT; i++) { for (int i = 0; i < KRENGINE_NODE_ATTRIBUTE_COUNT; i++) {
m_animation_mask[i] = false; m_animation_mask[i] = false;
} }
} }
KRNode::~KRNode() { KRNode::~KRNode()
{
while(m_childNodes.size() > 0) { while (m_childNodes.size() > 0) {
delete *m_childNodes.begin(); delete* m_childNodes.begin();
} }
for(std::set<KRBehavior *>::iterator itr = m_behaviors.begin(); itr != m_behaviors.end(); itr++) { for (std::set<KRBehavior*>::iterator itr = m_behaviors.begin(); itr != m_behaviors.end(); itr++) {
delete *itr; delete* itr;
} }
m_behaviors.clear(); m_behaviors.clear();
if(m_parentNode) { if (m_parentNode) {
m_parentNode->childDeleted(this); m_parentNode->childDeleted(this);
} }
@@ -131,7 +132,7 @@ KRNode::~KRNode() {
void KRNode::setScaleCompensation(bool scale_compensation) void KRNode::setScaleCompensation(bool scale_compensation)
{ {
if(m_scale_compensation != scale_compensation) { if (m_scale_compensation != scale_compensation) {
m_scale_compensation = scale_compensation; m_scale_compensation = scale_compensation;
invalidateModelMatrix(); invalidateModelMatrix();
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
@@ -142,24 +143,26 @@ bool KRNode::getScaleCompensation()
return m_scale_compensation; return m_scale_compensation;
} }
void KRNode::childDeleted(KRNode *child_node) void KRNode::childDeleted(KRNode* child_node)
{ {
m_childNodes.erase(child_node); m_childNodes.erase(child_node);
invalidateBounds(); invalidateBounds();
getScene().notify_sceneGraphModify(this); getScene().notify_sceneGraphModify(this);
} }
void KRNode::addChild(KRNode *child) { void KRNode::addChild(KRNode* child)
{
assert(child->m_parentNode == NULL); assert(child->m_parentNode == NULL);
child->m_parentNode = this; child->m_parentNode = this;
m_childNodes.insert(child); m_childNodes.insert(child);
child->setLODVisibility(m_lod_visible); // Child node inherits LOD visibility status from parent child->setLODVisibility(m_lod_visible); // Child node inherits LOD visibility status from parent
} }
tinyxml2::XMLElement *KRNode::saveXML(tinyxml2::XMLNode *parent) { tinyxml2::XMLElement* KRNode::saveXML(tinyxml2::XMLNode* parent)
tinyxml2::XMLDocument *doc = parent->GetDocument(); {
tinyxml2::XMLElement *e = doc->NewElement(getElementName().c_str()); tinyxml2::XMLDocument* doc = parent->GetDocument();
tinyxml2::XMLNode *n = parent->InsertEndChild(e); tinyxml2::XMLElement* e = doc->NewElement(getElementName().c_str());
tinyxml2::XMLNode* n = parent->InsertEndChild(e);
e->SetAttribute("name", m_name.c_str()); e->SetAttribute("name", m_name.c_str());
kraken::setXMLAttribute("translate", e, m_localTranslation, Vector3::Zero()); kraken::setXMLAttribute("translate", e, m_localTranslation, Vector3::Zero());
kraken::setXMLAttribute("scale", e, m_localScale, Vector3::One()); kraken::setXMLAttribute("scale", e, m_localScale, Vector3::One());
@@ -171,14 +174,15 @@ tinyxml2::XMLElement *KRNode::saveXML(tinyxml2::XMLNode *parent) {
kraken::setXMLAttribute("pre_rotate", e, (m_preRotation * (180.0f / (float)M_PI)), Vector3::Zero()); kraken::setXMLAttribute("pre_rotate", e, (m_preRotation * (180.0f / (float)M_PI)), Vector3::Zero());
kraken::setXMLAttribute("post_rotate", e, (m_postRotation * (180.0f / (float)M_PI)), Vector3::Zero()); kraken::setXMLAttribute("post_rotate", e, (m_postRotation * (180.0f / (float)M_PI)), Vector3::Zero());
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
KRNode *child = (*itr); KRNode* child = (*itr);
child->saveXML(n); child->saveXML(n);
} }
return e; return e;
} }
void KRNode::loadXML(tinyxml2::XMLElement *e) { void KRNode::loadXML(tinyxml2::XMLElement* e)
{
m_name = e->Attribute("name"); m_name = e->Attribute("name");
m_localTranslation = kraken::getXMLAttribute("translate", e, Vector3::Zero()); m_localTranslation = kraken::getXMLAttribute("translate", e, Vector3::Zero());
m_localScale = kraken::getXMLAttribute("scale", e, Vector3::One()); m_localScale = kraken::getXMLAttribute("scale", e, Vector3::One());
@@ -211,36 +215,37 @@ void KRNode::loadXML(tinyxml2::XMLElement *e) {
m_modelMatrixValid = false; m_modelMatrixValid = false;
m_inverseModelMatrixValid = false; m_inverseModelMatrixValid = false;
for(tinyxml2::XMLElement *child_element=e->FirstChildElement(); child_element != NULL; child_element = child_element->NextSiblingElement()) { for (tinyxml2::XMLElement* child_element = e->FirstChildElement(); child_element != NULL; child_element = child_element->NextSiblingElement()) {
const char *szElementName = child_element->Name(); const char* szElementName = child_element->Name();
if(strcmp(szElementName, "behavior") == 0) { if (strcmp(szElementName, "behavior") == 0) {
KRBehavior *behavior = KRBehavior::LoadXML(this, child_element); KRBehavior* behavior = KRBehavior::LoadXML(this, child_element);
if(behavior) { if (behavior) {
addBehavior(behavior); addBehavior(behavior);
behavior->init(); behavior->init();
} }
} else { } else {
KRNode *child_node = KRNode::LoadXML(getScene(), child_element); KRNode* child_node = KRNode::LoadXML(getScene(), child_element);
if(child_node) { if (child_node) {
addChild(child_node); addChild(child_node);
} }
} }
} }
} }
void KRNode::setLocalTranslation(const Vector3 &v, bool set_original) { void KRNode::setLocalTranslation(const Vector3& v, bool set_original)
{
m_localTranslation = v; m_localTranslation = v;
if(set_original) { if (set_original) {
m_initialLocalTranslation = v; m_initialLocalTranslation = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
invalidateModelMatrix(); invalidateModelMatrix();
} }
void KRNode::setWorldTranslation(const Vector3 &v) void KRNode::setWorldTranslation(const Vector3& v)
{ {
if(m_parentNode) { if (m_parentNode) {
setLocalTranslation(Matrix4::Dot(m_parentNode->getInverseModelMatrix(), v)); setLocalTranslation(Matrix4::Dot(m_parentNode->getInverseModelMatrix(), v));
} else { } else {
setLocalTranslation(v); setLocalTranslation(v);
@@ -248,9 +253,9 @@ void KRNode::setWorldTranslation(const Vector3 &v)
} }
void KRNode::setWorldRotation(const Vector3 &v) void KRNode::setWorldRotation(const Vector3& v)
{ {
if(m_parentNode) { if (m_parentNode) {
setLocalRotation((Quaternion::Create(v) * -m_parentNode->getWorldRotation()).eulerXYZ()); setLocalRotation((Quaternion::Create(v) * -m_parentNode->getWorldRotation()).eulerXYZ());
setPreRotation(Vector3::Zero()); setPreRotation(Vector3::Zero());
setPostRotation(Vector3::Zero()); setPostRotation(Vector3::Zero());
@@ -262,27 +267,29 @@ void KRNode::setWorldRotation(const Vector3 &v)
} }
void KRNode::setWorldScale(const Vector3 &v) void KRNode::setWorldScale(const Vector3& v)
{ {
if(m_parentNode) { if (m_parentNode) {
setLocalScale(Matrix4::DotNoTranslate(m_parentNode->getInverseModelMatrix(), v)); setLocalScale(Matrix4::DotNoTranslate(m_parentNode->getInverseModelMatrix(), v));
} else { } else {
setLocalScale(v); setLocalScale(v);
} }
} }
void KRNode::setLocalScale(const Vector3 &v, bool set_original) { void KRNode::setLocalScale(const Vector3& v, bool set_original)
{
m_localScale = v; m_localScale = v;
if(set_original) { if (set_original) {
m_initialLocalScale = v; m_initialLocalScale = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
invalidateModelMatrix(); invalidateModelMatrix();
} }
void KRNode::setLocalRotation(const Vector3 &v, bool set_original) { void KRNode::setLocalRotation(const Vector3& v, bool set_original)
{
m_localRotation = v; m_localRotation = v;
if(set_original) { if (set_original) {
m_initialLocalRotation = v; m_initialLocalRotation = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
@@ -290,201 +297,211 @@ void KRNode::setLocalRotation(const Vector3 &v, bool set_original) {
} }
void KRNode::setRotationOffset(const Vector3 &v, bool set_original) void KRNode::setRotationOffset(const Vector3& v, bool set_original)
{ {
m_rotationOffset = v; m_rotationOffset = v;
if(set_original) { if (set_original) {
m_initialRotationOffset = v; m_initialRotationOffset = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
invalidateModelMatrix(); invalidateModelMatrix();
} }
void KRNode::setScalingOffset(const Vector3 &v, bool set_original) void KRNode::setScalingOffset(const Vector3& v, bool set_original)
{ {
m_scalingOffset = v; m_scalingOffset = v;
if(set_original) { if (set_original) {
m_initialScalingOffset = v; m_initialScalingOffset = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
invalidateModelMatrix(); invalidateModelMatrix();
} }
void KRNode::setRotationPivot(const Vector3 &v, bool set_original) void KRNode::setRotationPivot(const Vector3& v, bool set_original)
{ {
m_rotationPivot = v; m_rotationPivot = v;
if(set_original) { if (set_original) {
m_initialRotationPivot = v; m_initialRotationPivot = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
invalidateModelMatrix(); invalidateModelMatrix();
} }
void KRNode::setScalingPivot(const Vector3 &v, bool set_original) void KRNode::setScalingPivot(const Vector3& v, bool set_original)
{ {
m_scalingPivot = v; m_scalingPivot = v;
if(set_original) { if (set_original) {
m_initialScalingPivot = v; m_initialScalingPivot = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
invalidateModelMatrix(); invalidateModelMatrix();
} }
void KRNode::setPreRotation(const Vector3 &v, bool set_original) void KRNode::setPreRotation(const Vector3& v, bool set_original)
{ {
m_preRotation = v; m_preRotation = v;
if(set_original) { if (set_original) {
m_initialPreRotation = v; m_initialPreRotation = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
invalidateModelMatrix(); invalidateModelMatrix();
} }
void KRNode::setPostRotation(const Vector3 &v, bool set_original) void KRNode::setPostRotation(const Vector3& v, bool set_original)
{ {
m_postRotation = v; m_postRotation = v;
if(set_original) { if (set_original) {
m_initialPostRotation = v; m_initialPostRotation = v;
invalidateBindPoseMatrix(); invalidateBindPoseMatrix();
} }
invalidateModelMatrix(); invalidateModelMatrix();
} }
const Vector3 &KRNode::getRotationOffset() const Vector3& KRNode::getRotationOffset()
{ {
return m_rotationOffset; return m_rotationOffset;
} }
const Vector3 &KRNode::getScalingOffset() const Vector3& KRNode::getScalingOffset()
{ {
return m_scalingOffset; return m_scalingOffset;
} }
const Vector3 &KRNode::getRotationPivot() const Vector3& KRNode::getRotationPivot()
{ {
return m_rotationPivot; return m_rotationPivot;
} }
const Vector3 &KRNode::getScalingPivot() const Vector3& KRNode::getScalingPivot()
{ {
return m_scalingPivot; return m_scalingPivot;
} }
const Vector3 &KRNode::getPreRotation() const Vector3& KRNode::getPreRotation()
{ {
return m_preRotation; return m_preRotation;
} }
const Vector3 &KRNode::getPostRotation() const Vector3& KRNode::getPostRotation()
{ {
return m_postRotation; return m_postRotation;
} }
const Vector3 &KRNode::getInitialRotationOffset() const Vector3& KRNode::getInitialRotationOffset()
{ {
return m_initialRotationOffset; return m_initialRotationOffset;
} }
const Vector3 &KRNode::getInitialScalingOffset() const Vector3& KRNode::getInitialScalingOffset()
{ {
return m_initialScalingOffset; return m_initialScalingOffset;
} }
const Vector3 &KRNode::getInitialRotationPivot() const Vector3& KRNode::getInitialRotationPivot()
{ {
return m_initialRotationPivot; return m_initialRotationPivot;
} }
const Vector3 &KRNode::getInitialScalingPivot() const Vector3& KRNode::getInitialScalingPivot()
{ {
return m_initialScalingPivot; return m_initialScalingPivot;
} }
const Vector3 &KRNode::getInitialPreRotation() const Vector3& KRNode::getInitialPreRotation()
{ {
return m_initialPreRotation; return m_initialPreRotation;
} }
const Vector3 &KRNode::getInitialPostRotation() const Vector3& KRNode::getInitialPostRotation()
{ {
return m_initialPostRotation; return m_initialPostRotation;
} }
const Vector3 &KRNode::getLocalTranslation() { const Vector3& KRNode::getLocalTranslation()
{
return m_localTranslation; return m_localTranslation;
} }
const Vector3 &KRNode::getLocalScale() { const Vector3& KRNode::getLocalScale()
{
return m_localScale; return m_localScale;
} }
const Vector3 &KRNode::getLocalRotation() { const Vector3& KRNode::getLocalRotation()
{
return m_localRotation; return m_localRotation;
} }
const Vector3 &KRNode::getInitialLocalTranslation() { const Vector3& KRNode::getInitialLocalTranslation()
{
return m_initialLocalTranslation; return m_initialLocalTranslation;
} }
const Vector3 &KRNode::getInitialLocalScale() { const Vector3& KRNode::getInitialLocalScale()
{
return m_initialLocalScale; return m_initialLocalScale;
} }
const Vector3 &KRNode::getInitialLocalRotation() { const Vector3& KRNode::getInitialLocalRotation()
{
return m_initialLocalRotation; return m_initialLocalRotation;
} }
const Vector3 KRNode::getWorldTranslation() { const Vector3 KRNode::getWorldTranslation()
{
return localToWorld(Vector3::Zero()); return localToWorld(Vector3::Zero());
} }
const Vector3 KRNode::getWorldScale() { const Vector3 KRNode::getWorldScale()
{
return Matrix4::DotNoTranslate(getModelMatrix(), m_localScale); return Matrix4::DotNoTranslate(getModelMatrix(), m_localScale);
} }
std::string KRNode::getElementName() { std::string KRNode::getElementName()
{
return "node"; return "node";
} }
KRNode *KRNode::LoadXML(KRScene &scene, tinyxml2::XMLElement *e) { KRNode* KRNode::LoadXML(KRScene& scene, tinyxml2::XMLElement* e)
KRNode *new_node = NULL; {
const char *szElementName = e->Name(); KRNode* new_node = NULL;
const char *szName = e->Attribute("name"); const char* szElementName = e->Name();
if(strcmp(szElementName, "node") == 0) { const char* szName = e->Attribute("name");
if (strcmp(szElementName, "node") == 0) {
new_node = new KRNode(scene, szName); new_node = new KRNode(scene, szName);
} else if(strcmp(szElementName, "lod_set") == 0) { } else if (strcmp(szElementName, "lod_set") == 0) {
new_node = new KRLODSet(scene, szName); new_node = new KRLODSet(scene, szName);
} else if(strcmp(szElementName, "lod_group") == 0) { } else if (strcmp(szElementName, "lod_group") == 0) {
new_node = new KRLODGroup(scene, szName); new_node = new KRLODGroup(scene, szName);
} else if(strcmp(szElementName, "point_light") == 0) { } else if (strcmp(szElementName, "point_light") == 0) {
new_node = new KRPointLight(scene, szName); new_node = new KRPointLight(scene, szName);
} else if(strcmp(szElementName, "directional_light") == 0) { } else if (strcmp(szElementName, "directional_light") == 0) {
new_node = new KRDirectionalLight(scene, szName); new_node = new KRDirectionalLight(scene, szName);
} else if(strcmp(szElementName, "spot_light") == 0) { } else if (strcmp(szElementName, "spot_light") == 0) {
new_node = new KRSpotLight(scene, szName); new_node = new KRSpotLight(scene, szName);
} else if(strcmp(szElementName, "particles_newtonian") == 0) { } else if (strcmp(szElementName, "particles_newtonian") == 0) {
new_node = new KRParticleSystemNewtonian(scene, szName); new_node = new KRParticleSystemNewtonian(scene, szName);
} else if(strcmp(szElementName, "sprite") == 0) { } else if (strcmp(szElementName, "sprite") == 0) {
new_node = new KRSprite(scene, szName); new_node = new KRSprite(scene, szName);
} else if(strcmp(szElementName, "model") == 0) { } else if (strcmp(szElementName, "model") == 0) {
float lod_min_coverage = 0.0f; float lod_min_coverage = 0.0f;
if(e->QueryFloatAttribute("lod_min_coverage", &lod_min_coverage) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("lod_min_coverage", &lod_min_coverage) != tinyxml2::XML_SUCCESS) {
lod_min_coverage = 0.0f; lod_min_coverage = 0.0f;
} }
bool receives_shadow = true; bool receives_shadow = true;
if(e->QueryBoolAttribute("receives_shadow", &receives_shadow) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("receives_shadow", &receives_shadow) != tinyxml2::XML_SUCCESS) {
receives_shadow = true; receives_shadow = true;
} }
bool faces_camera = false; bool faces_camera = false;
if(e->QueryBoolAttribute("faces_camera", &faces_camera) != tinyxml2::XML_SUCCESS) { if (e->QueryBoolAttribute("faces_camera", &faces_camera) != tinyxml2::XML_SUCCESS) {
faces_camera = false; faces_camera = false;
} }
float rim_power = 0.0f; float rim_power = 0.0f;
if(e->QueryFloatAttribute("rim_power", &rim_power) != tinyxml2::XML_SUCCESS) { if (e->QueryFloatAttribute("rim_power", &rim_power) != tinyxml2::XML_SUCCESS) {
rim_power = 0.0f; rim_power = 0.0f;
} }
Vector3 rim_color = Vector3::Zero(); Vector3 rim_color = Vector3::Zero();
rim_color = kraken::getXMLAttribute("rim_color", e, Vector3::Zero()); rim_color = kraken::getXMLAttribute("rim_color", e, Vector3::Zero());
new_node = new KRModel(scene, szName, e->Attribute("mesh"), e->Attribute("light_map"), lod_min_coverage, receives_shadow, faces_camera, rim_color, rim_power); new_node = new KRModel(scene, szName, e->Attribute("mesh"), e->Attribute("light_map"), lod_min_coverage, receives_shadow, faces_camera, rim_color, rim_power);
} else if(strcmp(szElementName, "collider") == 0) { } else if (strcmp(szElementName, "collider") == 0) {
new_node = new KRCollider(scene, szName, e->Attribute("mesh"), 65535, 1.0f); new_node = new KRCollider(scene, szName, e->Attribute("mesh"), 65535, 1.0f);
} else if(strcmp(szElementName, "bone") == 0) { } else if (strcmp(szElementName, "bone") == 0) {
new_node = new KRBone(scene, szName); new_node = new KRBone(scene, szName);
} else if(strcmp(szElementName, "locator") == 0) { } else if (strcmp(szElementName, "locator") == 0) {
new_node = new KRLocator(scene, szName); new_node = new KRLocator(scene, szName);
} else if(strcmp(szElementName, "audio_source") == 0) { } else if (strcmp(szElementName, "audio_source") == 0) {
new_node = new KRAudioSource(scene, szName); new_node = new KRAudioSource(scene, szName);
} else if(strcmp(szElementName, "ambient_zone") == 0) { } else if (strcmp(szElementName, "ambient_zone") == 0) {
new_node = new KRAmbientZone(scene, szName); new_node = new KRAmbientZone(scene, szName);
} else if(strcmp(szElementName, "reverb_zone") == 0) { } else if (strcmp(szElementName, "reverb_zone") == 0) {
new_node = new KRReverbZone(scene, szName); new_node = new KRReverbZone(scene, szName);
} else if(strcmp(szElementName, "camera") == 0) { } else if (strcmp(szElementName, "camera") == 0) {
new_node = new KRCamera(scene, szName); new_node = new KRCamera(scene, szName);
} }
if(new_node) { if (new_node) {
new_node->loadXML(e); new_node->loadXML(e);
} }
@@ -493,36 +510,41 @@ KRNode *KRNode::LoadXML(KRScene &scene, tinyxml2::XMLElement *e) {
void KRNode::render(const RenderInfo& ri) void KRNode::render(const RenderInfo& ri)
{ {
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
m_lastRenderFrame = getContext().getCurrentFrame(); m_lastRenderFrame = getContext().getCurrentFrame();
} }
const std::set<KRNode *> &KRNode::getChildren() { const std::set<KRNode*>& KRNode::getChildren()
{
return m_childNodes; return m_childNodes;
} }
KRNode *KRNode::getParent() { KRNode* KRNode::getParent()
{
return m_parentNode; return m_parentNode;
} }
const std::string &KRNode::getName() const { const std::string& KRNode::getName() const
{
return m_name; return m_name;
} }
KRScene &KRNode::getScene() { KRScene& KRNode::getScene()
{
return *m_pScene; return *m_pScene;
} }
AABB KRNode::getBounds() { AABB KRNode::getBounds()
if(!m_boundsValid) { {
if (!m_boundsValid) {
AABB bounds = AABB::Zero(); AABB bounds = AABB::Zero();
bool first_child = true; bool first_child = true;
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
KRNode *child = (*itr); KRNode* child = (*itr);
if(child->getBounds() != AABB::Zero()) { if (child->getBounds() != AABB::Zero()) {
if(first_child) { if (first_child) {
first_child = false; first_child = false;
bounds = child->getBounds(); bounds = child->getBounds();
} else { } else {
@@ -542,8 +564,8 @@ void KRNode::invalidateModelMatrix()
m_modelMatrixValid = false; m_modelMatrixValid = false;
m_activePoseMatrixValid = false; m_activePoseMatrixValid = false;
m_inverseModelMatrixValid = false; m_inverseModelMatrixValid = false;
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
KRNode *child = (*itr); KRNode* child = (*itr);
child->invalidateModelMatrix(); child->invalidateModelMatrix();
} }
@@ -555,24 +577,24 @@ void KRNode::invalidateBindPoseMatrix()
{ {
m_bindPoseMatrixValid = false; m_bindPoseMatrixValid = false;
m_inverseBindPoseMatrixValid = false; m_inverseBindPoseMatrixValid = false;
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
KRNode *child = (*itr); KRNode* child = (*itr);
child->invalidateBindPoseMatrix(); child->invalidateBindPoseMatrix();
} }
} }
const Matrix4 &KRNode::getModelMatrix() const Matrix4& KRNode::getModelMatrix()
{ {
if(!m_modelMatrixValid) { if (!m_modelMatrixValid) {
m_modelMatrix = Matrix4(); m_modelMatrix = Matrix4();
bool parent_is_bone = false; bool parent_is_bone = false;
if(dynamic_cast<KRBone *>(m_parentNode)) { if (dynamic_cast<KRBone*>(m_parentNode)) {
parent_is_bone = true; parent_is_bone = true;
} }
if(getScaleCompensation() && parent_is_bone) { if (getScaleCompensation() && parent_is_bone) {
// WorldTransform = ParentWorldTransform * T * Roff * Rp * Rpre * R * Rpost * Rp-1 * Soff * Sp * S * Sp-1 // WorldTransform = ParentWorldTransform * T * Roff * Rp * Rpre * R * Rpost * Rp-1 * Soff * Sp * S * Sp-1
@@ -588,7 +610,7 @@ const Matrix4 &KRNode::getModelMatrix()
* Matrix4::Translation(m_rotationPivot) * Matrix4::Translation(m_rotationPivot)
* Matrix4::Translation(m_rotationOffset); * Matrix4::Translation(m_rotationOffset);
if(m_parentNode) { if (m_parentNode) {
m_modelMatrix.rotate(m_parentNode->getWorldRotation()); m_modelMatrix.rotate(m_parentNode->getWorldRotation());
m_modelMatrix.translate(Matrix4::Dot(m_parentNode->getModelMatrix(), m_localTranslation)); m_modelMatrix.translate(Matrix4::Dot(m_parentNode->getModelMatrix(), m_localTranslation));
@@ -611,7 +633,7 @@ const Matrix4 &KRNode::getModelMatrix()
* Matrix4::Translation(m_rotationOffset) * Matrix4::Translation(m_rotationOffset)
* Matrix4::Translation(m_localTranslation); * Matrix4::Translation(m_localTranslation);
if(m_parentNode) { if (m_parentNode) {
m_modelMatrix *= m_parentNode->getModelMatrix(); m_modelMatrix *= m_parentNode->getModelMatrix();
} }
} }
@@ -622,17 +644,17 @@ const Matrix4 &KRNode::getModelMatrix()
return m_modelMatrix; return m_modelMatrix;
} }
const Matrix4 &KRNode::getBindPoseMatrix() const Matrix4& KRNode::getBindPoseMatrix()
{ {
if(!m_bindPoseMatrixValid) { if (!m_bindPoseMatrixValid) {
m_bindPoseMatrix = Matrix4(); m_bindPoseMatrix = Matrix4();
bool parent_is_bone = false; bool parent_is_bone = false;
if(dynamic_cast<KRBone *>(m_parentNode)) { if (dynamic_cast<KRBone*>(m_parentNode)) {
parent_is_bone = true; parent_is_bone = true;
} }
if(getScaleCompensation() && parent_is_bone) { if (getScaleCompensation() && parent_is_bone) {
m_bindPoseMatrix = Matrix4::Translation(-m_initialScalingPivot) m_bindPoseMatrix = Matrix4::Translation(-m_initialScalingPivot)
* Matrix4::Scaling(m_initialLocalScale) * Matrix4::Scaling(m_initialLocalScale)
* Matrix4::Translation(m_initialScalingPivot) * Matrix4::Translation(m_initialScalingPivot)
@@ -645,7 +667,7 @@ const Matrix4 &KRNode::getBindPoseMatrix()
* Matrix4::Translation(m_initialRotationPivot) * Matrix4::Translation(m_initialRotationPivot)
* Matrix4::Translation(m_initialRotationOffset); * Matrix4::Translation(m_initialRotationOffset);
//m_bindPoseMatrix.translate(m_localTranslation); //m_bindPoseMatrix.translate(m_localTranslation);
if(m_parentNode) { if (m_parentNode) {
m_bindPoseMatrix.rotate(m_parentNode->getBindPoseWorldRotation()); m_bindPoseMatrix.rotate(m_parentNode->getBindPoseWorldRotation());
m_bindPoseMatrix.translate(Matrix4::Dot(m_parentNode->getBindPoseMatrix(), m_localTranslation)); m_bindPoseMatrix.translate(Matrix4::Dot(m_parentNode->getBindPoseMatrix(), m_localTranslation));
@@ -669,7 +691,7 @@ const Matrix4 &KRNode::getBindPoseMatrix()
* Matrix4::Translation(m_initialRotationOffset) * Matrix4::Translation(m_initialRotationOffset)
* Matrix4::Translation(m_initialLocalTranslation); * Matrix4::Translation(m_initialLocalTranslation);
if(m_parentNode && parent_is_bone) { if (m_parentNode && parent_is_bone) {
m_bindPoseMatrix *= m_parentNode->getBindPoseMatrix(); m_bindPoseMatrix *= m_parentNode->getBindPoseMatrix();
} }
@@ -681,19 +703,19 @@ const Matrix4 &KRNode::getBindPoseMatrix()
return m_bindPoseMatrix; return m_bindPoseMatrix;
} }
const Matrix4 &KRNode::getActivePoseMatrix() const Matrix4& KRNode::getActivePoseMatrix()
{ {
if(!m_activePoseMatrixValid) { if (!m_activePoseMatrixValid) {
m_activePoseMatrix = Matrix4(); m_activePoseMatrix = Matrix4();
bool parent_is_bone = false; bool parent_is_bone = false;
if(dynamic_cast<KRBone *>(m_parentNode)) { if (dynamic_cast<KRBone*>(m_parentNode)) {
parent_is_bone = true; parent_is_bone = true;
} }
if(getScaleCompensation() && parent_is_bone) { if (getScaleCompensation() && parent_is_bone) {
m_activePoseMatrix= Matrix4::Translation(-m_scalingPivot) m_activePoseMatrix = Matrix4::Translation(-m_scalingPivot)
* Matrix4::Scaling(m_localScale) * Matrix4::Scaling(m_localScale)
* Matrix4::Translation(m_scalingPivot) * Matrix4::Translation(m_scalingPivot)
* Matrix4::Translation(m_scalingOffset) * Matrix4::Translation(m_scalingOffset)
@@ -704,7 +726,7 @@ const Matrix4 &KRNode::getActivePoseMatrix()
* Matrix4::Translation(m_rotationPivot) * Matrix4::Translation(m_rotationPivot)
* Matrix4::Translation(m_rotationOffset); * Matrix4::Translation(m_rotationOffset);
if(m_parentNode) { if (m_parentNode) {
m_activePoseMatrix.rotate(m_parentNode->getActivePoseWorldRotation()); m_activePoseMatrix.rotate(m_parentNode->getActivePoseWorldRotation());
m_activePoseMatrix.translate(Matrix4::Dot(m_parentNode->getActivePoseMatrix(), m_localTranslation)); m_activePoseMatrix.translate(Matrix4::Dot(m_parentNode->getActivePoseMatrix(), m_localTranslation));
@@ -727,7 +749,7 @@ const Matrix4 &KRNode::getActivePoseMatrix()
* Matrix4::Translation(m_localTranslation); * Matrix4::Translation(m_localTranslation);
if(m_parentNode && parent_is_bone) { if (m_parentNode && parent_is_bone) {
m_activePoseMatrix *= m_parentNode->getActivePoseMatrix(); m_activePoseMatrix *= m_parentNode->getActivePoseMatrix();
} }
} }
@@ -739,41 +761,44 @@ const Matrix4 &KRNode::getActivePoseMatrix()
} }
const Quaternion KRNode::getWorldRotation() { const Quaternion KRNode::getWorldRotation()
{
Quaternion world_rotation = Quaternion::Create(m_postRotation) * Quaternion::Create(m_localRotation) * Quaternion::Create(m_preRotation); Quaternion world_rotation = Quaternion::Create(m_postRotation) * Quaternion::Create(m_localRotation) * Quaternion::Create(m_preRotation);
if(m_parentNode) { if (m_parentNode) {
world_rotation = world_rotation * m_parentNode->getWorldRotation(); world_rotation = world_rotation * m_parentNode->getWorldRotation();
} }
return world_rotation; return world_rotation;
} }
const Quaternion KRNode::getBindPoseWorldRotation() { const Quaternion KRNode::getBindPoseWorldRotation()
{
Quaternion world_rotation = Quaternion::Create(m_initialPostRotation) * Quaternion::Create(m_initialLocalRotation) * Quaternion::Create(m_initialPreRotation); Quaternion world_rotation = Quaternion::Create(m_initialPostRotation) * Quaternion::Create(m_initialLocalRotation) * Quaternion::Create(m_initialPreRotation);
if(dynamic_cast<KRBone *>(m_parentNode)) { if (dynamic_cast<KRBone*>(m_parentNode)) {
world_rotation = world_rotation * m_parentNode->getBindPoseWorldRotation(); world_rotation = world_rotation * m_parentNode->getBindPoseWorldRotation();
} }
return world_rotation; return world_rotation;
} }
const Quaternion KRNode::getActivePoseWorldRotation() { const Quaternion KRNode::getActivePoseWorldRotation()
{
Quaternion world_rotation = Quaternion::Create(m_postRotation) * Quaternion::Create(m_localRotation) * Quaternion::Create(m_preRotation); Quaternion world_rotation = Quaternion::Create(m_postRotation) * Quaternion::Create(m_localRotation) * Quaternion::Create(m_preRotation);
if(dynamic_cast<KRBone *>(m_parentNode)) { if (dynamic_cast<KRBone*>(m_parentNode)) {
world_rotation = world_rotation * m_parentNode->getActivePoseWorldRotation(); world_rotation = world_rotation * m_parentNode->getActivePoseWorldRotation();
} }
return world_rotation; return world_rotation;
} }
const Matrix4 &KRNode::getInverseModelMatrix() const Matrix4& KRNode::getInverseModelMatrix()
{ {
if(!m_inverseModelMatrixValid) { if (!m_inverseModelMatrixValid) {
m_inverseModelMatrix = Matrix4::Invert(getModelMatrix()); m_inverseModelMatrix = Matrix4::Invert(getModelMatrix());
} }
return m_inverseModelMatrix; return m_inverseModelMatrix;
} }
const Matrix4 &KRNode::getInverseBindPoseMatrix() const Matrix4& KRNode::getInverseBindPoseMatrix()
{ {
if(!m_inverseBindPoseMatrixValid ) { if (!m_inverseBindPoseMatrixValid) {
m_inverseBindPoseMatrix = Matrix4::Invert(getBindPoseMatrix()); m_inverseBindPoseMatrix = Matrix4::Invert(getBindPoseMatrix());
m_inverseBindPoseMatrixValid = true; m_inverseBindPoseMatrixValid = true;
} }
@@ -784,9 +809,9 @@ void KRNode::physicsUpdate(float deltaTime)
{ {
const long MIN_DISPLAY_FRAMES = 10; const long MIN_DISPLAY_FRAMES = 10;
bool visible = m_lastRenderFrame + MIN_DISPLAY_FRAMES >= getContext().getCurrentFrame(); bool visible = m_lastRenderFrame + MIN_DISPLAY_FRAMES >= getContext().getCurrentFrame();
for(std::set<KRBehavior *>::iterator itr=m_behaviors.begin(); itr != m_behaviors.end(); itr++) { for (std::set<KRBehavior*>::iterator itr = m_behaviors.begin(); itr != m_behaviors.end(); itr++) {
(*itr)->update(deltaTime); (*itr)->update(deltaTime);
if(visible) { if (visible) {
(*itr)->visibleUpdate(deltaTime); (*itr)->visibleUpdate(deltaTime);
} }
} }
@@ -799,12 +824,12 @@ bool KRNode::hasPhysics()
void KRNode::SetAttribute(node_attribute_type attrib, float v) void KRNode::SetAttribute(node_attribute_type attrib, float v)
{ {
if(m_animation_mask[attrib]) return; if (m_animation_mask[attrib]) return;
const float DEGREES_TO_RAD = (float)M_PI / 180.0f; const float DEGREES_TO_RAD = (float)M_PI / 180.0f;
//printf("%s - ", m_name.c_str()); //printf("%s - ", m_name.c_str());
switch(attrib) { switch (attrib) {
case KRENGINE_NODE_ATTRIBUTE_TRANSLATE_X: case KRENGINE_NODE_ATTRIBUTE_TRANSLATE_X:
setLocalTranslation(Vector3::Create(v, m_localTranslation.y, m_localTranslation.z)); setLocalTranslation(Vector3::Create(v, m_localTranslation.y, m_localTranslation.z));
break; break;
@@ -906,14 +931,14 @@ bool KRNode::getAnimationEnabled(node_attribute_type attrib) const
void KRNode::removeFromOctreeNodes() void KRNode::removeFromOctreeNodes()
{ {
for(std::set<KROctreeNode *>::iterator itr=m_octree_nodes.begin(); itr != m_octree_nodes.end(); itr++) { for (std::set<KROctreeNode*>::iterator itr = m_octree_nodes.begin(); itr != m_octree_nodes.end(); itr++) {
KROctreeNode *octree_node = *itr; KROctreeNode* octree_node = *itr;
octree_node->remove(this); octree_node->remove(this);
// FINDME, TODO - This should be moved to the KROctree class // FINDME, TODO - This should be moved to the KROctree class
while(octree_node) { while (octree_node) {
octree_node->trim(); octree_node->trim();
if(octree_node->isEmpty()) { if (octree_node->isEmpty()) {
octree_node = octree_node->getParent(); octree_node = octree_node->getParent();
} else { } else {
octree_node = NULL; octree_node = NULL;
@@ -923,15 +948,15 @@ void KRNode::removeFromOctreeNodes()
m_octree_nodes.clear(); m_octree_nodes.clear();
} }
void KRNode::addToOctreeNode(KROctreeNode *octree_node) void KRNode::addToOctreeNode(KROctreeNode* octree_node)
{ {
m_octree_nodes.insert(octree_node); m_octree_nodes.insert(octree_node);
} }
void KRNode::updateLODVisibility(const KRViewport &viewport) void KRNode::updateLODVisibility(const KRViewport& viewport)
{ {
if(m_lod_visible >= LOD_VISIBILITY_PRESTREAM) { if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM) {
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
(*itr)->updateLODVisibility(viewport); (*itr)->updateLODVisibility(viewport);
} }
} }
@@ -939,16 +964,16 @@ void KRNode::updateLODVisibility(const KRViewport &viewport)
void KRNode::setLODVisibility(KRNode::LodVisibility lod_visibility) void KRNode::setLODVisibility(KRNode::LodVisibility lod_visibility)
{ {
if(m_lod_visible != lod_visibility) { if (m_lod_visible != lod_visibility) {
if(m_lod_visible == LOD_VISIBILITY_HIDDEN && lod_visibility >= LOD_VISIBILITY_PRESTREAM) { if (m_lod_visible == LOD_VISIBILITY_HIDDEN && lod_visibility >= LOD_VISIBILITY_PRESTREAM) {
getScene().notify_sceneGraphCreate(this); getScene().notify_sceneGraphCreate(this);
} else if(m_lod_visible >= LOD_VISIBILITY_PRESTREAM && lod_visibility == LOD_VISIBILITY_HIDDEN) { } else if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && lod_visibility == LOD_VISIBILITY_HIDDEN) {
getScene().notify_sceneGraphDelete(this); getScene().notify_sceneGraphDelete(this);
} }
m_lod_visible = lod_visibility; m_lod_visible = lod_visibility;
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
(*itr)->setLODVisibility(lod_visibility); (*itr)->setLODVisibility(lod_visibility);
} }
} }
@@ -959,33 +984,33 @@ KRNode::LodVisibility KRNode::getLODVisibility()
return m_lod_visible; return m_lod_visible;
} }
const Vector3 KRNode::localToWorld(const Vector3 &local_point) const Vector3 KRNode::localToWorld(const Vector3& local_point)
{ {
return Matrix4::Dot(getModelMatrix(), local_point); return Matrix4::Dot(getModelMatrix(), local_point);
} }
const Vector3 KRNode::worldToLocal(const Vector3 &world_point) const Vector3 KRNode::worldToLocal(const Vector3& world_point)
{ {
return Matrix4::Dot(getInverseModelMatrix(), world_point); return Matrix4::Dot(getInverseModelMatrix(), world_point);
} }
void KRNode::addBehavior(KRBehavior *behavior) void KRNode::addBehavior(KRBehavior* behavior)
{ {
m_behaviors.insert(behavior); m_behaviors.insert(behavior);
behavior->__setNode(this); behavior->__setNode(this);
getScene().notify_sceneGraphModify(this); getScene().notify_sceneGraphModify(this);
} }
std::set<KRBehavior *> &KRNode::getBehaviors() std::set<KRBehavior*>& KRNode::getBehaviors()
{ {
return m_behaviors; return m_behaviors;
} }
kraken_stream_level KRNode::getStreamLevel(const KRViewport &viewport) kraken_stream_level KRNode::getStreamLevel(const KRViewport& viewport)
{ {
kraken_stream_level stream_level = kraken_stream_level::STREAM_LEVEL_IN_HQ; kraken_stream_level stream_level = kraken_stream_level::STREAM_LEVEL_IN_HQ;
for(std::set<KRNode *>::iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
stream_level = KRMIN(stream_level, (*itr)->getStreamLevel(viewport)); stream_level = KRMIN(stream_level, (*itr)->getStreamLevel(viewport));
} }
@@ -995,7 +1020,7 @@ kraken_stream_level KRNode::getStreamLevel(const KRViewport &viewport)
void KRNode::invalidateBounds() const void KRNode::invalidateBounds() const
{ {
m_boundsValid = false; m_boundsValid = false;
if(m_parentNode) { if (m_parentNode) {
m_parentNode->invalidateBounds(); m_parentNode->invalidateBounds();
} }
} }

160
kraken/KRNode.h
View File

@@ -56,14 +56,15 @@ class KRPointLight;
class KRSpotLight; class KRSpotLight;
class KRDirectionalLight; class KRDirectionalLight;
namespace tinyxml2 { namespace tinyxml2 {
class XMLNode; class XMLNode;
class XMLAttribute; class XMLAttribute;
} }
class KRNode : public KRContextObject class KRNode : public KRContextObject
{ {
public: public:
enum RenderPass { enum RenderPass
{
RENDER_PASS_FORWARD_OPAQUE, RENDER_PASS_FORWARD_OPAQUE,
RENDER_PASS_DEFERRED_GBUFFER, RENDER_PASS_DEFERRED_GBUFFER,
RENDER_PASS_DEFERRED_LIGHTS, RENDER_PASS_DEFERRED_LIGHTS,
@@ -77,13 +78,15 @@ public:
RENDER_PASS_PRESTREAM RENDER_PASS_PRESTREAM
}; };
enum LodVisibility { enum LodVisibility
{
LOD_VISIBILITY_HIDDEN, LOD_VISIBILITY_HIDDEN,
LOD_VISIBILITY_PRESTREAM, LOD_VISIBILITY_PRESTREAM,
LOD_VISIBILITY_VISIBLE LOD_VISIBILITY_VISIBLE
}; };
class RenderInfo { class RenderInfo
{
public: public:
RenderInfo(VkCommandBuffer& cb) RenderInfo(VkCommandBuffer& cb)
: commandBuffer(cb) : commandBuffer(cb)
@@ -106,55 +109,55 @@ public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRNode(KRScene &scene, std::string name); KRNode(KRScene& scene, std::string name);
virtual ~KRNode(); virtual ~KRNode();
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
static KRNode *LoadXML(KRScene &scene, tinyxml2::XMLElement *e); static KRNode* LoadXML(KRScene& scene, tinyxml2::XMLElement* e);
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
virtual std::string getElementName(); virtual std::string getElementName();
const std::string &getName() const; const std::string& getName() const;
void addChild(KRNode *child); void addChild(KRNode* child);
const std::set<KRNode *> &getChildren(); const std::set<KRNode*>& getChildren();
KRNode *getParent(); KRNode* getParent();
void setLocalTranslation(const Vector3 &v, bool set_original = false); void setLocalTranslation(const Vector3& v, bool set_original = false);
void setLocalScale(const Vector3 &v, bool set_original = false); void setLocalScale(const Vector3& v, bool set_original = false);
void setLocalRotation(const Vector3 &v, bool set_original = false); void setLocalRotation(const Vector3& v, bool set_original = false);
void setRotationOffset(const Vector3 &v, bool set_original = false); void setRotationOffset(const Vector3& v, bool set_original = false);
void setScalingOffset(const Vector3 &v, bool set_original = false); void setScalingOffset(const Vector3& v, bool set_original = false);
void setRotationPivot(const Vector3 &v, bool set_original = false); void setRotationPivot(const Vector3& v, bool set_original = false);
void setScalingPivot(const Vector3 &v, bool set_original = false); void setScalingPivot(const Vector3& v, bool set_original = false);
void setPreRotation(const Vector3 &v, bool set_original = false); void setPreRotation(const Vector3& v, bool set_original = false);
void setPostRotation(const Vector3 &v, bool set_original = false); void setPostRotation(const Vector3& v, bool set_original = false);
const Vector3 &getRotationOffset(); const Vector3& getRotationOffset();
const Vector3 &getScalingOffset(); const Vector3& getScalingOffset();
const Vector3 &getRotationPivot(); const Vector3& getRotationPivot();
const Vector3 &getScalingPivot(); const Vector3& getScalingPivot();
const Vector3 &getPreRotation(); const Vector3& getPreRotation();
const Vector3 &getPostRotation(); const Vector3& getPostRotation();
const Vector3 &getInitialRotationOffset(); const Vector3& getInitialRotationOffset();
const Vector3 &getInitialScalingOffset(); const Vector3& getInitialScalingOffset();
const Vector3 &getInitialRotationPivot(); const Vector3& getInitialRotationPivot();
const Vector3 &getInitialScalingPivot(); const Vector3& getInitialScalingPivot();
const Vector3 &getInitialPreRotation(); const Vector3& getInitialPreRotation();
const Vector3 &getInitialPostRotation(); const Vector3& getInitialPostRotation();
const Vector3 &getLocalTranslation(); const Vector3& getLocalTranslation();
const Vector3 &getLocalScale(); const Vector3& getLocalScale();
const Vector3 &getLocalRotation(); const Vector3& getLocalRotation();
const Vector3 &getInitialLocalTranslation(); const Vector3& getInitialLocalTranslation();
const Vector3 &getInitialLocalScale(); const Vector3& getInitialLocalScale();
const Vector3 &getInitialLocalRotation(); const Vector3& getInitialLocalRotation();
const Vector3 getWorldTranslation(); const Vector3 getWorldTranslation();
const Vector3 getWorldScale(); const Vector3 getWorldScale();
@@ -163,22 +166,23 @@ public:
const Quaternion getBindPoseWorldRotation(); const Quaternion getBindPoseWorldRotation();
const Quaternion getActivePoseWorldRotation(); const Quaternion getActivePoseWorldRotation();
const Vector3 localToWorld(const Vector3 &local_point); const Vector3 localToWorld(const Vector3& local_point);
const Vector3 worldToLocal(const Vector3 &world_point); const Vector3 worldToLocal(const Vector3& world_point);
void setWorldTranslation(const Vector3 &v); void setWorldTranslation(const Vector3& v);
void setWorldScale(const Vector3 &v); void setWorldScale(const Vector3& v);
void setWorldRotation(const Vector3 &v); void setWorldRotation(const Vector3& v);
virtual AABB getBounds(); virtual AABB getBounds();
void invalidateBounds() const; void invalidateBounds() const;
const Matrix4 &getModelMatrix(); const Matrix4& getModelMatrix();
const Matrix4 &getInverseModelMatrix(); const Matrix4& getInverseModelMatrix();
const Matrix4 &getBindPoseMatrix(); const Matrix4& getBindPoseMatrix();
const Matrix4 &getActivePoseMatrix(); const Matrix4& getActivePoseMatrix();
const Matrix4 &getInverseBindPoseMatrix(); const Matrix4& getInverseBindPoseMatrix();
enum node_attribute_type { enum node_attribute_type
{
KRENGINE_NODE_ATTRIBUTE_NONE, KRENGINE_NODE_ATTRIBUTE_NONE,
KRENGINE_NODE_ATTRIBUTE_TRANSLATE_X, KRENGINE_NODE_ATTRIBUTE_TRANSLATE_X,
KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Y, KRENGINE_NODE_ATTRIBUTE_TRANSLATE_Y,
@@ -212,14 +216,14 @@ public:
void SetAttribute(node_attribute_type attrib, float v); void SetAttribute(node_attribute_type attrib, float v);
KRScene &getScene(); KRScene& getScene();
virtual void render(const RenderInfo& ri); virtual void render(const RenderInfo& ri);
virtual void physicsUpdate(float deltaTime); virtual void physicsUpdate(float deltaTime);
virtual bool hasPhysics(); virtual bool hasPhysics();
virtual void updateLODVisibility(const KRViewport &viewport); virtual void updateLODVisibility(const KRViewport& viewport);
LodVisibility getLODVisibility(); LodVisibility getLODVisibility();
void setScaleCompensation(bool scale_compensation); void setScaleCompensation(bool scale_compensation);
@@ -228,7 +232,7 @@ public:
bool getAnimationEnabled(node_attribute_type attrib) const; bool getAnimationEnabled(node_attribute_type attrib) const;
virtual kraken_stream_level getStreamLevel(const KRViewport &viewport); virtual kraken_stream_level getStreamLevel(const KRViewport& viewport);
virtual void setLODVisibility(LodVisibility lod_visibility); virtual void setLODVisibility(LodVisibility lod_visibility);
@@ -257,8 +261,8 @@ protected:
LodVisibility m_lod_visible; LodVisibility m_lod_visible;
KRNode *m_parentNode; KRNode* m_parentNode;
std::set<KRNode *> m_childNodes; std::set<KRNode*> m_childNodes;
bool m_animation_mask[KRENGINE_NODE_ATTRIBUTE_COUNT]; bool m_animation_mask[KRENGINE_NODE_ATTRIBUTE_COUNT];
@@ -284,40 +288,40 @@ private:
KRScene *m_pScene; KRScene* m_pScene;
std::set<KROctreeNode *> m_octree_nodes; std::set<KROctreeNode*> m_octree_nodes;
bool m_scale_compensation; bool m_scale_compensation;
std::set<KRBehavior *> m_behaviors; std::set<KRBehavior*> m_behaviors;
public: public:
void addBehavior(KRBehavior *behavior); void addBehavior(KRBehavior* behavior);
std::set<KRBehavior *> &getBehaviors(); std::set<KRBehavior*>& getBehaviors();
template <class T> T *getBehavior() template <class T> T* getBehavior()
{ {
for(std::set<KRBehavior *>::iterator itr=m_behaviors.begin(); itr != m_behaviors.end(); itr++) { for (std::set<KRBehavior*>::iterator itr = m_behaviors.begin(); itr != m_behaviors.end(); itr++) {
T *behavior = dynamic_cast<T *>(*itr); T* behavior = dynamic_cast<T*>(*itr);
if(behavior) { if (behavior) {
return behavior; return behavior;
} }
} }
return NULL; return NULL;
} }
void removeFromOctreeNodes(); void removeFromOctreeNodes();
void addToOctreeNode(KROctreeNode *octree_node); void addToOctreeNode(KROctreeNode* octree_node);
void childDeleted(KRNode *child_node); void childDeleted(KRNode* child_node);
template <class T> T *find() template <class T> T* find()
{ {
T *match = dynamic_cast<T *>(this); T* match = dynamic_cast<T*>(this);
if(match) { if (match) {
return match; return match;
} }
for(std::set<KRNode *>::const_iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::const_iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
match = (*itr)->find<T>(); match = (*itr)->find<T>();
if(match) { if (match) {
return match; return match;
} }
} }
@@ -325,18 +329,18 @@ public:
return NULL; return NULL;
} }
template <class T> T *find(const std::string &name) template <class T> T* find(const std::string& name)
{ {
T *match = dynamic_cast<T *>(this); T* match = dynamic_cast<T*>(this);
if(match) { if (match) {
if(name.compare(match->getName()) == 0) { if (name.compare(match->getName()) == 0) {
return match; return match;
} }
} }
for(std::set<KRNode *>::const_iterator itr=m_childNodes.begin(); itr != m_childNodes.end(); ++itr) { for (std::set<KRNode*>::const_iterator itr = m_childNodes.begin(); itr != m_childNodes.end(); ++itr) {
match = (*itr)->find<T>(name); match = (*itr)->find<T>(name);
if(match) { if (match) {
return match; return match;
} }
} }

86
kraken/KROctree.cpp
View File

@@ -41,33 +41,33 @@ KROctree::KROctree()
KROctree::~KROctree() KROctree::~KROctree()
{ {
if(m_pRootNode) { if (m_pRootNode) {
delete m_pRootNode; delete m_pRootNode;
} }
} }
void KROctree::add(KRNode *pNode) void KROctree::add(KRNode* pNode)
{ {
AABB nodeBounds = pNode->getBounds(); AABB nodeBounds = pNode->getBounds();
if(nodeBounds == AABB::Zero()) { if (nodeBounds == AABB::Zero()) {
// This item is not visible, don't add it to the octree or outer scene nodes // This item is not visible, don't add it to the octree or outer scene nodes
} else if(nodeBounds == AABB::Infinite()) { } else if (nodeBounds == AABB::Infinite()) {
// This item is infinitely large; we track it separately // This item is infinitely large; we track it separately
m_outerSceneNodes.insert(pNode); m_outerSceneNodes.insert(pNode);
} else { } else {
if(m_pRootNode == NULL) { if (m_pRootNode == NULL) {
// First item inserted, create a node large enough to fit it // First item inserted, create a node large enough to fit it
m_pRootNode = new KROctreeNode(NULL, nodeBounds); m_pRootNode = new KROctreeNode(NULL, nodeBounds);
m_pRootNode->add(pNode); m_pRootNode->add(pNode);
} else { } else {
// Keep encapsulating the root node until the new root contains the inserted node // Keep encapsulating the root node until the new root contains the inserted node
bool bInsideRoot = false; bool bInsideRoot = false;
while(!bInsideRoot) { while (!bInsideRoot) {
AABB rootBounds = m_pRootNode->getBounds(); AABB rootBounds = m_pRootNode->getBounds();
Vector3 rootSize = rootBounds.size(); Vector3 rootSize = rootBounds.size();
if(nodeBounds.min.x < rootBounds.min.x || nodeBounds.min.y < rootBounds.min.y || nodeBounds.min.z < rootBounds.min.z) { if (nodeBounds.min.x < rootBounds.min.x || nodeBounds.min.y < rootBounds.min.y || nodeBounds.min.z < rootBounds.min.z) {
m_pRootNode = new KROctreeNode(NULL, AABB::Create(rootBounds.min - rootSize, rootBounds.max), 7, m_pRootNode); m_pRootNode = new KROctreeNode(NULL, AABB::Create(rootBounds.min - rootSize, rootBounds.max), 7, m_pRootNode);
} else if(nodeBounds.max.x > rootBounds.max.x || nodeBounds.max.y > rootBounds.max.y || nodeBounds.max.z > rootBounds.max.z) { } else if (nodeBounds.max.x > rootBounds.max.x || nodeBounds.max.y > rootBounds.max.y || nodeBounds.max.z > rootBounds.max.z) {
m_pRootNode = new KROctreeNode(NULL, AABB::Create(rootBounds.min, rootBounds.max + rootSize), 0, m_pRootNode); m_pRootNode = new KROctreeNode(NULL, AABB::Create(rootBounds.min, rootBounds.max + rootSize), 0, m_pRootNode);
} else { } else {
bInsideRoot = true; bInsideRoot = true;
@@ -78,10 +78,10 @@ void KROctree::add(KRNode *pNode)
} }
} }
void KROctree::remove(KRNode *pNode) void KROctree::remove(KRNode* pNode)
{ {
if(!m_outerSceneNodes.erase(pNode)) { if (!m_outerSceneNodes.erase(pNode)) {
if(m_pRootNode) { if (m_pRootNode) {
pNode->removeFromOctreeNodes(); pNode->removeFromOctreeNodes();
} }
} }
@@ -89,7 +89,7 @@ void KROctree::remove(KRNode *pNode)
shrink(); shrink();
} }
void KROctree::update(KRNode *pNode) void KROctree::update(KRNode* pNode)
{ {
// TODO: This may be more efficient as an incremental operation rather than removing and re-adding the node // TODO: This may be more efficient as an incremental operation rather than removing and re-adding the node
remove(pNode); remove(pNode);
@@ -99,80 +99,80 @@ void KROctree::update(KRNode *pNode)
void KROctree::shrink() void KROctree::shrink()
{ {
if(m_pRootNode) { if (m_pRootNode) {
while(m_pRootNode->canShrinkRoot()) { while (m_pRootNode->canShrinkRoot()) {
KROctreeNode *newRoot = m_pRootNode->stripChild(); KROctreeNode* newRoot = m_pRootNode->stripChild();
delete m_pRootNode; delete m_pRootNode;
m_pRootNode = newRoot; m_pRootNode = newRoot;
if(m_pRootNode == NULL) return; if (m_pRootNode == NULL) return;
} }
} }
} }
KROctreeNode *KROctree::getRootNode() KROctreeNode* KROctree::getRootNode()
{ {
return m_pRootNode; return m_pRootNode;
} }
std::set<KRNode *> &KROctree::getOuterSceneNodes() std::set<KRNode*>& KROctree::getOuterSceneNodes()
{ {
return m_outerSceneNodes; return m_outerSceneNodes;
} }
bool KROctree::lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo, unsigned int layer_mask) bool KROctree::lineCast(const Vector3& v0, const Vector3& v1, HitInfo& hitinfo, unsigned int layer_mask)
{ {
bool hit_found = false; bool hit_found = false;
std::vector<KRCollider *> outer_colliders; std::vector<KRCollider*> outer_colliders;
for(std::set<KRNode *>::iterator outer_nodes_itr=m_outerSceneNodes.begin(); outer_nodes_itr != m_outerSceneNodes.end(); outer_nodes_itr++) { for (std::set<KRNode*>::iterator outer_nodes_itr = m_outerSceneNodes.begin(); outer_nodes_itr != m_outerSceneNodes.end(); outer_nodes_itr++) {
KRCollider *collider = dynamic_cast<KRCollider *>(*outer_nodes_itr); KRCollider* collider = dynamic_cast<KRCollider*>(*outer_nodes_itr);
if(collider) { if (collider) {
outer_colliders.push_back(collider); outer_colliders.push_back(collider);
} }
} }
for(std::vector<KRCollider *>::iterator itr=outer_colliders.begin(); itr != outer_colliders.end(); itr++) { for (std::vector<KRCollider*>::iterator itr = outer_colliders.begin(); itr != outer_colliders.end(); itr++) {
if((*itr)->lineCast(v0, v1, hitinfo, layer_mask)) hit_found = true; if ((*itr)->lineCast(v0, v1, hitinfo, layer_mask)) hit_found = true;
} }
if(m_pRootNode) { if (m_pRootNode) {
if(m_pRootNode->lineCast(v0, v1, hitinfo, layer_mask)) hit_found = true; if (m_pRootNode->lineCast(v0, v1, hitinfo, layer_mask)) hit_found = true;
} }
return hit_found; return hit_found;
} }
bool KROctree::rayCast(const Vector3 &v0, const Vector3 &dir, HitInfo &hitinfo, unsigned int layer_mask) bool KROctree::rayCast(const Vector3& v0, const Vector3& dir, HitInfo& hitinfo, unsigned int layer_mask)
{ {
bool hit_found = false; bool hit_found = false;
for(std::set<KRNode *>::iterator outer_nodes_itr=m_outerSceneNodes.begin(); outer_nodes_itr != m_outerSceneNodes.end(); outer_nodes_itr++) { for (std::set<KRNode*>::iterator outer_nodes_itr = m_outerSceneNodes.begin(); outer_nodes_itr != m_outerSceneNodes.end(); outer_nodes_itr++) {
KRCollider *collider = dynamic_cast<KRCollider *>(*outer_nodes_itr); KRCollider* collider = dynamic_cast<KRCollider*>(*outer_nodes_itr);
if(collider) { if (collider) {
if(collider->rayCast(v0, dir, hitinfo, layer_mask)) hit_found = true; if (collider->rayCast(v0, dir, hitinfo, layer_mask)) hit_found = true;
} }
} }
if(m_pRootNode) { if (m_pRootNode) {
if(m_pRootNode->rayCast(v0, dir, hitinfo, layer_mask)) hit_found = true; if (m_pRootNode->rayCast(v0, dir, hitinfo, layer_mask)) hit_found = true;
} }
return hit_found; return hit_found;
} }
bool KROctree::sphereCast(const Vector3 &v0, const Vector3 &v1, float radius, HitInfo &hitinfo, unsigned int layer_mask) bool KROctree::sphereCast(const Vector3& v0, const Vector3& v1, float radius, HitInfo& hitinfo, unsigned int layer_mask)
{ {
bool hit_found = false; bool hit_found = false;
std::vector<KRCollider *> outer_colliders; std::vector<KRCollider*> outer_colliders;
for(std::set<KRNode *>::iterator outer_nodes_itr=m_outerSceneNodes.begin(); outer_nodes_itr != m_outerSceneNodes.end(); outer_nodes_itr++) { for (std::set<KRNode*>::iterator outer_nodes_itr = m_outerSceneNodes.begin(); outer_nodes_itr != m_outerSceneNodes.end(); outer_nodes_itr++) {
KRCollider *collider = dynamic_cast<KRCollider *>(*outer_nodes_itr); KRCollider* collider = dynamic_cast<KRCollider*>(*outer_nodes_itr);
if(collider) { if (collider) {
outer_colliders.push_back(collider); outer_colliders.push_back(collider);
} }
} }
for(std::vector<KRCollider *>::iterator itr=outer_colliders.begin(); itr != outer_colliders.end(); itr++) { for (std::vector<KRCollider*>::iterator itr = outer_colliders.begin(); itr != outer_colliders.end(); itr++) {
if((*itr)->sphereCast(v0, v1, radius, hitinfo, layer_mask)) hit_found = true; if ((*itr)->sphereCast(v0, v1, radius, hitinfo, layer_mask)) hit_found = true;
} }
if(m_pRootNode) { if (m_pRootNode) {
if(m_pRootNode->sphereCast(v0, v1, radius, hitinfo, layer_mask)) hit_found = true; if (m_pRootNode->sphereCast(v0, v1, radius, hitinfo, layer_mask)) hit_found = true;
} }
return hit_found; return hit_found;
} }

23
kraken/KROctree.h
View File

@@ -36,25 +36,26 @@
class KRNode; class KRNode;
class KROctree { class KROctree
{
public: public:
KROctree(); KROctree();
~KROctree(); ~KROctree();
void add(KRNode *pNode); void add(KRNode* pNode);
void remove(KRNode *pNode); void remove(KRNode* pNode);
void update(KRNode *pNode); void update(KRNode* pNode);
KROctreeNode *getRootNode(); KROctreeNode* getRootNode();
std::set<KRNode *> &getOuterSceneNodes(); std::set<KRNode*>& getOuterSceneNodes();
bool lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo, unsigned int layer_mask); bool lineCast(const Vector3& v0, const Vector3& v1, HitInfo& hitinfo, unsigned int layer_mask);
bool rayCast(const Vector3 &v0, const Vector3 &dir, HitInfo &hitinfo, unsigned int layer_mask); bool rayCast(const Vector3& v0, const Vector3& dir, HitInfo& hitinfo, unsigned int layer_mask);
bool sphereCast(const Vector3 &v0, const Vector3 &v1, float radius, HitInfo &hitinfo, unsigned int layer_mask); bool sphereCast(const Vector3& v0, const Vector3& v1, float radius, HitInfo& hitinfo, unsigned int layer_mask);
private: private:
KROctreeNode *m_pRootNode; KROctreeNode* m_pRootNode;
std::set<KRNode *> m_outerSceneNodes; std::set<KRNode*> m_outerSceneNodes;
void shrink(); void shrink();
}; };

124
kraken/KROctreeNode.cpp
View File

@@ -33,23 +33,27 @@
#include "KRNode.h" #include "KRNode.h"
#include "KRCollider.h" #include "KRCollider.h"
KROctreeNode::KROctreeNode(KROctreeNode *parent, const AABB &bounds) : m_bounds(bounds) KROctreeNode::KROctreeNode(KROctreeNode* parent, const AABB& bounds) : m_bounds(bounds)
{ {
m_parent = parent; m_parent = parent;
for(int i=0; i<8; i++) m_children[i] = NULL; for (int i = 0; i < 8; i++) {
m_children[i] = NULL;
}
m_occlusionQuery = 0; m_occlusionQuery = 0;
m_occlusionTested = false; m_occlusionTested = false;
m_activeQuery = false; m_activeQuery = false;
} }
KROctreeNode::KROctreeNode(KROctreeNode *parent, const AABB &bounds, int iChild, KROctreeNode *pChild) : m_bounds(bounds) KROctreeNode::KROctreeNode(KROctreeNode* parent, const AABB& bounds, int iChild, KROctreeNode* pChild) : m_bounds(bounds)
{ {
// This constructor is used when expanding the octree and replacing the root node with a new root that encapsulates it // This constructor is used when expanding the octree and replacing the root node with a new root that encapsulates it
m_parent = parent; m_parent = parent;
for(int i=0; i<8; i++) m_children[i] = NULL; for (int i = 0; i < 8; i++) {
m_children[i] = NULL;
}
m_children[iChild] = pChild; m_children[iChild] = pChild;
pChild->m_parent = this; pChild->m_parent = this;
@@ -60,13 +64,13 @@ KROctreeNode::KROctreeNode(KROctreeNode *parent, const AABB &bounds, int iChild,
KROctreeNode::~KROctreeNode() KROctreeNode::~KROctreeNode()
{ {
for(int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
if(m_children[i] != NULL) { if (m_children[i] != NULL) {
delete m_children[i]; delete m_children[i];
} }
} }
if(m_occlusionTested) { if (m_occlusionTested) {
GLDEBUG(glDeleteQueriesEXT(1, &m_occlusionQuery)); GLDEBUG(glDeleteQueriesEXT(1, &m_occlusionQuery));
} }
} }
@@ -74,7 +78,7 @@ KROctreeNode::~KROctreeNode()
void KROctreeNode::beginOcclusionQuery() void KROctreeNode::beginOcclusionQuery()
{ {
if(!m_occlusionTested){ if (!m_occlusionTested) {
GLDEBUG(glGenQueriesEXT(1, &m_occlusionQuery)); GLDEBUG(glGenQueriesEXT(1, &m_occlusionQuery));
#if TARGET_OS_IPHONE || defined(ANDROID) #if TARGET_OS_IPHONE || defined(ANDROID)
GLDEBUG(glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, m_occlusionQuery)); GLDEBUG(glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, m_occlusionQuery));
@@ -88,7 +92,7 @@ void KROctreeNode::beginOcclusionQuery()
void KROctreeNode::endOcclusionQuery() void KROctreeNode::endOcclusionQuery()
{ {
if(m_activeQuery) { if (m_activeQuery) {
// Only end a query if we started one // Only end a query if we started one
#if TARGET_OS_IPHONE || defined(ANDROID) #if TARGET_OS_IPHONE || defined(ANDROID)
GLDEBUG(glEndQueryEXT(GL_ANY_SAMPLES_PASSED_EXT)); GLDEBUG(glEndQueryEXT(GL_ANY_SAMPLES_PASSED_EXT));
@@ -104,14 +108,14 @@ AABB KROctreeNode::getBounds()
return m_bounds; return m_bounds;
} }
void KROctreeNode::add(KRNode *pNode) void KROctreeNode::add(KRNode* pNode)
{ {
int iChild = getChildIndex(pNode); int iChild = getChildIndex(pNode);
if(iChild == -1) { if (iChild == -1) {
m_sceneNodes.insert(pNode); m_sceneNodes.insert(pNode);
pNode->addToOctreeNode(this); pNode->addToOctreeNode(this);
} else { } else {
if(m_children[iChild] == NULL) { if (m_children[iChild] == NULL) {
m_children[iChild] = new KROctreeNode(this, getChildBounds(iChild)); m_children[iChild] = new KROctreeNode(this, getChildBounds(iChild));
} }
m_children[iChild]->add(pNode); m_children[iChild]->add(pNode);
@@ -134,10 +138,10 @@ AABB KROctreeNode::getChildBounds(int iChild)
); );
} }
int KROctreeNode::getChildIndex(KRNode *pNode) int KROctreeNode::getChildIndex(KRNode* pNode)
{ {
for(int iChild=0; iChild < 8; iChild++) { for (int iChild = 0; iChild < 8; iChild++) {
if(getChildBounds(iChild).contains(pNode->getBounds())) { if (getChildBounds(iChild).contains(pNode->getBounds())) {
return iChild; return iChild;
} }
} }
@@ -146,9 +150,9 @@ int KROctreeNode::getChildIndex(KRNode *pNode)
void KROctreeNode::trim() void KROctreeNode::trim()
{ {
for(int iChild = 0; iChild < 8; iChild++) { for (int iChild = 0; iChild < 8; iChild++) {
if(m_children[iChild]) { if (m_children[iChild]) {
if(m_children[iChild]->isEmpty()) { if (m_children[iChild]->isEmpty()) {
delete m_children[iChild]; delete m_children[iChild];
m_children[iChild] = NULL; m_children[iChild] = NULL;
} }
@@ -156,20 +160,20 @@ void KROctreeNode::trim()
} }
} }
void KROctreeNode::remove(KRNode *pNode) void KROctreeNode::remove(KRNode* pNode)
{ {
m_sceneNodes.erase(pNode); m_sceneNodes.erase(pNode);
} }
void KROctreeNode::update(KRNode *pNode) void KROctreeNode::update(KRNode* pNode)
{ {
} }
bool KROctreeNode::isEmpty() const bool KROctreeNode::isEmpty() const
{ {
for(int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
if(m_children[i]) { if (m_children[i]) {
return false; return false;
} }
} }
@@ -179,21 +183,21 @@ bool KROctreeNode::isEmpty() const
bool KROctreeNode::canShrinkRoot() const bool KROctreeNode::canShrinkRoot() const
{ {
int cChildren = 0; int cChildren = 0;
for(int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
if(m_children[i]) { if (m_children[i]) {
cChildren++; cChildren++;
} }
} }
return cChildren <= 1 && m_sceneNodes.empty(); return cChildren <= 1 && m_sceneNodes.empty();
} }
KROctreeNode *KROctreeNode::stripChild() KROctreeNode* KROctreeNode::stripChild()
{ {
// Return the first found child and update its reference to NULL so that the destructor will not free it. This is used for shrinking the octree // Return the first found child and update its reference to NULL so that the destructor will not free it. This is used for shrinking the octree
// NOTE: The caller of this function will be responsible for freeing the child object. It is also possible to return a NULL // NOTE: The caller of this function will be responsible for freeing the child object. It is also possible to return a NULL
for(int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
if(m_children[i]) { if (m_children[i]) {
KROctreeNode *child = m_children[i]; KROctreeNode* child = m_children[i];
child->m_parent = NULL; child->m_parent = NULL;
m_children[i] = NULL; m_children[i] = NULL;
return child; return child;
@@ -203,40 +207,40 @@ KROctreeNode *KROctreeNode::stripChild()
} }
KROctreeNode *KROctreeNode::getParent() KROctreeNode* KROctreeNode::getParent()
{ {
return m_parent; return m_parent;
} }
KROctreeNode **KROctreeNode::getChildren() KROctreeNode** KROctreeNode::getChildren()
{ {
return m_children; return m_children;
} }
std::set<KRNode *> &KROctreeNode::getSceneNodes() std::set<KRNode*>& KROctreeNode::getSceneNodes()
{ {
return m_sceneNodes; return m_sceneNodes;
} }
bool KROctreeNode::lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo, unsigned int layer_mask) bool KROctreeNode::lineCast(const Vector3& v0, const Vector3& v1, HitInfo& hitinfo, unsigned int layer_mask)
{ {
bool hit_found = false; bool hit_found = false;
if(hitinfo.didHit() && v1 != hitinfo.getPosition()) { if (hitinfo.didHit() && v1 != hitinfo.getPosition()) {
// Optimization: If we already have a hit, only search for hits that are closer // Optimization: If we already have a hit, only search for hits that are closer
hit_found = lineCast(v0, hitinfo.getPosition(), hitinfo, layer_mask); hit_found = lineCast(v0, hitinfo.getPosition(), hitinfo, layer_mask);
} else { } else {
if(getBounds().intersectsLine(v0, v1)) { if (getBounds().intersectsLine(v0, v1)) {
for(std::set<KRNode *>::iterator nodes_itr=m_sceneNodes.begin(); nodes_itr != m_sceneNodes.end(); nodes_itr++) { for (std::set<KRNode*>::iterator nodes_itr = m_sceneNodes.begin(); nodes_itr != m_sceneNodes.end(); nodes_itr++) {
KRCollider *collider = dynamic_cast<KRCollider *>(*nodes_itr); KRCollider* collider = dynamic_cast<KRCollider*>(*nodes_itr);
if(collider) { if (collider) {
if(collider->lineCast(v0, v1, hitinfo, layer_mask)) hit_found = true; if (collider->lineCast(v0, v1, hitinfo, layer_mask)) hit_found = true;
} }
} }
for(int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
if(m_children[i]) { if (m_children[i]) {
if(m_children[i]->lineCast(v0, v1, hitinfo, layer_mask)) { if (m_children[i]->lineCast(v0, v1, hitinfo, layer_mask)) {
hit_found = true; hit_found = true;
} }
} }
@@ -247,24 +251,24 @@ bool KROctreeNode::lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitin
return hit_found; return hit_found;
} }
bool KROctreeNode::rayCast(const Vector3 &v0, const Vector3 &dir, HitInfo &hitinfo, unsigned int layer_mask) bool KROctreeNode::rayCast(const Vector3& v0, const Vector3& dir, HitInfo& hitinfo, unsigned int layer_mask)
{ {
bool hit_found = false; bool hit_found = false;
if(hitinfo.didHit()) { if (hitinfo.didHit()) {
// Optimization: If we already have a hit, only search for hits that are closer // Optimization: If we already have a hit, only search for hits that are closer
hit_found = lineCast(v0, hitinfo.getPosition(), hitinfo, layer_mask); // Note: This is purposefully lineCast as opposed to RayCast hit_found = lineCast(v0, hitinfo.getPosition(), hitinfo, layer_mask); // Note: This is purposefully lineCast as opposed to RayCast
} else { } else {
if(getBounds().intersectsRay(v0, dir)) { if (getBounds().intersectsRay(v0, dir)) {
for(std::set<KRNode *>::iterator nodes_itr=m_sceneNodes.begin(); nodes_itr != m_sceneNodes.end(); nodes_itr++) { for (std::set<KRNode*>::iterator nodes_itr = m_sceneNodes.begin(); nodes_itr != m_sceneNodes.end(); nodes_itr++) {
KRCollider *collider = dynamic_cast<KRCollider *>(*nodes_itr); KRCollider* collider = dynamic_cast<KRCollider*>(*nodes_itr);
if(collider) { if (collider) {
if(collider->rayCast(v0, dir, hitinfo, layer_mask)) hit_found = true; if (collider->rayCast(v0, dir, hitinfo, layer_mask)) hit_found = true;
} }
} }
for(int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
if(m_children[i]) { if (m_children[i]) {
if(m_children[i]->rayCast(v0, dir, hitinfo, layer_mask)) { if (m_children[i]->rayCast(v0, dir, hitinfo, layer_mask)) {
hit_found = true; hit_found = true;
} }
} }
@@ -275,7 +279,7 @@ bool KROctreeNode::rayCast(const Vector3 &v0, const Vector3 &dir, HitInfo &hitin
return hit_found; return hit_found;
} }
bool KROctreeNode::sphereCast(const Vector3 &v0, const Vector3 &v1, float radius, HitInfo &hitinfo, unsigned int layer_mask) bool KROctreeNode::sphereCast(const Vector3& v0, const Vector3& v1, float radius, HitInfo& hitinfo, unsigned int layer_mask)
{ {
bool hit_found = false; bool hit_found = false;
/* /*
@@ -289,18 +293,18 @@ bool KROctreeNode::sphereCast(const Vector3 &v0, const Vector3 &v1, float radius
AABB swept_bounds = AABB::Create(Vector3::Create(KRMIN(v0.x, v1.x) - radius, KRMIN(v0.y, v1.y) - radius, KRMIN(v0.z, v1.z) - radius), Vector3::Create(KRMAX(v0.x, v1.x) + radius, KRMAX(v0.y, v1.y) + radius, KRMAX(v0.z, v1.z) + radius)); AABB swept_bounds = AABB::Create(Vector3::Create(KRMIN(v0.x, v1.x) - radius, KRMIN(v0.y, v1.y) - radius, KRMIN(v0.z, v1.z) - radius), Vector3::Create(KRMAX(v0.x, v1.x) + radius, KRMAX(v0.y, v1.y) + radius, KRMAX(v0.z, v1.z) + radius));
// FINDME, TODO - Investigate AABB - swept sphere intersections or OBB - AABB intersections: "if(getBounds().intersectsSweptSphere(v0, v1, radius)) {" // FINDME, TODO - Investigate AABB - swept sphere intersections or OBB - AABB intersections: "if(getBounds().intersectsSweptSphere(v0, v1, radius)) {"
if(getBounds().intersects(swept_bounds)) { if (getBounds().intersects(swept_bounds)) {
for(std::set<KRNode *>::iterator nodes_itr=m_sceneNodes.begin(); nodes_itr != m_sceneNodes.end(); nodes_itr++) { for (std::set<KRNode*>::iterator nodes_itr = m_sceneNodes.begin(); nodes_itr != m_sceneNodes.end(); nodes_itr++) {
KRCollider *collider = dynamic_cast<KRCollider *>(*nodes_itr); KRCollider* collider = dynamic_cast<KRCollider*>(*nodes_itr);
if(collider) { if (collider) {
if(collider->sphereCast(v0, v1, radius, hitinfo, layer_mask)) hit_found = true; if (collider->sphereCast(v0, v1, radius, hitinfo, layer_mask)) hit_found = true;
} }
} }
for(int i=0; i<8; i++) { for (int i = 0; i < 8; i++) {
if(m_children[i]) { if (m_children[i]) {
if(m_children[i]->sphereCast(v0, v1, radius, hitinfo, layer_mask)) { if (m_children[i]->sphereCast(v0, v1, radius, hitinfo, layer_mask)) {
hit_found = true; hit_found = true;
} }
} }

37
kraken/KROctreeNode.h
View File

@@ -36,30 +36,31 @@
class KRNode; class KRNode;
class KROctreeNode { class KROctreeNode
{
public: public:
KROctreeNode(KROctreeNode *parent, const AABB &bounds); KROctreeNode(KROctreeNode* parent, const AABB& bounds);
KROctreeNode(KROctreeNode *parent, const AABB &bounds, int iChild, KROctreeNode *pChild); KROctreeNode(KROctreeNode* parent, const AABB& bounds, int iChild, KROctreeNode* pChild);
~KROctreeNode(); ~KROctreeNode();
KROctreeNode **getChildren(); KROctreeNode** getChildren();
std::set<KRNode *> &getSceneNodes(); std::set<KRNode*>& getSceneNodes();
void add(KRNode *pNode); void add(KRNode* pNode);
void remove(KRNode *pNode); void remove(KRNode* pNode);
void update(KRNode *pNode); void update(KRNode* pNode);
AABB getBounds(); AABB getBounds();
KROctreeNode *getParent(); KROctreeNode* getParent();
void setChildNode(int iChild, KROctreeNode *pChild); void setChildNode(int iChild, KROctreeNode* pChild);
int getChildIndex(KRNode *pNode); int getChildIndex(KRNode* pNode);
AABB getChildBounds(int iChild); AABB getChildBounds(int iChild);
void trim(); void trim();
bool isEmpty() const; bool isEmpty() const;
bool canShrinkRoot() const; bool canShrinkRoot() const;
KROctreeNode *stripChild(); KROctreeNode* stripChild();
void beginOcclusionQuery(); void beginOcclusionQuery();
void endOcclusionQuery(); void endOcclusionQuery();
@@ -69,16 +70,16 @@ public:
bool m_occlusionTested; bool m_occlusionTested;
bool m_activeQuery; bool m_activeQuery;
bool lineCast(const Vector3 &v0, const Vector3 &v1, HitInfo &hitinfo, unsigned int layer_mask); bool lineCast(const Vector3& v0, const Vector3& v1, HitInfo& hitinfo, unsigned int layer_mask);
bool rayCast(const Vector3 &v0, const Vector3 &dir, HitInfo &hitinfo, unsigned int layer_mask); bool rayCast(const Vector3& v0, const Vector3& dir, HitInfo& hitinfo, unsigned int layer_mask);
bool sphereCast(const Vector3 &v0, const Vector3 &v1, float radius, HitInfo &hitinfo, unsigned int layer_mask); bool sphereCast(const Vector3& v0, const Vector3& v1, float radius, HitInfo& hitinfo, unsigned int layer_mask);
private: private:
AABB m_bounds; AABB m_bounds;
KROctreeNode *m_parent; KROctreeNode* m_parent;
KROctreeNode *m_children[8]; KROctreeNode* m_children[8];
std::set<KRNode *>m_sceneNodes; std::set<KRNode*>m_sceneNodes;
}; };

8
kraken/KRParticleSystem.cpp
View File

@@ -30,7 +30,7 @@
// //
#include "KRParticleSystem.h" #include "KRParticleSystem.h"
KRParticleSystem::KRParticleSystem(KRScene &scene, std::string name) : KRNode(scene, name) KRParticleSystem::KRParticleSystem(KRScene& scene, std::string name) : KRNode(scene, name)
{ {
} }
@@ -40,14 +40,14 @@ KRParticleSystem::~KRParticleSystem()
} }
void KRParticleSystem::loadXML(tinyxml2::XMLElement *e) void KRParticleSystem::loadXML(tinyxml2::XMLElement* e)
{ {
} }
tinyxml2::XMLElement *KRParticleSystem::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRParticleSystem::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRNode::saveXML(parent); tinyxml2::XMLElement* e = KRNode::saveXML(parent);
return e; return e;
} }

9
kraken/KRParticleSystem.h
View File

@@ -33,20 +33,21 @@
#include "KRNode.h" #include "KRNode.h"
class KRParticleSystem : public KRNode { class KRParticleSystem : public KRNode
{
public: public:
virtual ~KRParticleSystem(); virtual ~KRParticleSystem();
virtual std::string getElementName() = 0; virtual std::string getElementName() = 0;
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual AABB getBounds() = 0; virtual AABB getBounds() = 0;
virtual void render(RenderInfo& ri) = 0; virtual void render(RenderInfo& ri) = 0;
protected: protected:
KRParticleSystem(KRScene &scene, std::string name); KRParticleSystem(KRScene& scene, std::string name);
private: private:
}; };

21
kraken/KRParticleSystemNewtonian.cpp
View File

@@ -35,7 +35,7 @@
#include "KRTexture.h" #include "KRTexture.h"
#include "KRContext.h" #include "KRContext.h"
KRParticleSystemNewtonian::KRParticleSystemNewtonian(KRScene &scene, std::string name) : KRParticleSystem(scene, name) KRParticleSystemNewtonian::KRParticleSystemNewtonian(KRScene& scene, std::string name) : KRParticleSystem(scene, name)
{ {
m_particlesAbsoluteTime = 0.0f; m_particlesAbsoluteTime = 0.0f;
} }
@@ -50,14 +50,14 @@ std::string KRParticleSystemNewtonian::getElementName()
return "newtonian_particles"; return "newtonian_particles";
} }
void KRParticleSystemNewtonian::loadXML(tinyxml2::XMLElement *e) void KRParticleSystemNewtonian::loadXML(tinyxml2::XMLElement* e)
{ {
KRParticleSystem::loadXML(e); KRParticleSystem::loadXML(e);
} }
tinyxml2::XMLElement *KRParticleSystemNewtonian::saveXML( tinyxml2::XMLNode *parent) tinyxml2::XMLElement* KRParticleSystemNewtonian::saveXML(tinyxml2::XMLNode* parent)
{ {
tinyxml2::XMLElement *e = KRParticleSystem::saveXML(parent); tinyxml2::XMLElement* e = KRParticleSystem::saveXML(parent);
return e; return e;
} }
@@ -78,15 +78,16 @@ bool KRParticleSystemNewtonian::hasPhysics()
return true; return true;
} }
void KRParticleSystemNewtonian::render(RenderInfo& ri) { void KRParticleSystemNewtonian::render(RenderInfo& ri)
{
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRNode::render(ri); KRNode::render(ri);
if(ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) { if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) {
if(ri.viewport.visible(getBounds())) { if (ri.viewport.visible(getBounds())) {
KRTexture *pParticleTexture = m_pContext->getTextureManager()->getTexture("flare"); KRTexture* pParticleTexture = m_pContext->getTextureManager()->getTexture("flare");
m_pContext->getTextureManager()->selectTexture(0, pParticleTexture, 0.0f, KRTexture::TEXTURE_USAGE_PARTICLE); m_pContext->getTextureManager()->selectTexture(0, pParticleTexture, 0.0f, KRTexture::TEXTURE_USAGE_PARTICLE);
int particle_count = 10000; int particle_count = 10000;
@@ -103,7 +104,7 @@ void KRParticleSystemNewtonian::render(RenderInfo& ri) {
info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA); info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA);
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline *pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
pParticleShader->setUniform(KRPipeline::Uniform::flare_size, 1.0f); pParticleShader->setUniform(KRPipeline::Uniform::flare_size, 1.0f);
pParticleShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pParticleShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);

9
kraken/KRParticleSystemNewtonian.h
View File

@@ -33,14 +33,15 @@
#include "KRParticleSystem.h" #include "KRParticleSystem.h"
class KRParticleSystemNewtonian : public KRParticleSystem { class KRParticleSystemNewtonian : public KRParticleSystem
{
public: public:
KRParticleSystemNewtonian(KRScene &scene, std::string name); KRParticleSystemNewtonian(KRScene& scene, std::string name);
virtual ~KRParticleSystemNewtonian(); virtual ~KRParticleSystemNewtonian();
virtual std::string getElementName(); virtual std::string getElementName();
virtual void loadXML(tinyxml2::XMLElement *e); virtual void loadXML(tinyxml2::XMLElement* e);
virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent);
virtual AABB getBounds(); virtual AABB getBounds();

81
kraken/KRPipeline.cpp
View File

@@ -39,7 +39,7 @@
#include "KRRenderPass.h" #include "KRRenderPass.h"
const char *KRPipeline::KRENGINE_UNIFORM_NAMES[] = { const char* KRPipeline::KRENGINE_UNIFORM_NAMES[] = {
"material_ambient", // Uniform::material_ambient "material_ambient", // Uniform::material_ambient
"material_diffuse", // Uniform::material_diffuse "material_diffuse", // Uniform::material_diffuse
"material_specular", // Uniform::material_specular "material_specular", // Uniform::material_specular
@@ -168,35 +168,27 @@ KRPipeline::KRPipeline(KRContext& context, KRSurface& surface, const PipelineInf
SpvReflectInterfaceVariable& input_var = *reflection->input_variables[i]; SpvReflectInterfaceVariable& input_var = *reflection->input_variables[i];
if (strcmp(input_var.name, "vertex_position") == 0) { if (strcmp(input_var.name, "vertex_position") == 0) {
attribute_locations[KRMesh::KRENGINE_ATTRIB_VERTEX] = input_var.location + 1; attribute_locations[KRMesh::KRENGINE_ATTRIB_VERTEX] = input_var.location + 1;
} } else if (strcmp(input_var.name, "vertex_normal") == 0) {
else if (strcmp(input_var.name, "vertex_normal") == 0) {
attribute_locations[KRMesh::KRENGINE_ATTRIB_NORMAL] = input_var.location + 1; attribute_locations[KRMesh::KRENGINE_ATTRIB_NORMAL] = input_var.location + 1;
} } else if (strcmp(input_var.name, "vertex_tangent") == 0) {
else if (strcmp(input_var.name, "vertex_tangent") == 0) {
attribute_locations[KRMesh::KRENGINE_ATTRIB_TANGENT] = input_var.location + 1; attribute_locations[KRMesh::KRENGINE_ATTRIB_TANGENT] = input_var.location + 1;
} } else if (strcmp(input_var.name, "vertex_uv") == 0) {
else if (strcmp(input_var.name, "vertex_uv") == 0) {
attribute_locations[KRMesh::KRENGINE_ATTRIB_TEXUVA] = input_var.location + 1; attribute_locations[KRMesh::KRENGINE_ATTRIB_TEXUVA] = input_var.location + 1;
} } else if (strcmp(input_var.name, "vertex_lightmap_uv") == 0) {
else if (strcmp(input_var.name, "vertex_lightmap_uv") == 0) {
attribute_locations[KRMesh::KRENGINE_ATTRIB_TEXUVB] = input_var.location + 1; attribute_locations[KRMesh::KRENGINE_ATTRIB_TEXUVB] = input_var.location + 1;
} } else if (strcmp(input_var.name, "bone_indexes") == 0) {
else if (strcmp(input_var.name, "bone_indexes") == 0) {
attribute_locations[KRMesh::KRENGINE_ATTRIB_BONEINDEXES] = input_var.location + 1; attribute_locations[KRMesh::KRENGINE_ATTRIB_BONEINDEXES] = input_var.location + 1;
} } else if (strcmp(input_var.name, "bone_weights") == 0) {
else if (strcmp(input_var.name, "bone_weights") == 0) {
attribute_locations[KRMesh::KRENGINE_ATTRIB_BONEWEIGHTS] = input_var.location + 1; attribute_locations[KRMesh::KRENGINE_ATTRIB_BONEWEIGHTS] = input_var.location + 1;
} }
} }
initPushConstantStage(ShaderStages::vertex, reflection); initPushConstantStage(ShaderStages::vertex, reflection);
} } else if (shader->getSubExtension().compare("frag") == 0) {
else if (shader->getSubExtension().compare("frag") == 0) {
stageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT; stageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
initPushConstantStage(ShaderStages::fragment, reflection); initPushConstantStage(ShaderStages::fragment, reflection);
} } else {
else {
// failed! TODO - Error handling // failed! TODO - Error handling
} }
stageInfo.module = shaderModule; stageInfo.module = shaderModule;
@@ -454,7 +446,8 @@ KRPipeline::KRPipeline(KRContext& context, KRSurface& surface, const PipelineInf
} }
} }
KRPipeline::~KRPipeline() { KRPipeline::~KRPipeline()
{
if (m_graphicsPipeline) { if (m_graphicsPipeline) {
// TODO: vkDestroyPipeline(device, m_graphicsPipeline, nullptr); // TODO: vkDestroyPipeline(device, m_graphicsPipeline, nullptr);
} }
@@ -468,7 +461,7 @@ KRPipeline::~KRPipeline() {
} }
if(getContext().getPipelineManager()->m_active_pipeline == this) { if (getContext().getPipelineManager()->m_active_pipeline == this) {
getContext().getPipelineManager()->m_active_pipeline = NULL; getContext().getPipelineManager()->m_active_pipeline = NULL;
} }
if (m_pushConstants[0].buffer) { if (m_pushConstants[0].buffer) {
@@ -492,8 +485,7 @@ void KRPipeline::initPushConstantStage(ShaderStages stage, const SpvReflectShade
for (int iUniform = 0; iUniform < kUniformCount; iUniform++) { for (int iUniform = 0; iUniform < kUniformCount; iUniform++) {
for (int iMember = 0; iMember < block.member_count; iMember++) { for (int iMember = 0; iMember < block.member_count; iMember++) {
const SpvReflectBlockVariable& member = block.members[iMember]; const SpvReflectBlockVariable& member = block.members[iMember];
if (stricmp(KRENGINE_UNIFORM_NAMES[iUniform], member.name) == 0) if (stricmp(KRENGINE_UNIFORM_NAMES[iUniform], member.name) == 0) {
{
pushConstants.offset[iUniform] = member.offset; pushConstants.offset[iUniform] = member.offset;
pushConstants.size[iUniform] = member.size; pushConstants.size[iUniform] = member.size;
} }
@@ -535,7 +527,7 @@ void KRPipeline::setUniform(Uniform location, int value)
} }
} }
void KRPipeline::setUniform(Uniform location, const Vector2 &value) void KRPipeline::setUniform(Uniform location, const Vector2& value)
{ {
for (PushConstantStageInfo& stageConstants : m_pushConstants) { for (PushConstantStageInfo& stageConstants : m_pushConstants) {
if (stageConstants.size[static_cast<size_t>(location)] == sizeof(value)) { if (stageConstants.size[static_cast<size_t>(location)] == sizeof(value)) {
@@ -544,7 +536,7 @@ void KRPipeline::setUniform(Uniform location, const Vector2 &value)
} }
} }
} }
void KRPipeline::setUniform(Uniform location, const Vector3 &value) void KRPipeline::setUniform(Uniform location, const Vector3& value)
{ {
for (PushConstantStageInfo& stageConstants : m_pushConstants) { for (PushConstantStageInfo& stageConstants : m_pushConstants) {
if (stageConstants.size[static_cast<size_t>(location)] == sizeof(value)) { if (stageConstants.size[static_cast<size_t>(location)] == sizeof(value)) {
@@ -554,7 +546,7 @@ void KRPipeline::setUniform(Uniform location, const Vector3 &value)
} }
} }
void KRPipeline::setUniform(Uniform location, const Vector4 &value) void KRPipeline::setUniform(Uniform location, const Vector4& value)
{ {
for (PushConstantStageInfo& stageConstants : m_pushConstants) { for (PushConstantStageInfo& stageConstants : m_pushConstants) {
if (stageConstants.size[static_cast<size_t>(location)] == sizeof(value)) { if (stageConstants.size[static_cast<size_t>(location)] == sizeof(value)) {
@@ -564,7 +556,7 @@ void KRPipeline::setUniform(Uniform location, const Vector4 &value)
} }
} }
void KRPipeline::setUniform(Uniform location, const Matrix4 &value) void KRPipeline::setUniform(Uniform location, const Matrix4& value)
{ {
for (PushConstantStageInfo& stageConstants : m_pushConstants) { for (PushConstantStageInfo& stageConstants : m_pushConstants) {
if (stageConstants.size[static_cast<size_t>(location)] == sizeof(value)) { if (stageConstants.size[static_cast<size_t>(location)] == sizeof(value)) {
@@ -582,7 +574,7 @@ void KRPipeline::setUniform(Uniform location, const Matrix4* value, const size_t
} }
} }
bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> *point_lights, const std::vector<KRDirectionalLight *> *directional_lights, const std::vector<KRSpotLight *> *spot_lights, const KRNode::RenderPass &renderPass) bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRNode::RenderPass& renderPass)
{ {
setUniform(Uniform::absolute_time, getContext().getAbsoluteTime()); setUniform(Uniform::absolute_time, getContext().getAbsoluteTime());
@@ -590,7 +582,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
//int light_point_count = 0; //int light_point_count = 0;
//int light_spot_count = 0; //int light_spot_count = 0;
// TODO - Need to support multiple lights and more light types in forward rendering // TODO - Need to support multiple lights and more light types in forward rendering
if(renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) { if (renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
if (directional_lights) { if (directional_lights) {
@@ -652,38 +644,38 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
//light_spot_count = spot_lights.size(); //light_spot_count = spot_lights.size();
} }
if(hasUniform(Uniform::camerapos_model_space)) { if (hasUniform(Uniform::camerapos_model_space)) {
Matrix4 inverseModelMatrix = matModel; Matrix4 inverseModelMatrix = matModel;
inverseModelMatrix.invert(); inverseModelMatrix.invert();
if(hasUniform(Uniform::camerapos_model_space)) { if (hasUniform(Uniform::camerapos_model_space)) {
// Transform location of camera to object space for calculation of specular halfVec // Transform location of camera to object space for calculation of specular halfVec
Vector3 cameraPosObject = Matrix4::Dot(inverseModelMatrix, viewport.getCameraPosition()); Vector3 cameraPosObject = Matrix4::Dot(inverseModelMatrix, viewport.getCameraPosition());
setUniform(Uniform::camerapos_model_space, cameraPosObject); setUniform(Uniform::camerapos_model_space, cameraPosObject);
} }
} }
if(hasUniform(Uniform::mvp) || hasUniform(KRPipeline::Uniform::invmvp)) { if (hasUniform(Uniform::mvp) || hasUniform(KRPipeline::Uniform::invmvp)) {
// Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram // Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
Matrix4 mvpMatrix = matModel * viewport.getViewProjectionMatrix(); Matrix4 mvpMatrix = matModel * viewport.getViewProjectionMatrix();
setUniform(Uniform::mvp, mvpMatrix); setUniform(Uniform::mvp, mvpMatrix);
if(hasUniform(KRPipeline::Uniform::invmvp)) { if (hasUniform(KRPipeline::Uniform::invmvp)) {
setUniform(KRPipeline::Uniform::invmvp, Matrix4::Invert(mvpMatrix)); setUniform(KRPipeline::Uniform::invmvp, Matrix4::Invert(mvpMatrix));
} }
} }
if(hasUniform(KRPipeline::Uniform::view_space_model_origin) || hasUniform(Uniform::model_view_inverse_transpose) || hasUniform(KRPipeline::Uniform::model_view)) { if (hasUniform(KRPipeline::Uniform::view_space_model_origin) || hasUniform(Uniform::model_view_inverse_transpose) || hasUniform(KRPipeline::Uniform::model_view)) {
Matrix4 matModelView = matModel * viewport.getViewMatrix(); Matrix4 matModelView = matModel * viewport.getViewMatrix();
setUniform(Uniform::model_view, matModelView); setUniform(Uniform::model_view, matModelView);
if(hasUniform(KRPipeline::Uniform::view_space_model_origin)) { if (hasUniform(KRPipeline::Uniform::view_space_model_origin)) {
Vector3 view_space_model_origin = Matrix4::Dot(matModelView, Vector3::Zero()); // Origin point of model space is the light source position. No perspective, so no w divide required Vector3 view_space_model_origin = Matrix4::Dot(matModelView, Vector3::Zero()); // Origin point of model space is the light source position. No perspective, so no w divide required
setUniform(Uniform::view_space_model_origin, view_space_model_origin); setUniform(Uniform::view_space_model_origin, view_space_model_origin);
} }
if(hasUniform(Uniform::model_view_inverse_transpose)) { if (hasUniform(Uniform::model_view_inverse_transpose)) {
Matrix4 matModelViewInverseTranspose = matModelView; Matrix4 matModelViewInverseTranspose = matModelView;
matModelViewInverseTranspose.transpose(); matModelViewInverseTranspose.transpose();
matModelViewInverseTranspose.invert(); matModelViewInverseTranspose.invert();
@@ -691,18 +683,18 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
} }
} }
if(hasUniform(Uniform::model_inverse_transpose)) { if (hasUniform(Uniform::model_inverse_transpose)) {
Matrix4 matModelInverseTranspose = matModel; Matrix4 matModelInverseTranspose = matModel;
matModelInverseTranspose.transpose(); matModelInverseTranspose.transpose();
matModelInverseTranspose.invert(); matModelInverseTranspose.invert();
setUniform(Uniform::model_inverse_transpose, matModelInverseTranspose); setUniform(Uniform::model_inverse_transpose, matModelInverseTranspose);
} }
if(hasUniform(KRPipeline::Uniform::invp)) { if (hasUniform(KRPipeline::Uniform::invp)) {
setUniform(Uniform::invp, viewport.getInverseProjectionMatrix()); setUniform(Uniform::invp, viewport.getInverseProjectionMatrix());
} }
if(hasUniform(KRPipeline::Uniform::invmvp_no_translate)) { if (hasUniform(KRPipeline::Uniform::invmvp_no_translate)) {
Matrix4 matInvMVPNoTranslate = matModel * viewport.getViewMatrix();; Matrix4 matInvMVPNoTranslate = matModel * viewport.getViewMatrix();;
// Remove the translation // Remove the translation
matInvMVPNoTranslate.getPointer()[3] = 0; matInvMVPNoTranslate.getPointer()[3] = 0;
@@ -718,11 +710,11 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
} }
setUniform(Uniform::model_matrix, matModel); setUniform(Uniform::model_matrix, matModel);
if(hasUniform(Uniform::projection_matrix)) { if (hasUniform(Uniform::projection_matrix)) {
setUniform(Uniform::projection_matrix, viewport.getProjectionMatrix()); setUniform(Uniform::projection_matrix, viewport.getProjectionMatrix());
} }
if(hasUniform(Uniform::viewport)) { if (hasUniform(Uniform::viewport)) {
setUniform(Uniform::viewport, Vector4::Create( setUniform(Uniform::viewport, Vector4::Create(
(float)0.0, (float)0.0,
(float)0.0, (float)0.0,
@@ -732,7 +724,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
); );
} }
if(hasUniform(Uniform::viewport_downsample)) { if (hasUniform(Uniform::viewport_downsample)) {
setUniform(Uniform::viewport_downsample, camera.getDownsample()); setUniform(Uniform::viewport_downsample, camera.getDownsample());
} }
@@ -742,13 +734,13 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
setUniform(Uniform::fog_density, camera.settings.fog_density); setUniform(Uniform::fog_density, camera.settings.fog_density);
setUniform(Uniform::fog_color, camera.settings.fog_color); setUniform(Uniform::fog_color, camera.settings.fog_color);
if(hasUniform(Uniform::fog_scale)) { if (hasUniform(Uniform::fog_scale)) {
setUniform(Uniform::fog_scale, 1.0f / (camera.settings.fog_far - camera.settings.fog_near)); setUniform(Uniform::fog_scale, 1.0f / (camera.settings.fog_far - camera.settings.fog_near));
} }
if(hasUniform(Uniform::density_premultiplied_exponential)) { if (hasUniform(Uniform::density_premultiplied_exponential)) {
setUniform(Uniform::density_premultiplied_exponential, -camera.settings.fog_density * 1.442695f); // -fog_density / log(2) setUniform(Uniform::density_premultiplied_exponential, -camera.settings.fog_density * 1.442695f); // -fog_density / log(2)
} }
if(hasUniform(Uniform::density_premultiplied_squared)) { if (hasUniform(Uniform::density_premultiplied_squared)) {
setUniform(Uniform::density_premultiplied_squared, (float)(-camera.settings.fog_density * camera.settings.fog_density * 1.442695)); // -fog_density * fog_density / log(2) setUniform(Uniform::density_premultiplied_squared, (float)(-camera.settings.fog_density * camera.settings.fog_density * 1.442695)); // -fog_density * fog_density / log(2)
} }
@@ -785,7 +777,8 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
return true; return true;
} }
const char *KRPipeline::getKey() const { const char* KRPipeline::getKey() const
{
return m_szKey; return m_szKey;
} }

27
kraken/KRPipeline.h
View File

@@ -45,14 +45,16 @@ class KRRenderPass;
enum class ModelFormat : __uint8_t; enum class ModelFormat : __uint8_t;
struct SpvReflectShaderModule; struct SpvReflectShaderModule;
enum class CullMode : uint32_t { enum class CullMode : uint32_t
{
kCullBack = 0, kCullBack = 0,
kCullFront, kCullFront,
kCullNone kCullNone
}; };
// Note: RasterMode is likely to be refactored later to a bitfield // Note: RasterMode is likely to be refactored later to a bitfield
enum class RasterMode : uint32_t { enum class RasterMode : uint32_t
{
kOpaque = 0, kOpaque = 0,
/* /*
kOpaque is equivalent to: kOpaque is equivalent to:
@@ -173,7 +175,8 @@ enum class RasterMode : uint32_t {
*/ */
}; };
class PipelineInfo { class PipelineInfo
{
public: public:
const std::string* shader_name; const std::string* shader_name;
KRCamera* pCamera; KRCamera* pCamera;
@@ -204,16 +207,18 @@ public:
KRNode::RenderPass renderPass; KRNode::RenderPass renderPass;
}; };
class KRPipeline : public KRContextObject { class KRPipeline : public KRContextObject
{
public: public:
KRPipeline(KRContext& context, KRSurface& surface, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat); KRPipeline(KRContext& context, KRSurface& surface, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat);
virtual ~KRPipeline(); virtual ~KRPipeline();
const char *getKey() const; const char* getKey() const;
bool bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> *point_lights, const std::vector<KRDirectionalLight *> *directional_lights, const std::vector<KRSpotLight *>*spot_lights, const KRNode::RenderPass &renderPass); bool bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRNode::RenderPass& renderPass);
enum class Uniform : uint8_t { enum class Uniform : uint8_t
{
material_ambient = 0, material_ambient = 0,
material_diffuse, material_diffuse,
material_specular, material_specular,
@@ -301,10 +306,10 @@ public:
bool hasUniform(Uniform location) const; bool hasUniform(Uniform location) const;
void setUniform(Uniform location, float value); void setUniform(Uniform location, float value);
void setUniform(Uniform location, int value); void setUniform(Uniform location, int value);
void setUniform(Uniform location, const Vector2 &value); void setUniform(Uniform location, const Vector2& value);
void setUniform(Uniform location, const Vector3 &value); void setUniform(Uniform location, const Vector3& value);
void setUniform(Uniform location, const Vector4 &value); void setUniform(Uniform location, const Vector4& value);
void setUniform(Uniform location, const Matrix4 &value); void setUniform(Uniform location, const Matrix4& value);
void setUniform(Uniform location, const Matrix4* value, const size_t count); void setUniform(Uniform location, const Matrix4* value, const size_t count);
VkPipeline& getPipeline(); VkPipeline& getPipeline();

12
kraken/KRPipelineManager.cpp
View File

@@ -44,20 +44,21 @@
using namespace std; using namespace std;
KRPipelineManager::KRPipelineManager(KRContext &context) : KRContextObject(context) { KRPipelineManager::KRPipelineManager(KRContext& context) : KRContextObject(context)
{
m_active_pipeline = NULL; m_active_pipeline = NULL;
#ifndef ANDROID #ifndef ANDROID
bool success = glslang::InitializeProcess(); bool success = glslang::InitializeProcess();
if (success) { if (success) {
printf("GLSLang Initialized.\n"); printf("GLSLang Initialized.\n");
} } else {
else {
printf("Failed to initialize GLSLang.\n"); printf("Failed to initialize GLSLang.\n");
} }
#endif // ANDROID #endif // ANDROID
} }
KRPipelineManager::~KRPipelineManager() { KRPipelineManager::~KRPipelineManager()
{
#ifndef ANDROID #ifndef ANDROID
glslang::FinalizeProcess(); glslang::FinalizeProcess();
#endif // ANDROID #endif // ANDROID
@@ -294,7 +295,8 @@ KRPipeline *KRPipelineManager::getPipeline(KRSurface& surface, const PipelineInf
} }
*/ */
size_t KRPipelineManager::getPipelineHandlesUsed() { size_t KRPipelineManager::getPipelineHandlesUsed()
{
return m_pipelines.size(); return m_pipelines.size();
} }

7
kraken/KRPipelineManager.h
View File

@@ -48,10 +48,11 @@ class KRPipeline;
class PipelineInfo; class PipelineInfo;
class KRCamera; class KRCamera;
class KRPipelineManager : public KRContextObject { class KRPipelineManager : public KRContextObject
{
public: public:
KRPipelineManager(KRContext &context); KRPipelineManager(KRContext& context);
virtual ~KRPipelineManager(); virtual ~KRPipelineManager();
KRPipeline* get(const char* szKey); KRPipeline* get(const char* szKey);
@@ -59,7 +60,7 @@ public:
size_t getPipelineHandlesUsed(); size_t getPipelineHandlesUsed();
KRPipeline *m_active_pipeline; KRPipeline* m_active_pipeline;
private: private:
typedef std::map<std::pair<std::string, std::vector<int> >, KRPipeline*> PipelineMap; typedef std::map<std::pair<std::string, std::vector<int> >, KRPipeline*> PipelineMap;

59
kraken/KRPointLight.cpp
View File

@@ -42,7 +42,7 @@ void KRPointLight::InitNodeInfo(KrNodeInfo* nodeInfo)
// No additional members // No additional members
} }
KRPointLight::KRPointLight(KRScene &scene, std::string name) : KRLight(scene, name) KRPointLight::KRPointLight(KRScene& scene, std::string name) : KRLight(scene, name)
{ {
m_sphereVertices = NULL; m_sphereVertices = NULL;
m_cVertices = 0; m_cVertices = 0;
@@ -50,19 +50,21 @@ KRPointLight::KRPointLight(KRScene &scene, std::string name) : KRLight(scene, na
KRPointLight::~KRPointLight() KRPointLight::~KRPointLight()
{ {
if(m_sphereVertices) { if (m_sphereVertices) {
delete m_sphereVertices; delete m_sphereVertices;
m_cVertices = 0; m_cVertices = 0;
} }
} }
std::string KRPointLight::getElementName() { std::string KRPointLight::getElementName()
{
return "point_light"; return "point_light";
} }
AABB KRPointLight::getBounds() { AABB KRPointLight::getBounds()
{
float influence_radius = m_decayStart - sqrt(m_intensity * 0.01f) / sqrt(KRLIGHT_MIN_INFLUENCE); float influence_radius = m_decayStart - sqrt(m_intensity * 0.01f) / sqrt(KRLIGHT_MIN_INFLUENCE);
if(influence_radius < m_flareOcclusionSize) { if (influence_radius < m_flareOcclusionSize) {
influence_radius = m_flareOcclusionSize; influence_radius = m_flareOcclusionSize;
} }
return AABB::Create(Vector3::Create(-influence_radius), Vector3::Create(influence_radius), getModelMatrix()); return AABB::Create(Vector3::Create(-influence_radius), Vector3::Create(influence_radius), getModelMatrix());
@@ -70,16 +72,16 @@ AABB KRPointLight::getBounds() {
void KRPointLight::render(RenderInfo& ri) void KRPointLight::render(RenderInfo& ri)
{ {
if(m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return; if (m_lod_visible <= LOD_VISIBILITY_PRESTREAM) return;
KRLight::render(ri); KRLight::render(ri);
bool bVisualize = ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.bShowDeferred; bool bVisualize = ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.bShowDeferred;
if(ri.renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS || bVisualize) { if (ri.renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS || bVisualize) {
// Lights are rendered on the second pass of the deferred renderer // Lights are rendered on the second pass of the deferred renderer
std::vector<KRPointLight *> this_light; std::vector<KRPointLight*> this_light;
this_light.push_back(this); this_light.push_back(this);
Vector3 light_position = getLocalTranslation(); Vector3 light_position = getLocalTranslation();
@@ -90,7 +92,7 @@ void KRPointLight::render(RenderInfo& ri)
sphereModelMatrix.scale(influence_radius); sphereModelMatrix.scale(influence_radius);
sphereModelMatrix.translate(light_position.x, light_position.y, light_position.z); sphereModelMatrix.translate(light_position.x, light_position.y, light_position.z);
if(ri.viewport.visible(getBounds())) { // Cull out any lights not within the view frustrum if (ri.viewport.visible(getBounds())) { // Cull out any lights not within the view frustrum
Vector3 view_light_position = Matrix4::Dot(ri.viewport.getViewMatrix(), light_position); Vector3 view_light_position = Matrix4::Dot(ri.viewport.getViewMatrix(), light_position);
@@ -104,14 +106,13 @@ void KRPointLight::render(RenderInfo& ri)
info.renderPass = ri.renderPass; info.renderPass = ri.renderPass;
if (bInsideLight) { if (bInsideLight) {
info.rasterMode = bVisualize ? RasterMode::kAdditiveNoTest : RasterMode::kAlphaBlendNoTest; info.rasterMode = bVisualize ? RasterMode::kAdditiveNoTest : RasterMode::kAlphaBlendNoTest;
} } else {
else {
info.rasterMode = bVisualize ? RasterMode::kAdditive : RasterMode::kAlphaBlend; info.rasterMode = bVisualize ? RasterMode::kAdditive : RasterMode::kAlphaBlend;
} }
info.vertexAttributes = bInsideLight ? m_pContext->getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES.getVertexAttributes() : 1 << KRMesh::KRENGINE_ATTRIB_VERTEX; info.vertexAttributes = bInsideLight ? m_pContext->getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES.getVertexAttributes() : 1 << KRMesh::KRENGINE_ATTRIB_VERTEX;
info.modelFormat = bInsideLight ? ModelFormat::KRENGINE_MODEL_FORMAT_STRIP : ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES; info.modelFormat = bInsideLight ? ModelFormat::KRENGINE_MODEL_FORMAT_STRIP : ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline* pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->setUniform(KRPipeline::Uniform::light_color, m_color); pShader->setUniform(KRPipeline::Uniform::light_color, m_color);
pShader->setUniform(KRPipeline::Uniform::light_intensity, m_intensity * 0.01f); pShader->setUniform(KRPipeline::Uniform::light_intensity, m_intensity * 0.01f);
pShader->setUniform(KRPipeline::Uniform::light_decay_start, getDecayStart()); pShader->setUniform(KRPipeline::Uniform::light_decay_start, getDecayStart());
@@ -119,7 +120,7 @@ void KRPointLight::render(RenderInfo& ri)
pShader->setUniform(KRPipeline::Uniform::light_position, light_position); pShader->setUniform(KRPipeline::Uniform::light_position, light_position);
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, sphereModelMatrix, &this_light, nullptr, nullptr, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, sphereModelMatrix, &this_light, nullptr, nullptr, ri.renderPass);
if(bInsideLight) { if (bInsideLight) {
// Render a full screen quad // Render a full screen quad
m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES, 1.0f); m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES, 1.0f);
vkCmdDraw(ri.commandBuffer, 4, 1, 0, 0); vkCmdDraw(ri.commandBuffer, 4, 1, 0, 0);
@@ -136,15 +137,16 @@ void KRPointLight::render(RenderInfo& ri)
} }
} }
void KRPointLight::generateMesh() { void KRPointLight::generateMesh()
{
// Create a triangular facet approximation to a sphere // Create a triangular facet approximation to a sphere
// Based on algorithm from Paul Bourke: http://paulbourke.net/miscellaneous/sphere_cylinder/ // Based on algorithm from Paul Bourke: http://paulbourke.net/miscellaneous/sphere_cylinder/
int iterations = 3; int iterations = 3;
int facet_count = (int)(pow(4, iterations) * 8); int facet_count = (int)(pow(4, iterations) * 8);
if(m_cVertices != facet_count * 3) { if (m_cVertices != facet_count * 3) {
if(m_sphereVertices) { if (m_sphereVertices) {
free(m_sphereVertices); free(m_sphereVertices);
m_sphereVertices = NULL; m_sphereVertices = NULL;
} }
@@ -152,12 +154,15 @@ void KRPointLight::generateMesh() {
m_cVertices = facet_count * 3; m_cVertices = facet_count * 3;
class Facet3 { class Facet3
{
public: public:
Facet3() { Facet3()
{
} }
~Facet3() { ~Facet3()
{
} }
Vector3 p1; Vector3 p1;
@@ -167,7 +172,7 @@ void KRPointLight::generateMesh() {
std::vector<Facet3> f = std::vector<Facet3>(facet_count); std::vector<Facet3> f = std::vector<Facet3>(facet_count);
int i,it; int i, it;
float a; float a;
Vector3 p[6] = { Vector3 p[6] = {
Vector3::Create(0,0,1), Vector3::Create(0,0,1),
@@ -178,12 +183,12 @@ void KRPointLight::generateMesh() {
Vector3::Create(-1,1,0) Vector3::Create(-1,1,0)
}; };
Vector3 pa,pb,pc; Vector3 pa, pb, pc;
int nt = 0,ntold; int nt = 0, ntold;
/* Create the level 0 object */ /* Create the level 0 object */
a = 1.0f / sqrtf(2.0f); a = 1.0f / sqrtf(2.0f);
for (i=0;i<6;i++) { for (i = 0; i < 6; i++) {
p[i].x *= a; p[i].x *= a;
p[i].y *= a; p[i].y *= a;
} }
@@ -198,9 +203,9 @@ void KRPointLight::generateMesh() {
nt = 8; nt = 8;
/* Bisect each edge and move to the surface of a unit sphere */ /* Bisect each edge and move to the surface of a unit sphere */
for (it=0;it<iterations;it++) { for (it = 0; it < iterations; it++) {
ntold = nt; ntold = nt;
for (i=0;i<ntold;i++) { for (i = 0; i < ntold; i++) {
pa.x = (f[i].p1.x + f[i].p2.x) / 2; pa.x = (f[i].p1.x + f[i].p2.x) / 2;
pa.y = (f[i].p1.y + f[i].p2.y) / 2; pa.y = (f[i].p1.y + f[i].p2.y) / 2;
pa.z = (f[i].p1.z + f[i].p2.z) / 2; pa.z = (f[i].p1.z + f[i].p2.z) / 2;
@@ -224,8 +229,8 @@ void KRPointLight::generateMesh() {
m_sphereVertices = (float*)malloc(sizeof(float) * m_cVertices * 3); m_sphereVertices = (float*)malloc(sizeof(float) * m_cVertices * 3);
assert(m_sphereVertices != NULL); assert(m_sphereVertices != NULL);
float*pDest = m_sphereVertices; float* pDest = m_sphereVertices;
for(int facet_index=0; facet_index < facet_count; facet_index++) { for (int facet_index = 0; facet_index < facet_count; facet_index++) {
*pDest++ = f[facet_index].p1.x; *pDest++ = f[facet_index].p1.x;
*pDest++ = f[facet_index].p1.y; *pDest++ = f[facet_index].p1.y;
*pDest++ = f[facet_index].p1.z; *pDest++ = f[facet_index].p1.z;

8
kraken/KRPointLight.h
View File

@@ -33,11 +33,11 @@
#include "KRLight.h" #include "KRLight.h"
class KRPointLight : public KRLight { class KRPointLight : public KRLight
{
public: public:
static void InitNodeInfo(KrNodeInfo* nodeInfo); static void InitNodeInfo(KrNodeInfo* nodeInfo);
KRPointLight(KRScene &scene, std::string name); KRPointLight(KRScene& scene, std::string name);
virtual ~KRPointLight(); virtual ~KRPointLight();
virtual std::string getElementName(); virtual std::string getElementName();
@@ -48,6 +48,6 @@ public:
private: private:
void generateMesh(); void generateMesh();
float *m_sphereVertices; float* m_sphereVertices;
int m_cVertices; int m_cVertices;
}; };

5
kraken/KRPresentationThread.cpp
View File

@@ -71,8 +71,7 @@ void KRPresentationThread::run()
std::chrono::microseconds sleep_duration(15000); std::chrono::microseconds sleep_duration(15000);
m_activeState = PresentThreadState::run; m_activeState = PresentThreadState::run;
while (m_requestedState != PresentThreadRequest::stop) while (m_requestedState != PresentThreadRequest::stop) {
{
switch (m_activeState) { switch (m_activeState) {
case PresentThreadState::pause: case PresentThreadState::pause:
case PresentThreadState::stop: case PresentThreadState::stop:
@@ -103,7 +102,7 @@ void KRPresentationThread::renderFrame()
unordered_map<KrSurfaceHandle, std::unique_ptr<KRSurface>>& surfaces = m_pContext->getSurfaceManager()->getSurfaces(); unordered_map<KrSurfaceHandle, std::unique_ptr<KRSurface>>& surfaces = m_pContext->getSurfaceManager()->getSurfaces();
KRSceneManager* sceneManager = m_pContext->getSceneManager(); KRSceneManager* sceneManager = m_pContext->getSceneManager();
KRScene *scene = sceneManager->getFirstScene(); KRScene* scene = sceneManager->getFirstScene();
for (auto surfaceItr = surfaces.begin(); surfaceItr != surfaces.end(); surfaceItr++) { for (auto surfaceItr = surfaces.begin(); surfaceItr != surfaces.end(); surfaceItr++) {
KRSurface& surface = *(*surfaceItr).second; KRSurface& surface = *(*surfaceItr).second;

4
kraken/KRRenderPass.cpp
View File

@@ -45,7 +45,7 @@ KRRenderPass::~KRRenderPass()
assert(m_renderPass == VK_NULL_HANDLE); assert(m_renderPass == VK_NULL_HANDLE);
} }
void KRRenderPass::create(KRDevice &device, VkFormat swapChainImageFormat, VkFormat depthImageFormat, const RenderPassInfo& info) void KRRenderPass::create(KRDevice& device, VkFormat swapChainImageFormat, VkFormat depthImageFormat, const RenderPassInfo& info)
{ {
if (m_renderPass) { if (m_renderPass) {
return; return;
@@ -110,7 +110,7 @@ void KRRenderPass::create(KRDevice &device, VkFormat swapChainImageFormat, VkFor
} }
} }
void KRRenderPass::destroy(KRDevice &device) void KRRenderPass::destroy(KRDevice& device)
{ {
if (m_renderPass) { if (m_renderPass) {
vkDestroyRenderPass(device.m_logicalDevice, m_renderPass, nullptr); vkDestroyRenderPass(device.m_logicalDevice, m_renderPass, nullptr);

4
kraken/KRRenderPass.h
View File

@@ -51,9 +51,9 @@ public:
void create(KRDevice& device, VkFormat swapChainImageFormat, VkFormat depthImageFormat, const RenderPassInfo& info); void create(KRDevice& device, VkFormat swapChainImageFormat, VkFormat depthImageFormat, const RenderPassInfo& info);
void destroy(KRDevice& device); void destroy(KRDevice& device);
void begin(VkCommandBuffer &commandBuffer, KRSurface& surface, const Vector4& clearColor); void begin(VkCommandBuffer& commandBuffer, KRSurface& surface, const Vector4& clearColor);
void end(VkCommandBuffer& commandBuffer); void end(VkCommandBuffer& commandBuffer);
// private: // private:
VkRenderPass m_renderPass; VkRenderPass m_renderPass;
}; };

92
kraken/KRRenderSettings.cpp
View File

@@ -106,7 +106,7 @@ KRRenderSettings::~KRRenderSettings()
} }
KRRenderSettings& KRRenderSettings::operator=(const KRRenderSettings &s) KRRenderSettings& KRRenderSettings::operator=(const KRRenderSettings& s)
{ {
siren_enable = s.siren_enable; siren_enable = s.siren_enable;
siren_enable_reverb = s.siren_enable_reverb; siren_enable_reverb = s.siren_enable_reverb;
@@ -118,54 +118,54 @@ KRRenderSettings& KRRenderSettings::operator=(const KRRenderSettings &s)
bEnableNormalMap = s.bEnableNormalMap; bEnableNormalMap = s.bEnableNormalMap;
bEnableSpecMap = s.bEnableSpecMap; bEnableSpecMap = s.bEnableSpecMap;
bEnableReflectionMap = s.bEnableReflectionMap; bEnableReflectionMap = s.bEnableReflectionMap;
bEnableReflection=s.bEnableReflection; bEnableReflection = s.bEnableReflection;
bEnableLightMap=s.bEnableLightMap; bEnableLightMap = s.bEnableLightMap;
bDebugPSSM=s.bDebugPSSM; bDebugPSSM = s.bDebugPSSM;
bShowShadowBuffer=s.bShowShadowBuffer; bShowShadowBuffer = s.bShowShadowBuffer;
bShowOctree=s.bShowOctree; bShowOctree = s.bShowOctree;
bShowDeferred=s.bShowDeferred; bShowDeferred = s.bShowDeferred;
bEnableAmbient=s.bEnableAmbient; bEnableAmbient = s.bEnableAmbient;
bEnableDiffuse=s.bEnableDiffuse; bEnableDiffuse = s.bEnableDiffuse;
bEnableSpecular=s.bEnableSpecular; bEnableSpecular = s.bEnableSpecular;
bEnableDeferredLighting=s.bEnableDeferredLighting; bEnableDeferredLighting = s.bEnableDeferredLighting;
light_intensity=s.light_intensity; light_intensity = s.light_intensity;
ambient_intensity=s.ambient_intensity; ambient_intensity = s.ambient_intensity;
perspective_fov=s.perspective_fov; perspective_fov = s.perspective_fov;
dof_quality=s.dof_quality; dof_quality = s.dof_quality;
dof_depth=s.dof_depth; dof_depth = s.dof_depth;
dof_falloff=s.dof_falloff; dof_falloff = s.dof_falloff;
bEnableFlash=s.bEnableFlash; bEnableFlash = s.bEnableFlash;
flash_intensity=s.flash_intensity; flash_intensity = s.flash_intensity;
flash_depth=s.flash_depth; flash_depth = s.flash_depth;
flash_falloff=s.flash_falloff; flash_falloff = s.flash_falloff;
bEnableVignette=s.bEnableVignette; bEnableVignette = s.bEnableVignette;
vignette_radius=s.vignette_radius; vignette_radius = s.vignette_radius;
vignette_falloff=s.vignette_falloff; vignette_falloff = s.vignette_falloff;
m_viewportSize=s.m_viewportSize; m_viewportSize = s.m_viewportSize;
m_cShadowBuffers=s.m_cShadowBuffers; m_cShadowBuffers = s.m_cShadowBuffers;
m_debug_text=s.m_debug_text; m_debug_text = s.m_debug_text;
volumetric_environment_enable=s.volumetric_environment_enable; volumetric_environment_enable = s.volumetric_environment_enable;
volumetric_environment_downsample=s.volumetric_environment_downsample; volumetric_environment_downsample = s.volumetric_environment_downsample;
volumetric_environment_max_distance=s.volumetric_environment_max_distance; volumetric_environment_max_distance = s.volumetric_environment_max_distance;
volumetric_environment_quality=s.volumetric_environment_quality; volumetric_environment_quality = s.volumetric_environment_quality;
volumetric_environment_intensity=s.volumetric_environment_intensity; volumetric_environment_intensity = s.volumetric_environment_intensity;
fog_near=s.fog_near; fog_near = s.fog_near;
fog_far=s.fog_far; fog_far = s.fog_far;
fog_density=s.fog_density; fog_density = s.fog_density;
fog_color=s.fog_color; fog_color = s.fog_color;
fog_type=s.fog_type; fog_type = s.fog_type;
dust_particle_intensity=s.dust_particle_intensity; dust_particle_intensity = s.dust_particle_intensity;
dust_particle_enable=s.dust_particle_enable; dust_particle_enable = s.dust_particle_enable;
perspective_nearz=s.perspective_nearz; perspective_nearz = s.perspective_nearz;
perspective_farz=s.perspective_farz; perspective_farz = s.perspective_farz;
debug_display = s.debug_display; debug_display = s.debug_display;
m_lodBias = s.m_lodBias; m_lodBias = s.m_lodBias;
@@ -176,11 +176,13 @@ KRRenderSettings& KRRenderSettings::operator=(const KRRenderSettings &s)
return *this; return *this;
} }
const Vector2 &KRRenderSettings::getViewportSize() { const Vector2& KRRenderSettings::getViewportSize()
{
return m_viewportSize; return m_viewportSize;
} }
void KRRenderSettings::setViewportSize(const Vector2 &size) { void KRRenderSettings::setViewportSize(const Vector2& size)
{
m_viewportSize = size; m_viewportSize = size;
} }
@@ -195,13 +197,13 @@ float KRRenderSettings::getPerspectiveFarZ()
void KRRenderSettings::setPerspectiveNear(float v) void KRRenderSettings::setPerspectiveNear(float v)
{ {
if(perspective_nearz != v) { if (perspective_nearz != v) {
perspective_nearz = v; perspective_nearz = v;
} }
} }
void KRRenderSettings::setPerpsectiveFarZ(float v) void KRRenderSettings::setPerpsectiveFarZ(float v)
{ {
if(perspective_farz != v) { if (perspective_farz != v) {
perspective_farz = v; perspective_farz = v;
} }
} }

12
kraken/KRRenderSettings.h
View File

@@ -33,16 +33,17 @@
#include "KREngine-common.h" #include "KREngine-common.h"
class KRRenderSettings { class KRRenderSettings
{
public: public:
KRRenderSettings(); KRRenderSettings();
~KRRenderSettings(); ~KRRenderSettings();
// Overload assignment operator // Overload assignment operator
KRRenderSettings& operator=(const KRRenderSettings &s); KRRenderSettings& operator=(const KRRenderSettings& s);
const Vector2 &getViewportSize(); const Vector2& getViewportSize();
void setViewportSize(const Vector2 &size); void setViewportSize(const Vector2& size);
float getPerspectiveNearZ(); float getPerspectiveNearZ();
float getPerspectiveFarZ(); float getPerspectiveFarZ();
@@ -106,7 +107,8 @@ public:
float perspective_nearz; float perspective_nearz;
float perspective_farz; float perspective_farz;
enum debug_display_type{ enum debug_display_type
{
KRENGINE_DEBUG_DISPLAY_NONE = 0, KRENGINE_DEBUG_DISPLAY_NONE = 0,
KRENGINE_DEBUG_DISPLAY_TIME, KRENGINE_DEBUG_DISPLAY_TIME,
KRENGINE_DEBUG_DISPLAY_MEMORY, KRENGINE_DEBUG_DISPLAY_MEMORY,

48
kraken/KRResource+blend.cpp
View File

@@ -36,12 +36,13 @@
#include "KRResource+blend.h" #include "KRResource+blend.h"
KRScene* KRResource::LoadBlenderScene(KRContext &context, const std::string& path) { KRScene* KRResource::LoadBlenderScene(KRContext& context, const std::string& path)
KRScene *pScene = new KRScene(context, KRResource::GetFileBase(path)); {
KRScene* pScene = new KRScene(context, KRResource::GetFileBase(path));
KRDataBlock data; KRDataBlock data;
if(data.load(path)) { if (data.load(path)) {
//KRBlendFile blend_file = KRBlendFile(pFile); //KRBlendFile blend_file = KRBlendFile(pFile);
} }
@@ -49,11 +50,12 @@ KRScene* KRResource::LoadBlenderScene(KRContext &context, const std::string& pat
} }
KRBlendFile::KRBlendFile(const void *pFile) { KRBlendFile::KRBlendFile(const void* pFile)
unsigned char *scan = (unsigned char *)pFile; {
unsigned char* scan = (unsigned char*)pFile;
readHeader(scan); readHeader(scan);
std::string block_code = ""; std::string block_code = "";
while(block_code != "ENDB") { while (block_code != "ENDB") {
Block b = Block(this, scan); Block b = Block(this, scan);
block_code = b.getCode(); block_code = b.getCode();
m_blocks.push_back(b); m_blocks.push_back(b);
@@ -62,21 +64,22 @@ KRBlendFile::KRBlendFile(const void *pFile) {
} }
} }
void KRBlendFile::readHeader(unsigned char *&scan) { void KRBlendFile::readHeader(unsigned char*& scan)
if(strncmp((char *)scan, "BLENDER", 7) != 0) { {
if (strncmp((char*)scan, "BLENDER", 7) != 0) {
// TODO throw exception // TODO throw exception
} }
scan += 7; scan += 7;
if(scan[0] == '_' && scan[1] == 'v') { if (scan[0] == '_' && scan[1] == 'v') {
// 32-bit, little-endian // 32-bit, little-endian
m_file_type = KRBLEND_LITTLEENDIAN_32BIT; m_file_type = KRBLEND_LITTLEENDIAN_32BIT;
} else if(scan[0] == '_' && scan[1] == 'V') { } else if (scan[0] == '_' && scan[1] == 'V') {
// 32-bit, bit-endian // 32-bit, bit-endian
m_file_type = KRBLEND_BIGENDIAN_32BIT; m_file_type = KRBLEND_BIGENDIAN_32BIT;
} else if(scan[0] == '-' && scan[1] == 'v') { } else if (scan[0] == '-' && scan[1] == 'v') {
// 64-bit, little-endian // 64-bit, little-endian
m_file_type = KRBLEND_LITTLEENDIAN_64BIT; m_file_type = KRBLEND_LITTLEENDIAN_64BIT;
} else if(scan[0] == '-' && scan[1] == 'V') { } else if (scan[0] == '-' && scan[1] == 'V') {
// 64-bit, big-endian // 64-bit, big-endian
m_file_type = KRBLEND_BIGENDIAN_64BIT; m_file_type = KRBLEND_BIGENDIAN_64BIT;
} else { } else {
@@ -85,7 +88,8 @@ void KRBlendFile::readHeader(unsigned char *&scan) {
scan += 5; // Skip and ignore version scan += 5; // Skip and ignore version
} }
__int32_t KRBlendFile::readInt(unsigned char *&scan) { __int32_t KRBlendFile::readInt(unsigned char*& scan)
{
__int32_t ret = 0; __int32_t ret = 0;
// read a 32-bit integer and increment scan // read a 32-bit integer and increment scan
@@ -104,7 +108,8 @@ __int32_t KRBlendFile::readInt(unsigned char *&scan) {
return ret; return ret;
} }
__int64_t KRBlendFile::readPointer(unsigned char *&scan) { __int64_t KRBlendFile::readPointer(unsigned char*& scan)
{
__int64_t ret = 0; __int64_t ret = 0;
// read a 32-bit integer and increment scan // read a 32-bit integer and increment scan
switch (m_file_type) { switch (m_file_type) {
@@ -131,12 +136,14 @@ __int64_t KRBlendFile::readPointer(unsigned char *&scan) {
return ret; return ret;
} }
KRBlendFile::~KRBlendFile() { KRBlendFile::~KRBlendFile()
{
} }
KRBlendFile::Block::Block(KRBlendFile *blendFile, unsigned char *&scan) { KRBlendFile::Block::Block(KRBlendFile* blendFile, unsigned char*& scan)
{
scan += (__int64_t)scan % 4; // Scan forward until the next 4-byte boundary scan += (__int64_t)scan % 4; // Scan forward until the next 4-byte boundary
char szBlock[5]; char szBlock[5];
szBlock[0] = *scan++; szBlock[0] = *scan++;
@@ -152,15 +159,18 @@ KRBlendFile::Block::Block(KRBlendFile *blendFile, unsigned char *&scan) {
m_data = scan; m_data = scan;
scan += m_dataSize; scan += m_dataSize;
} }
KRBlendFile::Block::~Block() { KRBlendFile::Block::~Block()
{
} }
std::string KRBlendFile::Block::getCode() { std::string KRBlendFile::Block::getCode()
{
return m_code; return m_code;
} }
int KRBlendFile::Block::getDataSize() { int KRBlendFile::Block::getDataSize()
{
return m_dataSize; return m_dataSize;
} }

21
kraken/KRResource+blend.h
View File

@@ -31,14 +31,16 @@
#pragma once #pragma once
class KRBlendFile { class KRBlendFile
{
public: public:
KRBlendFile(const void *pFile); KRBlendFile(const void* pFile);
~KRBlendFile(); ~KRBlendFile();
class Block { class Block
{
public: public:
Block(KRBlendFile *blendFile, unsigned char *&scan); Block(KRBlendFile* blendFile, unsigned char*& scan);
~Block(); ~Block();
std::string getCode(); std::string getCode();
@@ -49,20 +51,21 @@ public:
__int32_t m_sdna_index; __int32_t m_sdna_index;
__int32_t m_structure_count; __int32_t m_structure_count;
__int64_t m_prev_pointer; __int64_t m_prev_pointer;
unsigned char *m_data; unsigned char* m_data;
}; };
private: private:
enum file_type { enum file_type
{
KRBLEND_LITTLEENDIAN_32BIT, KRBLEND_LITTLEENDIAN_32BIT,
KRBLEND_LITTLEENDIAN_64BIT, KRBLEND_LITTLEENDIAN_64BIT,
KRBLEND_BIGENDIAN_32BIT, KRBLEND_BIGENDIAN_32BIT,
KRBLEND_BIGENDIAN_64BIT KRBLEND_BIGENDIAN_64BIT
} m_file_type; } m_file_type;
void readHeader(unsigned char *&scan); void readHeader(unsigned char*& scan);
__int32_t readInt(unsigned char *&scan); __int32_t readInt(unsigned char*& scan);
__int64_t readPointer(unsigned char *&scan); __int64_t readPointer(unsigned char*& scan);
std::vector<Block> m_blocks; std::vector<Block> m_blocks;
}; };

645
kraken/KRResource+fbx.cpp
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More