Merge pull request #138 from beasterio/rpr

beasterio · web-flow · commit 7ab79d0a765e · 2017-03-30T13:37:59.000+03:00
fix RPR get* methods.
diff --git a/Rpr/RadeonProRender.cpp b/Rpr/RadeonProRender.cpp
@@ -922,7 +922,7 @@ rpr_int rprShapeSetDisplacementScale(rpr_shape shape, rpr_float minscale, rpr_fl
 
 rpr_int rprShapeSetObjectGroupID(rpr_shape shape, rpr_uint objectGroupID)
 {
-	UNIMLEMENTED_FUNCTION
+    UNSUPPORTED_FUNCTION
 }
 
 rpr_int rprShapeSetDisplacementImage(rpr_shape shape, rpr_image image)
@@ -1048,6 +1048,7 @@ rpr_int rprShapeGetInfo(rpr_shape in_shape, rpr_shape_info in_info, size_t in_si
     case RPR_SHAPE_TRANSFORM:
     {
         RadeonRays::matrix value = shape->GetTransform();
+        value = value.transpose();
         size_ret = sizeof(value);
         data.resize(size_ret);
         memcpy(&data[0], &value, size_ret);
@@ -1144,18 +1145,16 @@ rpr_int rprMeshGetInfo(rpr_shape in_mesh, rpr_mesh_info in_mesh_info, size_t in_
     }
     case RPR_MESH_VERTEX_ARRAY:
     {
-        const RadeonRays::float3* value = mesh->GetVertexData();
-        size_ret = sizeof(RadeonRays::float3) * mesh->GetVertexCount();
+        size_ret = sizeof(float) * 3 * mesh->GetVertexCount();
         data.resize(size_ret);
-        memcpy(&data[0], &value, size_ret);
+        mesh->GetVertexData(reinterpret_cast<float*>(data.data()));
         break;
     }
     case RPR_MESH_NORMAL_ARRAY:
     {
-        const RadeonRays::float3* value = mesh->GetNormalData();
-        size_ret = sizeof(RadeonRays::float3) * mesh->GetNormalCount();
+        size_ret = sizeof(float) * 3 * mesh->GetNormalCount();
         data.resize(size_ret);
-        memcpy(&data[0], &value, size_ret);
+        mesh->GetNormalData(reinterpret_cast<float*>(data.data()));
         break;
 
     }
@@ -1164,26 +1163,26 @@ rpr_int rprMeshGetInfo(rpr_shape in_mesh, rpr_mesh_info in_mesh_info, size_t in_
         const RadeonRays::float2* value = mesh->GetUVData();
         size_ret = sizeof(RadeonRays::float2) * mesh->GetUVCount();
         data.resize(size_ret);
-        memcpy(&data[0], &value, size_ret);
+        memcpy(&data[0], value, size_ret);
         break;
     }
     case RPR_MESH_VERTEX_INDEX_ARRAY:
     case RPR_MESH_UV_INDEX_ARRAY:
     case RPR_MESH_NORMAL_INDEX_ARRAY:
     {
         const uint32_t* value = mesh->GetIndicesData();
-        size_ret = sizeof(uint32_t) * mesh->GetVertexCount();
+        size_ret = sizeof(uint32_t) * mesh->GetIndicesCount();
         data.resize(size_ret);
-        memcpy(&data[0], &value, size_ret);
+        memcpy(&data[0], value, size_ret);
         break;
     }
     case RPR_MESH_NUM_FACE_VERTICES_ARRAY:
     {
         //only triangles used in Baikal mesh
-        std::vector<int32_t> value(mesh->GetVertexCount() / 3, 3);
-        size_ret = sizeof(value);
+        std::vector<int32_t> value(mesh->GetIndicesCount() / 3, 3);
+        size_ret = sizeof(int32_t) * value.size();
         data.resize(size_ret);
-        memcpy(&data[0], &value, size_ret);
+        memcpy(&data[0], value.data(), size_ret);
         break;
     }
     default:
@@ -1493,14 +1492,15 @@ rpr_int rprLightGetInfo(rpr_light in_light, rpr_light_info in_info, size_t in_si
     case RPR_LIGHT_TRANSFORM:
     {
         RadeonRays::matrix value = light->GetTransform();
+        value = value.transpose();
         size_ret = sizeof(value);
         data.resize(size_ret);
         memcpy(&data[0], &value, size_ret);
         break;
     }
     case RPR_ENVIRONMENT_LIGHT_IMAGE:
     {
-        RadeonRays::matrix value = light->GetTransform();
+        MaterialObject* value = light->GetEnvTexture();
         size_ret = sizeof(value);
         data.resize(size_ret);
         memcpy(&data[0], &value, size_ret);
@@ -2036,7 +2036,8 @@ rpr_int rprMaterialNodeGetInputInfo(rpr_material_node in_node, rpr_int in_input_
     }
     case RPR_MATERIAL_NODE_INPUT_VALUE:
     {
-        data.resize(sizeof(size_t));
+        //sizeof(RadeonRays::float4) should be enough to store any input data
+        data.resize(sizeof(RadeonRays::float4));
         mat->GetInput(in_input_idx, data.data(), &size_ret);
         break;
     }
diff --git a/Rpr/WrapObject/CameraObject.cpp b/Rpr/WrapObject/CameraObject.cpp
@@ -21,7 +21,7 @@ THE SOFTWARE.
 ********************************************************************/
 
 #include "WrapObject/CameraObject.h"
-#include "Scene/camera.h"
+#include "SceneGraph/camera.h"
 #include "radeon_rays.h"
 
 using namespace Baikal;
@@ -75,6 +75,6 @@ void CameraObject::GetLookAt(RadeonRays::float3& eye,
     RadeonRays::float3& up)
 {
     eye = m_cam->GetPosition();
-    at = m_cam->GetForwardVector();
+    at = m_cam->GetForwardVector() + eye;
     up = m_cam->GetUpVector();
 }
diff --git a/Rpr/WrapObject/CameraObject.h b/Rpr/WrapObject/CameraObject.h
@@ -22,7 +22,7 @@ THE SOFTWARE.
 #pragma once
 
 #include "WrapObject.h"
-#include "Scene/camera.h"
+#include "SceneGraph/camera.h"
 
 #include "math/matrix.h"
 #include "RadeonProRender.h"
@@ -42,13 +42,13 @@ class CameraObject
     //camera data
     //Note: some values are converted between meters and mm
     void SetFocalLength(rpr_float flen) { m_cam->SetFocalLength(flen / 1000.f); }
-    rpr_float GetFocalLength() { return m_cam->GetFocalLength(); }
+    rpr_float GetFocalLength() { return m_cam->GetFocalLength() * 1000.f; }
 
     void SetFocusDistance(rpr_float fdist) { m_cam->SetFocusDistance(fdist); }
     rpr_float GetFocusDistance() { return m_cam->GetFocusDistance(); }
 
-    void SetSensorSize(RadeonRays::float2 size) { m_cam->SetSensorSize(size * 0.001); }
-    RadeonRays::float2 GetSensorSize() { return m_cam->GetSensorSize() * 1000; }
+    void SetSensorSize(RadeonRays::float2 size) { m_cam->SetSensorSize(size * 0.001f); }
+    RadeonRays::float2 GetSensorSize() { return m_cam->GetSensorSize() * 1000.f; }
 
     void GetLookAt(RadeonRays::float3& eye,
                 RadeonRays::float3& at,
diff --git a/Rpr/WrapObject/ContextObject.cpp b/Rpr/WrapObject/ContextObject.cpp
@@ -30,10 +30,10 @@ THE SOFTWARE.
 #include "WrapObject/MaterialObject.h"
 #include "WrapObject/Exception.h"
 
-#include "Scene/scene1.h"
-#include "Scene/iterator.h"
-#include "Scene/material.h"
-#include "Scene/light.h"
+#include "SceneGraph/scene1.h"
+#include "SceneGraph/iterator.h"
+#include "SceneGraph/material.h"
+#include "SceneGraph/light.h"
 
 namespace
 {
diff --git a/Rpr/WrapObject/ContextObject.h b/Rpr/WrapObject/ContextObject.h
@@ -24,8 +24,8 @@ THE SOFTWARE.
 #include "WrapObject/WrapObject.h"
 #include "WrapObject/LightObject.h"
 
-#include "App/config_manager.h"
-#include "App/PT/ptrenderer.h"
+#include "App/Utils/config_manager.h"
+#include "App/Renderers/PT/ptrenderer.h"
 
 #include <vector>
 #include "RadeonProRender.h"
diff --git a/Rpr/WrapObject/LightObject.cpp b/Rpr/WrapObject/LightObject.cpp
@@ -23,12 +23,12 @@ THE SOFTWARE.
 #include "WrapObject/MaterialObject.h"
 #include "WrapObject/Exception.h"
 #include "radeon_rays.h"
-#include "App/Scene/light.h"
+#include "App/SceneGraph/light.h"
 #include "RadeonProRender.h"
 
 void LightObject::SetTransform(const RadeonRays::matrix& t)
 {
-    m_light->SetPosition(RadeonRays::float3(t.m30, t.m31, t.m32, t.m33));
+    m_light->SetPosition(RadeonRays::float3(t.m03, t.m13, t.m23, t.m33));
     //float3(0, 0, -1) is a default direction vector
     m_light->SetDirection(t * RadeonRays::float3(0, 0, -1));
 }
diff --git a/Rpr/WrapObject/MaterialObject.cpp b/Rpr/WrapObject/MaterialObject.cpp
@@ -23,10 +23,10 @@ THE SOFTWARE.
 #include <map>
 
 #include "math/int2.h"
-#include "App/Scene/texture.h"
-#include "App/Scene/material.h"
-#include "App/Scene/IO/image_io.h"
-#include "App/Scene/iterator.h"
+#include "App/SceneGraph/texture.h"
+#include "App/SceneGraph/material.h"
+#include "App/SceneGraph/IO/image_io.h"
+#include "App/SceneGraph/iterator.h"
 #include "WrapObject/MaterialObject.h"
 #include "WrapObject/Exception.h"
 
@@ -627,7 +627,7 @@ void MaterialObject::GetInput(int i, void* out, size_t* out_size)
 rpr_image_desc MaterialObject::GetTextureDesc() const
 {
     RadeonRays::int2 size = m_tex->GetSize();
-    rpr_uint depth = m_tex->GetSizeInBytes() / size.x / size.y;
+    rpr_uint depth = (rpr_uint)m_tex->GetSizeInBytes() / size.x / size.y;
     return {(rpr_uint)size.x, (rpr_uint)size.y, depth, 0, 0};
 }
 char const* MaterialObject::GetTextureData() const
diff --git a/Rpr/WrapObject/SceneObject.cpp b/Rpr/WrapObject/SceneObject.cpp
@@ -24,11 +24,11 @@ THE SOFTWARE.
 #include "WrapObject/ShapeObject.h"
 #include "WrapObject/LightObject.h"
 #include "WrapObject/CameraObject.h"
-#include "App/Scene/scene1.h"
-#include "App/Scene/light.h"
-#include "App/Scene/shape.h"
-#include "App/Scene/material.h"
-#include "App/Scene/iterator.h"
+#include "App/SceneGraph/scene1.h"
+#include "App/SceneGraph/light.h"
+#include "App/SceneGraph/shape.h"
+#include "App/SceneGraph/material.h"
+#include "App/SceneGraph/iterator.h"
 
 #include <assert.h>
 
diff --git a/Rpr/WrapObject/SceneObject.h b/Rpr/WrapObject/SceneObject.h
@@ -22,9 +22,9 @@ THE SOFTWARE.
 #pragma once
 
 #include "WrapObject/WrapObject.h"
-#include "Scene/scene1.h"
-#include "Scene/shape.h"
-#include "Scene/light.h"
+#include "SceneGraph/scene1.h"
+#include "SceneGraph/shape.h"
+#include "SceneGraph/light.h"
 
 #include <vector>
 
diff --git a/Rpr/WrapObject/ShapeObject.cpp b/Rpr/WrapObject/ShapeObject.cpp
@@ -25,7 +25,7 @@ THE SOFTWARE.
 
 #include "WrapObject/ShapeObject.h"
 #include "WrapObject/Exception.h"
-#include "App/Scene/shape.h"
+#include "App/SceneGraph/shape.h"
 
 
 using namespace Baikal;
@@ -46,7 +46,7 @@ namespace
 				count +=in_num_face_vertices[i];
 			}
 			result.resize(count * size);
-			std::fill(result.begin(), result.end(), 0);
+			std::fill(result.begin(), result.end(), 0.f);
 
 			return result;
 		}
@@ -191,14 +191,23 @@ uint64_t ShapeObject::GetVertexCount()
     return mesh->GetNumVertices();
 }
 
-const RadeonRays::float3* ShapeObject::GetVertexData() const
+void ShapeObject::GetVertexData(float* out) const
 {
     Baikal::Mesh* mesh = dynamic_cast<Baikal::Mesh*>(m_shape);
     if (!mesh)
     {
         throw Exception(RPR_ERROR_INTERNAL_ERROR, "ShapeObject: mesh is nullptr.");
     }
-    return mesh->GetVertices();
+
+    //need to copy data, because RadeonRays::float3 contains 4 float,
+    //but we need only 3
+    const RadeonRays::float3 * data = mesh->GetVertices();
+    for (int i = 0; i < mesh->GetNumVertices(); ++i)
+    {
+        out[3 * i] = data[i].x;
+        out[3 * i + 1] = data[i].y;
+        out[3 * i + 2] = data[i].z;
+    }
 }
 
 
@@ -211,14 +220,23 @@ uint64_t ShapeObject::GetNormalCount()
     }
     return mesh->GetNumNormals();
 }
-const RadeonRays::float3* ShapeObject::GetNormalData() const
+void ShapeObject::GetNormalData(float* out) const
 {
     Baikal::Mesh* mesh = dynamic_cast<Baikal::Mesh*>(m_shape);
     if (!mesh)
     {
         throw Exception(RPR_ERROR_INTERNAL_ERROR, "ShapeObject: mesh is nullptr.");
     }
-    return mesh->GetNormals();
+    
+    //need to copy data, because RadeonRays::float3 contains 4 float,
+    //but we need only 3
+    const RadeonRays::float3 * data = mesh->GetNormals();
+    for (int i = 0; i < mesh->GetNumNormals(); ++i)
+    {
+        out[3 * i] = data[i].x;
+        out[3 * i + 1] = data[i].y;
+        out[3 * i + 2] = data[i].z;
+    }
 }
 
 
@@ -249,3 +267,13 @@ const uint32_t* ShapeObject::GetIndicesData() const
     }
     return mesh->GetIndices();
 }
+
+uint64_t ShapeObject::GetIndicesCount() const
+{
+    Baikal::Mesh* mesh = dynamic_cast<Baikal::Mesh*>(m_shape);
+    if (!mesh)
+    {
+        throw Exception(RPR_ERROR_INTERNAL_ERROR, "ShapeObject: mesh is nullptr.");
+    }
+    return mesh->GetNumIndices();
+}
diff --git a/Rpr/WrapObject/ShapeObject.h b/Rpr/WrapObject/ShapeObject.h
@@ -22,7 +22,7 @@ THE SOFTWARE.
 #pragma once
 
 #include "RadeonProRender.h"
-#include "App/Scene/shape.h"
+#include "App/SceneGraph/shape.h"
 #include "WrapObject/WrapObject.h"
 #include "WrapObject/MaterialObject.h"
 
@@ -50,7 +50,7 @@ class ShapeObject
 
     ShapeObject* CreateInstance();
 
-    bool IsInstance() { return m_base_obj; }
+    bool IsInstance() { return m_base_obj != nullptr; }
     
     //Set/Get methods
     void SetTransform(const RadeonRays::matrix& m) { m_shape->SetTransform(m); };
@@ -60,15 +60,16 @@ class ShapeObject
     MaterialObject* GetMaterial() { return m_current_mat; }
     
     uint64_t GetVertexCount();
-    const RadeonRays::float3* GetVertexData() const;
+    void GetVertexData(float* out) const;
     
     uint64_t GetNormalCount();
-    const RadeonRays::float3* GetNormalData() const;
+    void GetNormalData(float* out) const;
     
     uint64_t GetUVCount();
     const RadeonRays::float2* GetUVData() const;
 
     const uint32_t* GetIndicesData() const;
+    uint64_t GetIndicesCount() const;
 
     ShapeObject* GetBaseShape() { return m_base_obj; }
     Baikal::Shape* GetShape() { return m_shape; }

Original file line number	Diff line number	Diff line change
`@@ -922,7 +922,7 @@ rpr_int rprShapeSetDisplacementScale(rpr_shape shape, rpr_float minscale, rpr_fl`
`922`	`922`
`923`	`923`	`rpr_int rprShapeSetObjectGroupID(rpr_shape shape, rpr_uint objectGroupID)`
`924`	`924`	`{`
`925`		`- UNIMLEMENTED_FUNCTION`
	`925`	`+ UNSUPPORTED_FUNCTION`
`926`	`926`	`}`
`927`	`927`
`928`	`928`	`rpr_int rprShapeSetDisplacementImage(rpr_shape shape, rpr_image image)`
`@@ -1048,6 +1048,7 @@ rpr_int rprShapeGetInfo(rpr_shape in_shape, rpr_shape_info in_info, size_t in_si`
`1048`	`1048`	`case RPR_SHAPE_TRANSFORM:`
`1049`	`1049`	`{`
`1050`	`1050`	`RadeonRays::matrix value = shape->GetTransform();`
	`1051`	`+ value = value.transpose();`
`1051`	`1052`	`size_ret = sizeof(value);`
`1052`	`1053`	`data.resize(size_ret);`
`1053`	`1054`	`memcpy(&data[0], &value, size_ret);`
`@@ -1144,18 +1145,16 @@ rpr_int rprMeshGetInfo(rpr_shape in_mesh, rpr_mesh_info in_mesh_info, size_t in_`
`1144`	`1145`	`}`
`1145`	`1146`	`case RPR_MESH_VERTEX_ARRAY:`
`1146`	`1147`	`{`
`1147`		`- const RadeonRays::float3* value = mesh->GetVertexData();`
`1148`		`- size_ret = sizeof(RadeonRays::float3) * mesh->GetVertexCount();`
	`1148`	`+ size_ret = sizeof(float) * 3 * mesh->GetVertexCount();`
`1149`	`1149`	`data.resize(size_ret);`
`1150`		`- memcpy(&data[0], &value, size_ret);`
	`1150`	`+ mesh->GetVertexData(reinterpret_cast<float*>(data.data()));`
`1151`	`1151`	`break;`
`1152`	`1152`	`}`
`1153`	`1153`	`case RPR_MESH_NORMAL_ARRAY:`
`1154`	`1154`	`{`
`1155`		`- const RadeonRays::float3* value = mesh->GetNormalData();`
`1156`		`- size_ret = sizeof(RadeonRays::float3) * mesh->GetNormalCount();`
	`1155`	`+ size_ret = sizeof(float) * 3 * mesh->GetNormalCount();`
`1157`	`1156`	`data.resize(size_ret);`
`1158`		`- memcpy(&data[0], &value, size_ret);`
	`1157`	`+ mesh->GetNormalData(reinterpret_cast<float*>(data.data()));`
`1159`	`1158`	`break;`
`1160`	`1159`
`1161`	`1160`	`}`
`@@ -1164,26 +1163,26 @@ rpr_int rprMeshGetInfo(rpr_shape in_mesh, rpr_mesh_info in_mesh_info, size_t in_`
`1164`	`1163`	`const RadeonRays::float2* value = mesh->GetUVData();`
`1165`	`1164`	`size_ret = sizeof(RadeonRays::float2) * mesh->GetUVCount();`
`1166`	`1165`	`data.resize(size_ret);`
`1167`		`- memcpy(&data[0], &value, size_ret);`
	`1166`	`+ memcpy(&data[0], value, size_ret);`
`1168`	`1167`	`break;`
`1169`	`1168`	`}`
`1170`	`1169`	`case RPR_MESH_VERTEX_INDEX_ARRAY:`
`1171`	`1170`	`case RPR_MESH_UV_INDEX_ARRAY:`
`1172`	`1171`	`case RPR_MESH_NORMAL_INDEX_ARRAY:`
`1173`	`1172`	`{`
`1174`	`1173`	`const uint32_t* value = mesh->GetIndicesData();`
`1175`		`- size_ret = sizeof(uint32_t) * mesh->GetVertexCount();`
	`1174`	`+ size_ret = sizeof(uint32_t) * mesh->GetIndicesCount();`
`1176`	`1175`	`data.resize(size_ret);`
`1177`		`- memcpy(&data[0], &value, size_ret);`
	`1176`	`+ memcpy(&data[0], value, size_ret);`
`1178`	`1177`	`break;`
`1179`	`1178`	`}`
`1180`	`1179`	`case RPR_MESH_NUM_FACE_VERTICES_ARRAY:`
`1181`	`1180`	`{`
`1182`	`1181`	`//only triangles used in Baikal mesh`
`1183`		`- std::vector<int32_t> value(mesh->GetVertexCount() / 3, 3);`
`1184`		`- size_ret = sizeof(value);`
	`1182`	`+ std::vector<int32_t> value(mesh->GetIndicesCount() / 3, 3);`
	`1183`	`+ size_ret = sizeof(int32_t) * value.size();`
`1185`	`1184`	`data.resize(size_ret);`
`1186`		`- memcpy(&data[0], &value, size_ret);`
	`1185`	`+ memcpy(&data[0], value.data(), size_ret);`
`1187`	`1186`	`break;`
`1188`	`1187`	`}`
`1189`	`1188`	`default:`
`@@ -1493,14 +1492,15 @@ rpr_int rprLightGetInfo(rpr_light in_light, rpr_light_info in_info, size_t in_si`
`1493`	`1492`	`case RPR_LIGHT_TRANSFORM:`
`1494`	`1493`	`{`
`1495`	`1494`	`RadeonRays::matrix value = light->GetTransform();`
	`1495`	`+ value = value.transpose();`
`1496`	`1496`	`size_ret = sizeof(value);`
`1497`	`1497`	`data.resize(size_ret);`
`1498`	`1498`	`memcpy(&data[0], &value, size_ret);`
`1499`	`1499`	`break;`
`1500`	`1500`	`}`
`1501`	`1501`	`case RPR_ENVIRONMENT_LIGHT_IMAGE:`
`1502`	`1502`	`{`
`1503`		`- RadeonRays::matrix value = light->GetTransform();`
	`1503`	`+ MaterialObject* value = light->GetEnvTexture();`
`1504`	`1504`	`size_ret = sizeof(value);`
`1505`	`1505`	`data.resize(size_ret);`
`1506`	`1506`	`memcpy(&data[0], &value, size_ret);`
`@@ -2036,7 +2036,8 @@ rpr_int rprMaterialNodeGetInputInfo(rpr_material_node in_node, rpr_int in_input_`
`2036`	`2036`	`}`
`2037`	`2037`	`case RPR_MATERIAL_NODE_INPUT_VALUE:`
`2038`	`2038`	`{`
`2039`		`- data.resize(sizeof(size_t));`
	`2039`	`+ //sizeof(RadeonRays::float4) should be enough to store any input data`
	`2040`	`+ data.resize(sizeof(RadeonRays::float4));`
`2040`	`2041`	`mat->GetInput(in_input_idx, data.data(), &size_ret);`
`2041`	`2042`	`break;`
`2042`	`2043`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ THE SOFTWARE.`
`21`	`21`	`********************************************************************/`
`22`	`22`
`23`	`23`	`#include "WrapObject/CameraObject.h"`
`24`		`-#include "Scene/camera.h"`
	`24`	`+#include "SceneGraph/camera.h"`
`25`	`25`	`#include "radeon_rays.h"`
`26`	`26`
`27`	`27`	`using namespace Baikal;`
`@@ -75,6 +75,6 @@ void CameraObject::GetLookAt(RadeonRays::float3& eye,`
`75`	`75`	`RadeonRays::float3& up)`
`76`	`76`	`{`
`77`	`77`	`eye = m_cam->GetPosition();`
`78`		`- at = m_cam->GetForwardVector();`
	`78`	`+ at = m_cam->GetForwardVector() + eye;`
`79`	`79`	`up = m_cam->GetUpVector();`
`80`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,12 +23,12 @@ THE SOFTWARE.`
`23`	`23`	`#include "WrapObject/MaterialObject.h"`
`24`	`24`	`#include "WrapObject/Exception.h"`
`25`	`25`	`#include "radeon_rays.h"`
`26`		`-#include "App/Scene/light.h"`
	`26`	`+#include "App/SceneGraph/light.h"`
`27`	`27`	`#include "RadeonProRender.h"`
`28`	`28`
`29`	`29`	`void LightObject::SetTransform(const RadeonRays::matrix& t)`
`30`	`30`	`{`
`31`		`- m_light->SetPosition(RadeonRays::float3(t.m30, t.m31, t.m32, t.m33));`
	`31`	`+ m_light->SetPosition(RadeonRays::float3(t.m03, t.m13, t.m23, t.m33));`
`32`	`32`	`//float3(0, 0, -1) is a default direction vector`
`33`	`33`	`m_light->SetDirection(t * RadeonRays::float3(0, 0, -1));`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ THE SOFTWARE.`
`25`	`25`
`26`	`26`	`#include "WrapObject/ShapeObject.h"`
`27`	`27`	`#include "WrapObject/Exception.h"`
`28`		`-#include "App/Scene/shape.h"`
	`28`	`+#include "App/SceneGraph/shape.h"`
`29`	`29`
`30`	`30`
`31`	`31`	`using namespace Baikal;`
`@@ -46,7 +46,7 @@ namespace`
`46`	`46`	`count +=in_num_face_vertices[i];`
`47`	`47`	`}`
`48`	`48`	`result.resize(count * size);`
`49`		`- std::fill(result.begin(), result.end(), 0);`
	`49`	`+ std::fill(result.begin(), result.end(), 0.f);`
`50`	`50`
`51`	`51`	`return result;`
`52`	`52`	`}`
`@@ -191,14 +191,23 @@ uint64_t ShapeObject::GetVertexCount()`
`191`	`191`	`return mesh->GetNumVertices();`
`192`	`192`	`}`
`193`	`193`
`194`		`-const RadeonRays::float3* ShapeObject::GetVertexData() const`
	`194`	`+void ShapeObject::GetVertexData(float* out) const`
`195`	`195`	`{`
`196`	`196`	`Baikal::Mesh* mesh = dynamic_cast<Baikal::Mesh*>(m_shape);`
`197`	`197`	`if (!mesh)`
`198`	`198`	`{`
`199`	`199`	`throw Exception(RPR_ERROR_INTERNAL_ERROR, "ShapeObject: mesh is nullptr.");`
`200`	`200`	`}`
`201`		`- return mesh->GetVertices();`
	`201`	`+`
	`202`	`+ //need to copy data, because RadeonRays::float3 contains 4 float,`
	`203`	`+ //but we need only 3`
	`204`	`+ const RadeonRays::float3 * data = mesh->GetVertices();`
	`205`	`+ for (int i = 0; i < mesh->GetNumVertices(); ++i)`
	`206`	`+ {`
	`207`	`+ out[3 * i] = data[i].x;`
	`208`	`+ out[3 * i + 1] = data[i].y;`
	`209`	`+ out[3 * i + 2] = data[i].z;`
	`210`	`+ }`
`202`	`211`	`}`
`203`	`212`
`204`	`213`
`@@ -211,14 +220,23 @@ uint64_t ShapeObject::GetNormalCount()`
`211`	`220`	`}`
`212`	`221`	`return mesh->GetNumNormals();`
`213`	`222`	`}`
`214`		`-const RadeonRays::float3* ShapeObject::GetNormalData() const`
	`223`	`+void ShapeObject::GetNormalData(float* out) const`
`215`	`224`	`{`
`216`	`225`	`Baikal::Mesh* mesh = dynamic_cast<Baikal::Mesh*>(m_shape);`
`217`	`226`	`if (!mesh)`
`218`	`227`	`{`
`219`	`228`	`throw Exception(RPR_ERROR_INTERNAL_ERROR, "ShapeObject: mesh is nullptr.");`
`220`	`229`	`}`
`221`		`- return mesh->GetNormals();`
	`230`	`+`
	`231`	`+ //need to copy data, because RadeonRays::float3 contains 4 float,`
	`232`	`+ //but we need only 3`
	`233`	`+ const RadeonRays::float3 * data = mesh->GetNormals();`
	`234`	`+ for (int i = 0; i < mesh->GetNumNormals(); ++i)`
	`235`	`+ {`
	`236`	`+ out[3 * i] = data[i].x;`
	`237`	`+ out[3 * i + 1] = data[i].y;`
	`238`	`+ out[3 * i + 2] = data[i].z;`
	`239`	`+ }`
`222`	`240`	`}`
`223`	`241`
`224`	`242`
`@@ -249,3 +267,13 @@ const uint32_t* ShapeObject::GetIndicesData() const`
`249`	`267`	`}`
`250`	`268`	`return mesh->GetIndices();`
`251`	`269`	`}`
	`270`	`+`
	`271`	`+uint64_t ShapeObject::GetIndicesCount() const`
	`272`	`+{`
	`273`	`+ Baikal::Mesh* mesh = dynamic_cast<Baikal::Mesh*>(m_shape);`
	`274`	`+ if (!mesh)`
	`275`	`+ {`
	`276`	`+ throw Exception(RPR_ERROR_INTERNAL_ERROR, "ShapeObject: mesh is nullptr.");`
	`277`	`+ }`
	`278`	`+ return mesh->GetNumIndices();`
	`279`	`+}`