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

Renamed Vector3 class to KRVector3

Browse Source 
KRObjPacker project updated to use KREngine_osx framework rather than having a copy of the files

--HG--
extra : convert_revision : svn%3A7752d6cf-9f14-4ad2-affc-04f1e67b81a5/trunk%4015
This commit is contained in:
kearwood
2012-03-15 22:57:20 +00:00
parent a9786b80e6
commit bb38ede18e
28 changed files with 136 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
KREngine/KREngine/Classes/KRBoundingVolume.cpp
View File

@@ -34,21 +34,21 @@
#import "KRBoundingVolume.h"
KRBoundingVolume::KRBoundingVolume(const Vector3 *pVertices) {
KRBoundingVolume::KRBoundingVolume(const KRVector3 *pVertices) {
for(int iVertex=0; iVertex < 8; iVertex++) {
m_vertices[iVertex] = pVertices[iVertex];
}
}
KRBoundingVolume::KRBoundingVolume(const Vector3 &corner1, const Vector3 &corner2, const KRMat4 modelMatrix) {
m_vertices[0] = Vector3(corner1.x, corner1.y, corner1.z);
m_vertices[1] = Vector3(corner2.x, corner1.y, corner1.z);
m_vertices[2] = Vector3(corner2.x, corner2.y, corner1.z);
m_vertices[3] = Vector3(corner1.x, corner2.y, corner1.z);
m_vertices[4] = Vector3(corner1.x, corner1.y, corner2.z);
m_vertices[5] = Vector3(corner2.x, corner1.y, corner2.z);
m_vertices[6] = Vector3(corner2.x, corner2.y, corner2.z);
m_vertices[7] = Vector3(corner1.x, corner2.y, corner2.z);
KRBoundingVolume::KRBoundingVolume(const KRVector3 &corner1, const KRVector3 &corner2, const KRMat4 modelMatrix) {
m_vertices[0] = KRVector3(corner1.x, corner1.y, corner1.z);
m_vertices[1] = KRVector3(corner2.x, corner1.y, corner1.z);
m_vertices[2] = KRVector3(corner2.x, corner2.y, corner1.z);
m_vertices[3] = KRVector3(corner1.x, corner2.y, corner1.z);
m_vertices[4] = KRVector3(corner1.x, corner1.y, corner2.z);
m_vertices[5] = KRVector3(corner2.x, corner1.y, corner2.z);
m_vertices[6] = KRVector3(corner2.x, corner2.y, corner2.z);
m_vertices[7] = KRVector3(corner1.x, corner2.y, corner2.z);
for(int iVertex=0; iVertex < 8; iVertex++) {
m_vertices[iVertex] = modelMatrix.dot(m_vertices[iVertex]);
@@ -63,14 +63,14 @@ KRBoundingVolume::KRBoundingVolume(const KRMat4 &matView, GLfloat fov, GLfloat a
GLfloat r = tan(fov / 2.0);
m_vertices[0] = Vector3(-1.0 * r * nearz * aspect, -1.0 * r * nearz, -nearz);
m_vertices[1] = Vector3(1.0 * r * nearz * aspect, -1.0 * r * nearz, -nearz);
m_vertices[2] = Vector3(1.0 * r * nearz * aspect, 1.0 * r * nearz, -nearz);
m_vertices[3] = Vector3(-1.0 * r * nearz * aspect, 1.0 * r * nearz, -nearz);
m_vertices[4] = Vector3(-1.0 * r * farz * aspect, -1.0 * r * farz, -farz);
m_vertices[5] = Vector3(1.0 * r * farz * aspect, -1.0 * r * farz, -farz);
m_vertices[6] = Vector3(1.0 * r * farz * aspect, 1.0 * r * farz, -farz);
m_vertices[7] = Vector3(-1.0 * r * farz * aspect, 1.0 * r * farz, -farz);
m_vertices[0] = KRVector3(-1.0 * r * nearz * aspect, -1.0 * r * nearz, -nearz);
m_vertices[1] = KRVector3(1.0 * r * nearz * aspect, -1.0 * r * nearz, -nearz);
m_vertices[2] = KRVector3(1.0 * r * nearz * aspect, 1.0 * r * nearz, -nearz);
m_vertices[3] = KRVector3(-1.0 * r * nearz * aspect, 1.0 * r * nearz, -nearz);
m_vertices[4] = KRVector3(-1.0 * r * farz * aspect, -1.0 * r * farz, -farz);
m_vertices[5] = KRVector3(1.0 * r * farz * aspect, -1.0 * r * farz, -farz);
m_vertices[6] = KRVector3(1.0 * r * farz * aspect, 1.0 * r * farz, -farz);
m_vertices[7] = KRVector3(-1.0 * r * farz * aspect, 1.0 * r * farz, -farz);
for(int iVertex=0; iVertex < 8; iVertex++) {
m_vertices[iVertex] = invView.dot(m_vertices[iVertex]);
@@ -97,7 +97,7 @@ KRBoundingVolume& KRBoundingVolume::operator = ( const KRBoundingVolume& p ) {
KRBoundingVolume KRBoundingVolume::get_union(const KRBoundingVolume &p) const {
// Simple, non-aligned bounding box calculated that contains both volumes.
Vector3 minPoint = m_vertices[0], maxPoint = m_vertices[0];
KRVector3 minPoint = m_vertices[0], maxPoint = m_vertices[0];
for(int iVertex=1; iVertex < 8; iVertex++) {
if(m_vertices[iVertex].x < minPoint.x) {
minPoint.x = m_vertices[iVertex].x;
@@ -144,7 +144,7 @@ KRBoundingVolume KRBoundingVolume::get_union(const KRBoundingVolume &p) const {
bool KRBoundingVolume::test_intersect(const KRBoundingVolume &p) const {
// Simple, non-aligned bounding box intersection test
Vector3 minPoint = m_vertices[0], maxPoint = m_vertices[0], minPoint2 = p.m_vertices[0], maxPoint2 = p.m_vertices[0];
KRVector3 minPoint = m_vertices[0], maxPoint = m_vertices[0], minPoint2 = p.m_vertices[0], maxPoint2 = p.m_vertices[0];
for(int iVertex=1; iVertex < 8; iVertex++) {
if(m_vertices[iVertex].x < minPoint.x) {
minPoint.x = m_vertices[iVertex].x;
@@ -202,9 +202,9 @@ KRMat4 KRBoundingVolume::calcShadowProj(KRScene *pScene, GLfloat sun_yaw, GLfloa
shadowvp.invert();
shadowvp.scale(1.0, 1.0, -1.0);
Vector3 minPointFrustrum = shadowvp.dot(m_vertices[0]), maxPointFrustrum = minPointFrustrum;
KRVector3 minPointFrustrum = shadowvp.dot(m_vertices[0]), maxPointFrustrum = minPointFrustrum;
for(int iVertex=1; iVertex < 8; iVertex++) {
Vector3 v = shadowvp.dot(m_vertices[iVertex]);
KRVector3 v = shadowvp.dot(m_vertices[iVertex]);
if(v.x < minPointFrustrum.x) {
minPointFrustrum.x = v.x;
}
@@ -226,9 +226,9 @@ KRMat4 KRBoundingVolume::calcShadowProj(KRScene *pScene, GLfloat sun_yaw, GLfloa
}
Vector3 minPointScene = shadowvp.dot(sceneVolume.m_vertices[0]), maxPointScene = minPointScene;
KRVector3 minPointScene = shadowvp.dot(sceneVolume.m_vertices[0]), maxPointScene = minPointScene;
for(int iVertex=1; iVertex < 8; iVertex++) {
Vector3 v = shadowvp.dot(sceneVolume.m_vertices[iVertex]);
KRVector3 v = shadowvp.dot(sceneVolume.m_vertices[iVertex]);
if(v.x < minPointScene.x) {
minPointScene.x = v.x;
}
@@ -261,7 +261,7 @@ KRMat4 KRBoundingVolume::calcShadowProj(KRScene *pScene, GLfloat sun_yaw, GLfloa
GLfloat maxFrustrumDepth = maxPointFrustrum.z;
for(int i=0; i<8; i++) {
Vector3 v = shadowvp.dot(sceneVolume.m_vertices[i]);
KRVector3 v = shadowvp.dot(sceneVolume.m_vertices[i]);
if(i == 0) {
minPointFrustrum.z = v.z;
maxPointFrustrum.z = v.z;

6
KREngine/KREngine/Classes/KRBoundingVolume.h
View File

@@ -42,8 +42,8 @@ class KRScene;
class KRBoundingVolume {
public:
KRBoundingVolume(const Vector3 *pVertices);
KRBoundingVolume(const Vector3 &corner1, const Vector3 &corner2, const KRMat4 modelMatrix);
KRBoundingVolume(const KRVector3 *pVertices);
KRBoundingVolume(const KRVector3 &corner1, const KRVector3 &corner2, const KRMat4 modelMatrix);
KRBoundingVolume(const KRMat4 &matView, GLfloat fov, GLfloat aspect, GLfloat nearz, GLfloat farz);
~KRBoundingVolume();
@@ -55,7 +55,7 @@ public:
KRMat4 calcShadowProj(KRScene *pScene, GLfloat sun_yaw, GLfloat sun_pitch) const;
private:
Vector3 m_vertices[8];
KRVector3 m_vertices[8];
};
#endif

4
KREngine/KREngine/Classes/KREngine.h
View File

@@ -100,7 +100,7 @@ typedef enum KREngineParameterType {KRENGINE_PARAMETER_INT, KRENGINE_PARAMETER_F
- (BOOL)loadResource:(NSString *)path;
- (void)renderShadowBufferNumber: (int)iShadow ForScene: (KRScene *)pScene;
- (void)renderScene: (KRScene *)pScene WithViewMatrix: (KRMat4)viewMatrix LightDirection: (Vector3)lightDirection CameraPosition: (Vector3)cameraPosition;
- (void)renderScene: (KRScene *)pScene WithViewMatrix: (KRMat4)viewMatrix LightDirection: (KRVector3)lightDirection CameraPosition: (KRVector3)cameraPosition;
- (KRModelManager *)getModelManager;
- (void)invalidateShadowBuffers;
- (void)allocateShadowBuffers;
@@ -120,7 +120,7 @@ typedef enum KREngineParameterType {KRENGINE_PARAMETER_INT, KRENGINE_PARAMETER_F
-(void)setParameterValueWithName: (NSString *)name Value: (double)v;
- (void)renderScene: (KRScene *)pScene WithViewMatrix: (KRMat4)viewMatrix;
- (void)renderScene: (KRScene *)pScene WithPosition: (Vector3)position Yaw: (GLfloat)yaw Pitch: (GLfloat)pitch Roll: (GLfloat)roll;
- (void)renderScene: (KRScene *)pScene WithPosition: (KRVector3)position Yaw: (GLfloat)yaw Pitch: (GLfloat)pitch Roll: (GLfloat)roll;
- (void)setNearZ: (double)dNearZ;
- (void)setFarZ: (double)dFarZ;
- (void)setAspect: (double)dAspect;

30
KREngine/KREngine/Classes/KREngine.mm
View File

@@ -183,7 +183,7 @@ double const PI = 3.141592653589793f;
}
}
- (void)renderScene: (KRScene *)pScene WithPosition: (Vector3)position Yaw: (GLfloat)yaw Pitch: (GLfloat)pitch Roll: (GLfloat)roll
- (void)renderScene: (KRScene *)pScene WithPosition: (KRVector3)position Yaw: (GLfloat)yaw Pitch: (GLfloat)pitch Roll: (GLfloat)roll
{
KRMat4 viewMatrix;
viewMatrix.translate(-position.x, -position.y, -position.z);
@@ -198,9 +198,9 @@ double const PI = 3.141592653589793f;
KRMat4 invViewMatrix = viewMatrix;
invViewMatrix.invert();
Vector3 cameraPosition = invViewMatrix.dot(Vector3(0.0,0.0,0.0));
KRVector3 cameraPosition = invViewMatrix.dot(KRVector3(0.0,0.0,0.0));
Vector3 lightDirection(0.0, 0.0, 1.0);
KRVector3 lightDirection(0.0, 0.0, 1.0);
// ----- Render Model -----
KRMat4 shadowvp;
@@ -312,29 +312,29 @@ double const PI = 3.141592653589793f;
KRMat4 matInvShadow = shadowmvpmatrix[iShadow];
matInvShadow.invert();
Vector3 vertices[8];
vertices[0] = Vector3(-1.0, -1.0, 0.0);
vertices[1] = Vector3(1.0, -1.0, 0.0);
vertices[2] = Vector3(1.0, 1.0, 0.0);
vertices[3] = Vector3(-1.0, 1.0, 0.0);
vertices[4] = Vector3(-1.0, -1.0, 1.0);
vertices[5] = Vector3(1.0, -1.0, 1.0);
vertices[6] = Vector3(1.0, 1.0, 1.0);
vertices[7] = Vector3(-1.0, 1.0, 1.0);
KRVector3 vertices[8];
vertices[0] = KRVector3(-1.0, -1.0, 0.0);
vertices[1] = KRVector3(1.0, -1.0, 0.0);
vertices[2] = KRVector3(1.0, 1.0, 0.0);
vertices[3] = KRVector3(-1.0, 1.0, 0.0);
vertices[4] = KRVector3(-1.0, -1.0, 1.0);
vertices[5] = KRVector3(1.0, -1.0, 1.0);
vertices[6] = KRVector3(1.0, 1.0, 1.0);
vertices[7] = KRVector3(-1.0, 1.0, 1.0);
for(int iVertex=0; iVertex < 8; iVertex++) {
vertices[iVertex] = matInvShadow.dot(vertices[iVertex]);
}
Vector3 cameraPosition;
Vector3 lightDirection;
KRVector3 cameraPosition;
KRVector3 lightDirection;
KRBoundingVolume shadowVolume = KRBoundingVolume(vertices);
pScene->render(&m_camera, shadowVolume, m_pMaterialManager, true, shadowmvpmatrix[iShadow], cameraPosition, lightDirection, shadowmvpmatrix, NULL, 0);
glViewport(0, 0, 768, 1024);
}
- (void)renderScene: (KRScene *)pScene WithViewMatrix: (KRMat4)viewMatrix LightDirection: (Vector3)lightDirection CameraPosition: (Vector3)cameraPosition
- (void)renderScene: (KRScene *)pScene WithViewMatrix: (KRMat4)viewMatrix LightDirection: (KRVector3)lightDirection CameraPosition: (KRVector3)cameraPosition
{
glBindFramebuffer(GL_FRAMEBUFFER, compositeFramebuffer);

8
KREngine/KREngine/Classes/KRInstance.cpp
View File

@@ -48,7 +48,7 @@ KRModel *KRInstance::getModel() {
return m_pModel;
}
void KRInstance::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
void KRInstance::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
KRMat4 projectionMatrix;
if(!bRenderShadowMap) {
@@ -59,8 +59,8 @@ void KRInstance::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager,
// Transform location of camera to object space for calculation of specular halfVec
KRMat4 inverseModelMatrix = m_modelMatrix;
inverseModelMatrix.invert();
Vector3 cameraPosObject = inverseModelMatrix.dot(cameraPosition);
Vector3 lightDirObject = inverseModelMatrix.dot(lightDirection);
KRVector3 cameraPosObject = inverseModelMatrix.dot(cameraPosition);
KRVector3 lightDirObject = inverseModelMatrix.dot(lightDirection);
m_pModel->render(pCamera, pMaterialManager, bRenderShadowMap, mvpmatrix, cameraPosObject, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers);
@@ -68,5 +68,5 @@ void KRInstance::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager,
KRBoundingVolume KRInstance::getExtents() {
KRMesh *pMesh = m_pModel->getMesh();
return KRBoundingVolume(Vector3(pMesh->getMinX(), pMesh->getMinY(), pMesh->getMinZ()), Vector3(pMesh->getMaxX(), pMesh->getMaxY(), pMesh->getMaxZ()), m_modelMatrix);
return KRBoundingVolume(KRVector3(pMesh->getMinX(), pMesh->getMinY(), pMesh->getMinZ()), KRVector3(pMesh->getMaxX(), pMesh->getMaxY(), pMesh->getMaxZ()), m_modelMatrix);
}

2
KREngine/KREngine/Classes/KRInstance.h
View File

@@ -49,7 +49,7 @@ class KRInstance {
public:
KRInstance(KRModel *pModel, const KRMat4 modelMatrix);
~KRInstance();
void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
KRBoundingVolume getExtents();

4
KREngine/KREngine/Classes/KRMat4.cpp
View File

@@ -242,8 +242,8 @@ bool KRMat4::invert() {
}
/* Dot Product */
Vector3 KRMat4::dot(const Vector3 &v) const {
return Vector3(
KRVector3 KRMat4::dot(const KRVector3 &v) const {
return KRVector3(
v.x * (float)m_mat[0*4 + 0] + v.y * (float)m_mat[1*4 + 0] + v.z * (float)m_mat[2*4 + 0] + (float)m_mat[3*4 + 0],
v.x * (float)m_mat[0*4 + 1] + v.y * (float)m_mat[1*4 + 1] + v.z * (float)m_mat[2*4 + 1] + (float)m_mat[3*4 + 1],
v.x * (float)m_mat[0*4 + 2] + v.y * (float)m_mat[1*4 + 2] + v.z * (float)m_mat[2*4 + 2] + (float)m_mat[3*4 + 2]

2
KREngine/KREngine/Classes/KRMat4.h
View File

@@ -95,7 +95,7 @@ public:
void rotate(GLfloat angle, AXIS axis);
void bias();
bool invert();
Vector3 dot(const Vector3 &v) const;
KRVector3 dot(const KRVector3 &v) const;
};
#endif // KRMAT4_I

2
KREngine/KREngine/Classes/KRMaterial.cpp
View File

@@ -102,7 +102,7 @@ bool KRMaterial::isTransparent() {
return m_tr != 0.0;
}
void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
bool bSameMaterial = *prevBoundMaterial == this;
bool bDiffuseMap = m_pDiffuseMap != NULL && pCamera->bEnableDiffuseMap;

2
KREngine/KREngine/Classes/KRMaterial.h
View File

@@ -60,7 +60,7 @@ public:
void setTransparency(GLfloat a);
void setShininess(GLfloat s);
void bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
void bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
bool isTransparent();
char *getName();

4
KREngine/KREngine/Classes/KRMesh.cpp
View File

@@ -173,9 +173,9 @@ void KRMesh::renderSubmesh(int iSubmesh, int *iPrevBuffer) {
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_NORMAL, 3, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D)));
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TANGENT, 3, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(Vector3D)));
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TANGENT, 3, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(KRVector3D)));
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUV, 2, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(Vector3D) * 2));
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUV, 2, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(KRVector3D) * 2));
*iPrevBuffer = iBuffer;

6
KREngine/KREngine/Classes/KRMesh.h
View File

@@ -95,7 +95,7 @@ protected:
GLfloat x;
GLfloat y;
GLfloat z;
} Vertex3D, Vector3D;
} Vertex3D, KRVector3D;
typedef struct {
GLfloat u;
@@ -104,8 +104,8 @@ protected:
typedef struct {
Vertex3D vertex;
Vector3D normal;
Vector3D tangent;
KRVector3D normal;
KRVector3D tangent;
TexCoord texcoord;
} VertexData;

2
KREngine/KREngine/Classes/KRModel.cpp
View File

@@ -65,7 +65,7 @@ KRModel::~KRModel() {
}
void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
KRMaterial *pPrevBoundMaterial = NULL;
int iPrevBuffer = -1;
char szPrevShaderKey[128];

2
KREngine/KREngine/Classes/KRModel.h
View File

@@ -52,7 +52,7 @@ public:
KRModel(std::string path, KRMaterialManager *pMaterialManager);
~KRModel();
void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
KRMesh *getMesh();

2
KREngine/KREngine/Classes/KRScene.cpp
View File

@@ -52,7 +52,7 @@ KRInstance *KRScene::addInstance(KRModel *pModel, KRMat4 modelMatrix) {
m_instances.push_back(pInstance);
return pInstance;
}
void KRScene::render(KRCamera *pCamera, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
void KRScene::render(KRCamera *pCamera, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
if(cShadowBuffers > 0 && !bRenderShadowMap) {
glActiveTexture(GL_TEXTURE3);

2
KREngine/KREngine/Classes/KRScene.h
View File

@@ -49,7 +49,7 @@ public:
KRScene();
~KRScene();
KRInstance *addInstance(KRModel *pModel, KRMat4 modelMatrix);
void render(KRCamera *pCamera, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
void render(KRCamera *pCamera, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
KRBoundingVolume getExtents();
private:
vector<KRInstance *> m_instances;

4
KREngine/KREngine/Classes/KRShader.cpp
View File

@@ -122,14 +122,14 @@ KRShader::~KRShader() {
}
}
void KRShader::bind(KRCamera *pCamera, KRMat4 &mvpMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
void KRShader::bind(KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
glUseProgram(m_iProgram);
// Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
glUniformMatrix4fv(m_uniforms[KRENGINE_UNIFORM_MVP], 1, GL_FALSE, mvpMatrix.getPointer());
Vector3 nLightDir = lightDirection;
KRVector3 nLightDir = lightDirection;
nLightDir.normalize();
// Bind the light direction vector

2
KREngine/KREngine/Classes/KRShader.h
View File

@@ -51,7 +51,7 @@ public:
GLuint getProgram();
char *getKey();
void bind(KRCamera *pCamera, KRMat4 &mvpMatrix, Vector3 &cameraPosition, Vector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
void bind(KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
enum {
KRENGINE_ATTRIB_VERTEX,

36
KREngine/KREngine/Classes/KRVector3.cpp
View File

@@ -32,27 +32,27 @@
#include "KRVector3.h"
//default constructor
Vector3::Vector3()
KRVector3::KRVector3()
{
x = 0.0f;
y = 0.0f;
z = 0.0f;
}
Vector3::Vector3(float X = 0, float Y = 0, float Z = 0)
KRVector3::KRVector3(float X, float Y, float Z)
{
x = X;
y = Y;
z = Z;
}
Vector3::Vector3(const Vector3& p) {
KRVector3::KRVector3(const KRVector3& p) {
x = p.x;
y = p.y;
z = p.z;
}
Vector3& Vector3::operator = ( const Vector3& p ) {
KRVector3& KRVector3::operator = ( const KRVector3& p ) {
x = p.x;
y = p.y;
z = p.z;
@@ -60,44 +60,44 @@ Vector3& Vector3::operator = ( const Vector3& p ) {
return *this;
}
Vector3::~Vector3()
KRVector3::~KRVector3()
{
}
//calculate and return the magnitude of this vector
float Vector3::GetMagnitude()
float KRVector3::GetMagnitude()
{
return sqrtf(x * x + y * y + z * z);
}
//multiply this vector by a scalar
Vector3 Vector3::operator*(float num) const
KRVector3 KRVector3::operator*(float num) const
{
return Vector3(x * num, y * num, z * num);
return KRVector3(x * num, y * num, z * num);
}
//pass in a vector, pass in a scalar, return the product
/*
Vector3 Vector3::operator*(float num, Vector3 const &vec)
KRVector3 KRVector3::operator*(float num, KRVector3 const &vec)
{
return Vector3(vec.x * num, vec.y * num, vec.z * num);
return KRVector3(vec.x * num, vec.y * num, vec.z * num);
}
*/
//add two vectors
Vector3 Vector3::operator+(const Vector3 &vec) const
KRVector3 KRVector3::operator+(const KRVector3 &vec) const
{
return Vector3(x + vec.x, y + vec.y, z + vec.z);
return KRVector3(x + vec.x, y + vec.y, z + vec.z);
}
//subtract two vectors
Vector3 Vector3::operator-(const Vector3 &vec) const
KRVector3 KRVector3::operator-(const KRVector3 &vec) const
{
return Vector3(x - vec.x, y - vec.y, z - vec.z);
return KRVector3(x - vec.x, y - vec.y, z - vec.z);
}
//normalize this vector
void Vector3::normalize()
void KRVector3::normalize()
{
float magnitude = sqrtf(x * x + y * y + z * z);
x /= magnitude;
@@ -106,15 +106,15 @@ void Vector3::normalize()
}
//calculate and return dot product
float Vector3::dot(const Vector3 &vec) const
float KRVector3::dot(const KRVector3 &vec) const
{
return x * vec.x + y * vec.y + z * vec.z;
}
//calculate and return cross product
Vector3 Vector3::cross(const Vector3 &vec) const
KRVector3 KRVector3::cross(const KRVector3 &vec) const
{
return Vector3(y * vec.z - z * vec.y,
return KRVector3(y * vec.z - z * vec.y,
z * vec.x - x * vec.z,
x * vec.y - y * vec.x);
}

24
KREngine/KREngine/Classes/KRVector3.h
View File

@@ -33,7 +33,7 @@
#define KRVECTOR3
#include <math.h>
class Vector3
class KRVector3
{
public:
@@ -41,37 +41,37 @@ public:
//default constructor
Vector3(float X, float Y, float Z);
Vector3();
~Vector3();
KRVector3(float X = 0, float Y = 0, float Z = 0);
KRVector3();
~KRVector3();
Vector3(const Vector3& p);
Vector3& operator = ( const Vector3& p );
KRVector3(const KRVector3& p);
KRVector3& operator = ( const KRVector3& p );
//calculate and return the magnitude of this vector
float GetMagnitude();
//multiply this vector by a scalar
Vector3 operator*(float num) const;
KRVector3 operator*(float num) const;
//pass in a vector, pass in a scalar, return the product
//friend Vector3 operator*(float num, Vector3 const &vec);
//friend KRVector3 operator*(float num, KRVector3 const &vec);
//add two vectors
Vector3 operator+(const Vector3 &vec) const;
KRVector3 operator+(const KRVector3 &vec) const;
//subtract two vectors
Vector3 operator-(const Vector3 &vec) const;
KRVector3 operator-(const KRVector3 &vec) const;
//normalize this vector
void normalize();
//calculate and return dot product
float dot(const Vector3 &vec) const;
float dot(const KRVector3 &vec) const;
//calculate and return cross product
Vector3 cross(const Vector3 &vec) const;
KRVector3 cross(const KRVector3 &vec) const;
};
#endif