mirror of
https://github.com/Ttanasart-pt/Pixel-Composer.git
synced 2024-12-26 15:06:22 +01:00
719 lines
21 KiB
Text
719 lines
21 KiB
Text
global.node_rm_primitive_keys = [
|
|
"plane", "box", "box frame", "box round", "cube",
|
|
"sphere", "ellipse", "cut sphere", "cut hollow sphere", "torus", "capped torus",
|
|
"cylinder", "prism", "capsule", "cone", "capped cone", "round cone", "3d arc", "pie",
|
|
"octahedron", "pyramid",
|
|
];
|
|
|
|
function Node_create_RM_Primitive(_x, _y, _group = noone, _param = {}) {
|
|
var query = struct_try_get(_param, "query", "");
|
|
var node = new Node_RM_Primitive(_x, _y, _group).skipDefault();
|
|
|
|
switch(query) {
|
|
case "cube" : ind = array_find_string(node.shape_types, "box"); break;
|
|
|
|
default : ind = array_find_string(node.shape_types, query);
|
|
}
|
|
|
|
if(ind >= 0) node.inputs[1].setValue(ind);
|
|
return node;
|
|
}
|
|
|
|
function Node_RM_Primitive(_x, _y, _group = noone) : Node_RM(_x, _y, _group) constructor {
|
|
name = "RM Primitive";
|
|
|
|
newInput(0, nodeValue_Dimension(self));
|
|
|
|
shape_types = [
|
|
"Plane", "Box", "Box Frame", "Box Round",
|
|
-1,
|
|
"Sphere", "Ellipse", "Cut Sphere", "Cut Hollow Sphere", "Torus", "Capped Torus",
|
|
-1,
|
|
"Cylinder", "Prism", "Capsule", "Cone", "Capped Cone", "Round Cone", "3D Arc", "Pie",
|
|
-1,
|
|
"Octahedron", "Pyramid",
|
|
];
|
|
shape_types_str = [];
|
|
|
|
var _ind = 0;
|
|
for( var i = 0, n = array_length(shape_types); i < n; i++ )
|
|
shape_types_str[i] = shape_types[i] == -1? -1 : new scrollItem(shape_types[i], s_node_shape_3d, _ind++, COLORS._main_icon_light);
|
|
|
|
newInput(1, nodeValue_Enum_Scroll("Shape", self, 1, { data: shape_types_str, horizontal: true, text_pad: ui(16) }));
|
|
|
|
newInput(2, nodeValue_Vec3("Position", self, [ 0, 0, 0 ]));
|
|
|
|
newInput(3, nodeValue_Vec3("Rotation", self, [ 0, 0, 0 ]));
|
|
|
|
newInput(4, nodeValue_Float("Scale", self, 1))
|
|
.setDisplay(VALUE_DISPLAY.slider, { range: [ 0, 4, 0.01 ] });
|
|
|
|
newInput(5, nodeValue_Float("FOV", self, 30))
|
|
.setDisplay(VALUE_DISPLAY.slider, { range: [ 0, 90, 1 ] });
|
|
|
|
newInput(6, nodeValue_Vec2("View Range", self, [ 3, 6 ]));
|
|
|
|
newInput(7, nodeValue_Float("Depth", self, 0))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
newInput(8, nodeValue_Vec3("Light Position", self, [ -.4, -.5, 1 ]));
|
|
|
|
newInput(9, nodeValue_Color("Base Color", self, cola(c_white)));
|
|
|
|
newInput(10, nodeValue_Float("Ambient Level", self, 0.2))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
newInput(11, nodeValue_Vec3("Elongate", self, [ 0, 0, 0 ]));
|
|
|
|
newInput(12, nodeValue_Float("Rounded", self, 0.))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
newInput(13, nodeValue_Enum_Button("Projection", self, 0, [ "Perspective", "Orthographic" ]));
|
|
|
|
newInput(14, nodeValue_Float("Ortho Scale", self, 1.))
|
|
|
|
newInput(15, nodeValue_Vec3("Wave Amplitude", self, [ 4, 4, 4 ]));
|
|
|
|
newInput(16, nodeValue_Vec3("Wave Intensity", self, [ 0, 0, 0 ]));
|
|
|
|
newInput(17, nodeValue_Vec3("Wave Phase", self, [ 0, 0, 0 ]));
|
|
|
|
newInput(18, nodeValue_Enum_Button("Twist Axis", self, 0, [ "X", "Y", "Z" ]));
|
|
|
|
newInput(19, nodeValue_Float("Twist Amount", self, 0))
|
|
.setDisplay(VALUE_DISPLAY.slider, { range: [ 0, 8, 0.1 ] });
|
|
|
|
newInput(20, nodeValue_Vec3("Tile Distance", self, [ 1, 1, 1 ]));
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
newInput(21, nodeValue_Vec3("Size", self, [ 1, 1, 1 ]));
|
|
|
|
newInput(22, nodeValue_Float("Radius", self, .7))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
newInput(23, nodeValue_Float("Thickness", self, .2))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
newInput(24, nodeValue_Float("Crop", self, 0.))
|
|
.setDisplay(VALUE_DISPLAY.slider, { range: [ -1, 1, 0.01 ] });
|
|
|
|
newInput(25, nodeValue_Rotation("Angle", self, 30));
|
|
|
|
newInput(26, nodeValue_Float("Height", self, .5))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
newInput(27, nodeValue_Slider_Range("Radius Range", self, [ .7, .1 ]));
|
|
|
|
newInput(28, nodeValue_Float("Uniform Size", self, 1))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
newInput(29, nodeValue_Vec3("Tile Amount", self, [ 1, 1, 1 ]));
|
|
|
|
newInput(30, nodeValue_Color("Background", self, cola(c_black)));
|
|
|
|
newInput(31, nodeValue_Bool("Draw BG", self, false));
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
newInput(32, nodeValue_Bool("Volumetric", self, false));
|
|
|
|
newInput(33, nodeValue_Float("Density", self, 0.3))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
newInput(34, nodeValue_Surface("Environment", self));
|
|
|
|
newInput(35, nodeValue_Float("Reflective", self, 0.))
|
|
.setDisplay(VALUE_DISPLAY.slider);
|
|
|
|
newInput(36, nodeValue_Surface("Texture", self));
|
|
|
|
newInput(37, nodeValue_Float("Triplanar Smoothing", self, 1.))
|
|
.setDisplay(VALUE_DISPLAY.slider, { range: [ 0, 10, 0.1 ] });
|
|
|
|
newInput(38, nodeValue_Float("Texture Scale", self, 1.));
|
|
|
|
newInput(39, nodeValue_Vec4("Corner", self, [ 0.25, 0.25, 0.25, 0.25 ]));
|
|
|
|
newInput(40, nodeValue_Vec2("2D Size", self, [ 0.5, 0.5 ]));
|
|
|
|
newInput(41, nodeValue_Int("Side", self, 3));
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
newInput(42, nodeValue_Vec3("Camera Rotation", self, [ 30, 45, 0 ]));
|
|
|
|
newInput(43, nodeValue_Float("Camera Scale", self, 1))
|
|
.setDisplay(VALUE_DISPLAY.slider, { range: [ 0, 4, 0.01 ] });
|
|
|
|
newInput(44, nodeValue_Bool("Render", self, true));
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
newInput(45, nodeValue_Bool("Tile", self, false));
|
|
|
|
newInput(46, nodeValue_Vec3("Tiled Shift", self, [ 0, 0, 0 ]));
|
|
|
|
newInput(47, nodeValue_Vec3("Tiled Rotation", self, [ 0, 0, 0 ]));
|
|
|
|
newInput(48, nodeValue_Float("Tiled Scale", self, 0));
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
newInput(49, nodeValue_Bool("Env Interpolation", self, false));
|
|
|
|
newInput(50, nodeValue_Bool("Texture Interpolation", self, false));
|
|
|
|
newOutput(0, nodeValue_Output("Surface Out", self, VALUE_TYPE.surface, noone));
|
|
|
|
newOutput(1, nodeValue_Output("Shape Data", self, VALUE_TYPE.sdf, noone));
|
|
|
|
input_display_list = [ 0,
|
|
["Primitive", false], 1, 21, 22, 23, 24, 25, 26, 27, 28, 39, 40, 41,
|
|
["Modify", false], 12, 11,
|
|
["Deform", true], 15, 16, 17, 18, 19,
|
|
["Transform", false], 2, 3, 4,
|
|
["Tile", false, 45], 20, 29, /*46, 47, 48,*/
|
|
["Material", false], 9, 36, 50, 35, 37, 38,
|
|
|
|
["Camera", false], 42, 43, 13, 14, 5, 6,
|
|
["Render", false, 44], 31, 30, 34, 49, 10, 7, 8,
|
|
["Volumetric", true, 32], 33,
|
|
];
|
|
|
|
temp_surface = [ 0, 0 ];
|
|
environ = new RM_Environment();
|
|
object = new RM_Shape();
|
|
|
|
tool_pos = new NodeTool( "Transform", THEME.tools_3d_transform, "Node_3D_Object" );
|
|
|
|
tools = [ tool_pos ];
|
|
|
|
#region ---- overlay ----
|
|
drag_axis = noone;
|
|
drag_sv = 0;
|
|
drag_delta = 0;
|
|
drag_pre0 = 0;
|
|
drag_pre1 = 0;
|
|
drag_dist = 0;
|
|
drag_val = 0;
|
|
|
|
drag_mx = 0;
|
|
drag_my = 0;
|
|
drag_px = 0;
|
|
drag_py = 0;
|
|
drag_cx = 0;
|
|
drag_cy = 0;
|
|
drag_rot_axis = new BBMOD_Quaternion();
|
|
|
|
drag_original = 0;
|
|
|
|
axis_hover = noone;
|
|
#endregion
|
|
|
|
static drawGizmoPosition = function(index, _vpos, active, params, _mx, _my, _snx, _sny, _panel) { #region
|
|
#region ---- main ----
|
|
var _pos = inputs[index].getValue(,,, true);
|
|
// _pos = [ -_pos[0], _pos[2], -_pos[1] ];
|
|
var _qinv = new BBMOD_Quaternion().FromAxisAngle(new BBMOD_Vec3(1, 0, 0), 90);
|
|
|
|
var _camera = params.camera;
|
|
var _qview = new BBMOD_Quaternion().FromEuler(_camera.focus_angle_y, -_camera.focus_angle_x, 0);
|
|
|
|
var _hover = noone;
|
|
var _hoverDist = 10;
|
|
var th;
|
|
|
|
var _posView = _camera.worldPointToViewPoint(_vpos);
|
|
|
|
var cx = _posView.x;
|
|
var cy = _posView.y;
|
|
|
|
var ga = [];
|
|
var size = 64;
|
|
var hs = size / 2;
|
|
var sq = 8;
|
|
#endregion
|
|
|
|
#region display
|
|
ga[0] = new BBMOD_Vec3(-size, 0, 0);
|
|
ga[1] = new BBMOD_Vec3(0, 0, size);
|
|
ga[2] = new BBMOD_Vec3(0, -size, 0);
|
|
|
|
ga[3] = [ new BBMOD_Vec3(-hs + sq, 0, hs - sq),
|
|
new BBMOD_Vec3(-hs - sq, 0, hs - sq),
|
|
new BBMOD_Vec3(-hs - sq, 0, hs + sq),
|
|
new BBMOD_Vec3(-hs + sq, 0, hs + sq), ];
|
|
ga[4] = [ new BBMOD_Vec3( 0, -hs + sq, hs - sq),
|
|
new BBMOD_Vec3( 0, -hs - sq, hs - sq),
|
|
new BBMOD_Vec3( 0, -hs - sq, hs + sq),
|
|
new BBMOD_Vec3( 0, -hs + sq, hs + sq), ];
|
|
ga[5] = [ new BBMOD_Vec3(-hs + sq, -hs - sq, 0),
|
|
new BBMOD_Vec3(-hs - sq, -hs - sq, 0),
|
|
new BBMOD_Vec3(-hs - sq, -hs + sq, 0),
|
|
new BBMOD_Vec3(-hs + sq, -hs + sq, 0), ];
|
|
|
|
ga[0] = new BBMOD_Vec3(-size, 0, 0);
|
|
ga[1] = new BBMOD_Vec3(0, -size, 0);
|
|
ga[2] = new BBMOD_Vec3(0, 0, -size);
|
|
|
|
ga[3] = [ new BBMOD_Vec3(-hs + sq, -hs - sq, 0),
|
|
new BBMOD_Vec3(-hs - sq, -hs - sq, 0),
|
|
new BBMOD_Vec3(-hs - sq, -hs + sq, 0),
|
|
new BBMOD_Vec3(-hs + sq, -hs + sq, 0), ];
|
|
ga[4] = [ new BBMOD_Vec3( 0, -hs + sq, -hs - sq),
|
|
new BBMOD_Vec3( 0, -hs - sq, -hs - sq),
|
|
new BBMOD_Vec3( 0, -hs - sq, -hs + sq),
|
|
new BBMOD_Vec3( 0, -hs + sq, -hs + sq), ];
|
|
ga[5] = [ new BBMOD_Vec3(-hs + sq, 0, -hs - sq),
|
|
new BBMOD_Vec3(-hs - sq, 0, -hs - sq),
|
|
new BBMOD_Vec3(-hs - sq, 0, -hs + sq),
|
|
new BBMOD_Vec3(-hs + sq, 0, -hs + sq), ];
|
|
|
|
for( var i = 0; i < 3; i++ ) {
|
|
ga[i] = _qview.Rotate(_qinv.Rotate(ga[i]));
|
|
|
|
th = 2 + (axis_hover == i || drag_axis == i);
|
|
if(drag_axis != noone && drag_axis != i)
|
|
continue;
|
|
|
|
draw_set_color(COLORS.axis[i]);
|
|
if(point_distance(cx, cy, cx + ga[i].X, cy + ga[i].Y) < 5)
|
|
draw_line_round(cx, cy, cx + ga[i].X, cy + ga[i].Y, th);
|
|
else
|
|
draw_line_round_arrow(cx, cy, cx + ga[i].X, cy + ga[i].Y, th, 3);
|
|
|
|
var _d = distance_to_line(_mx, _my, cx, cy, cx + ga[i].X, cy + ga[i].Y);
|
|
if(_d < _hoverDist) {
|
|
_hover = i;
|
|
_hoverDist = _d;
|
|
}
|
|
}
|
|
|
|
// for( var i = 3; i < 6; i++ ) {
|
|
// for( var j = 0; j < 4; j++ )
|
|
// ga[i][j] = _qview.Rotate(_qinv.Rotate(ga[i][j]));
|
|
|
|
// th = 1;
|
|
|
|
// var p0x = cx + ga[i][0].X, p0y = cy + ga[i][0].Y;
|
|
// var p1x = cx + ga[i][1].X, p1y = cy + ga[i][1].Y;
|
|
// var p2x = cx + ga[i][2].X, p2y = cy + ga[i][2].Y;
|
|
// var p3x = cx + ga[i][3].X, p3y = cy + ga[i][3].Y;
|
|
|
|
// var _pax = (p0x + p1x + p2x + p3x) / 4;
|
|
// var _pay = (p0y + p1y + p2y + p3y) / 4;
|
|
|
|
// if((abs(p0x - _pax) + abs(p1x - _pax) + abs(p2x - _pax) + abs(p3x - _pax)) / 4 < 1)
|
|
// continue;
|
|
// if((abs(p0y - _pay) + abs(p1y - _pay) + abs(p2y - _pay) + abs(p3y - _pay)) / 4 < 1)
|
|
// continue;
|
|
|
|
// draw_set_color(COLORS.axis[(i - 3 - 1 + 3) % 3]);
|
|
// if(axis_hover == i || drag_axis == i) {
|
|
// draw_primitive_begin(pr_trianglestrip);
|
|
// draw_vertex(p0x, p0y);
|
|
// draw_vertex(p1x, p1y);
|
|
// draw_vertex(p3x, p3y);
|
|
// draw_vertex(p2x, p2y);
|
|
// draw_primitive_end();
|
|
|
|
// } else if (drag_axis == noone) {
|
|
// draw_line(p0x, p0y, p1x, p1y);
|
|
// draw_line(p1x, p1y, p2x, p2y);
|
|
// draw_line(p2x, p2y, p3x, p3y);
|
|
// draw_line(p3x, p3y, p0x, p0y);
|
|
// } else
|
|
// continue;
|
|
|
|
// if(point_in_rectangle_points(_mx, _my, p0x, p0y, p1x, p1y, p3x, p3y, p2x, p2y))
|
|
// _hover = i;
|
|
// }
|
|
|
|
axis_hover = _hover;
|
|
#endregion display
|
|
|
|
if(drag_axis != noone) { #region editing
|
|
if(!MOUSE_WRAPPING) {
|
|
drag_mx += _mx - drag_px;
|
|
drag_my += _my - drag_py;
|
|
|
|
var mAdj, nor, prj, app;
|
|
|
|
var ray = _camera.viewPointToWorldRay(drag_mx, drag_my);
|
|
var val = [ drag_val[0], drag_val[1], drag_val[2] ];
|
|
|
|
switch(drag_axis) {
|
|
case 0 :
|
|
case 3 : nor = new __vec3(0, 1, 0); prj = new __vec3(1, 0, 0); app = 0; break;
|
|
case 1 :
|
|
case 4 : nor = new __vec3(0, 0, 1); prj = new __vec3(0, 1, 0); app = -2; break;
|
|
case 2 :
|
|
case 5 : nor = new __vec3(1, 0, 0); prj = new __vec3(0, 0, 1); app = 1; break;
|
|
}
|
|
|
|
var pln = new __plane(drag_original, nor);
|
|
mAdj = d3d_intersect_ray_plane(ray, pln);
|
|
|
|
if(drag_pre0 != undefined) {
|
|
var _diff = mAdj.subtract(drag_pre0);
|
|
var _dist = _diff.dot(prj);
|
|
|
|
val[abs(app)] -= _dist * (app >= 0? 1 : -1);
|
|
}
|
|
|
|
drag_pre0 = mAdj;
|
|
|
|
if(inputs[index].setValue(value_snap(val, _snx)))
|
|
UNDO_HOLDING = true;
|
|
|
|
drag_val = [ val[0], val[1], val[2] ];
|
|
}
|
|
|
|
setMouseWrap();
|
|
drag_px = _mx;
|
|
drag_py = _my;
|
|
} #endregion
|
|
|
|
if(_hover != noone && mouse_press(mb_left, active)) { #region
|
|
drag_axis = _hover;
|
|
drag_pre0 = undefined;
|
|
drag_pre1 = undefined;
|
|
drag_mx = _mx;
|
|
drag_my = _my;
|
|
drag_px = _mx;
|
|
drag_py = _my;
|
|
drag_cx = cx;
|
|
drag_cy = cy;
|
|
|
|
drag_val = _pos;
|
|
drag_original = new __vec3(_pos);
|
|
} #endregion
|
|
} #endregion
|
|
|
|
static drawOverlay3D = function(active, params, _mx, _my, _snx, _sny, _panel) {
|
|
var _pos = getSingleValue(2);
|
|
var _camera = params.camera;
|
|
var _vpos = new __vec3( -_pos[0], _pos[2], -_pos[1] );
|
|
|
|
if(isUsingTool("Transform")) drawGizmoPosition(2, _vpos, active, params, _mx, _my, _snx, _sny, _panel);
|
|
|
|
if(drag_axis != noone && mouse_release(mb_left)) {
|
|
drag_axis = noone;
|
|
UNDO_HOLDING = false;
|
|
}
|
|
|
|
}
|
|
|
|
static step = function() {
|
|
var _shp = getSingleValue( 1);
|
|
var _ort = getSingleValue(13);
|
|
var _ren = getSingleValue(44);
|
|
|
|
inputs[21].setVisible(false);
|
|
inputs[22].setVisible(false);
|
|
inputs[23].setVisible(false);
|
|
inputs[24].setVisible(false);
|
|
inputs[25].setVisible(false);
|
|
inputs[26].setVisible(false);
|
|
inputs[27].setVisible(false);
|
|
inputs[28].setVisible(false);
|
|
inputs[39].setVisible(false);
|
|
inputs[40].setVisible(false);
|
|
inputs[41].setVisible(false);
|
|
|
|
outputs[0].setVisible(_ren, _ren);
|
|
|
|
var _shape = shape_types[_shp];
|
|
switch(_shape) { // Size
|
|
case "Box" :
|
|
case "Box Frame" :
|
|
case "Ellipse" :
|
|
inputs[21].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Radius
|
|
case "Sphere" :
|
|
case "Torus" :
|
|
case "Cut Sphere" :
|
|
case "Cut Hollow Sphere" :
|
|
case "Capped Torus" :
|
|
case "Cylinder" :
|
|
case "Capsule" :
|
|
case "3D Arc" :
|
|
case "Pie" :
|
|
inputs[22].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Thickness
|
|
case "Box Frame" :
|
|
case "Box Round" :
|
|
case "Torus" :
|
|
case "Cut Hollow Sphere" :
|
|
case "Capped Torus" :
|
|
case "Terrain" :
|
|
case "Extrude" :
|
|
case "Prism" :
|
|
case "Pie" :
|
|
inputs[23].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Crop
|
|
case "Cut Sphere" :
|
|
case "Cut Hollow Sphere" :
|
|
inputs[24].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Angle
|
|
case "Capped Torus" :
|
|
case "Cone" :
|
|
case "3D Arc" :
|
|
case "Pie" :
|
|
inputs[25].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Height
|
|
case "Cylinder" :
|
|
case "Capsule" :
|
|
case "Cone" :
|
|
case "Capped Cone" :
|
|
case "Round Cone" :
|
|
inputs[26].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Radius Range
|
|
case "Capped Cone" :
|
|
case "Round Cone" :
|
|
inputs[27].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Uniform Size
|
|
case "Octahedron" :
|
|
case "Pyramid" :
|
|
case "Terrain" :
|
|
case "Extrude" :
|
|
inputs[28].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Corner
|
|
case "Box Round" :
|
|
inputs[39].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Size 2D
|
|
case "Box Round" :
|
|
inputs[40].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
switch(_shape) { // Sides
|
|
case "Prism" :
|
|
inputs[41].setVisible(true);
|
|
break;
|
|
}
|
|
|
|
inputs[ 5].setVisible(_ort == 0);
|
|
inputs[14].setVisible(_ort == 1);
|
|
}
|
|
|
|
static processData = function(_outSurf, _data, _output_index, _array_index = 0) {
|
|
var _dim = _data[0];
|
|
var _shp = _data[1];
|
|
|
|
var _pos = _data[2];
|
|
var _rot = _data[3];
|
|
var _sca = _data[4];
|
|
|
|
var _fov = _data[5];
|
|
var _rng = _data[6];
|
|
|
|
var _dpi = _data[7];
|
|
var _lPos = _data[8];
|
|
var _amb = _data[9];
|
|
var _ambI = _data[10];
|
|
var _elon = _data[11];
|
|
var _rond = _data[12];
|
|
|
|
var _ort = _data[13];
|
|
var _ortS = _data[14];
|
|
|
|
var _wavA = _data[15];
|
|
var _wavI = _data[16];
|
|
var _wavS = _data[17];
|
|
var _twsX = _data[18];
|
|
var _twsA = _data[19];
|
|
|
|
var _size = _data[21];
|
|
var _rad = _data[22];
|
|
var _thk = _data[23];
|
|
var _crop = _data[24];
|
|
var _angl = _data[25];
|
|
var _heig = _data[26];
|
|
var _radR = _data[27];
|
|
var _sizz = _data[28];
|
|
var _bgc = _data[30];
|
|
var _bgd = _data[31];
|
|
|
|
var _vol = _data[32];
|
|
var _vden = _data[33];
|
|
var bgEnv = _data[34];
|
|
var _refl = _data[35];
|
|
|
|
var _text = _data[36];
|
|
var _triS = _data[37];
|
|
var _texs = _data[38];
|
|
var _corn = _data[39];
|
|
var _sz2d = _data[40];
|
|
var _side = _data[41];
|
|
|
|
var _crt = _data[42];
|
|
var _csa = _data[43];
|
|
var _ren = _data[44];
|
|
|
|
var _tileActive = _data[45];
|
|
var _tileAmount = _data[29];
|
|
var _tileSpace = _data[20];
|
|
var _tilePos = _data[46];
|
|
var _tileRot = _data[47];
|
|
var _tileSca = _data[48];
|
|
|
|
var _eint = _data[49];
|
|
var _textFilter = _data[50];
|
|
|
|
_outSurf = surface_verify(_outSurf, _dim[0], _dim[1]);
|
|
|
|
for (var i = 0, n = array_length(temp_surface); i < n; i++)
|
|
temp_surface[i] = surface_verify(temp_surface[i], 8192, 8192);
|
|
|
|
var tx = 1024;
|
|
surface_set_shader(temp_surface[0]);
|
|
gpu_set_tex_filter(_eint);
|
|
draw_surface_stretched_safe(bgEnv, tx * 0, tx * 0, tx, tx);
|
|
gpu_set_tex_filter(false);
|
|
surface_reset_shader();
|
|
|
|
var _shape = shape_types[_shp];
|
|
var _shpI = 0;
|
|
|
|
switch(_shape) {
|
|
case "Plane" : _shpI = 100; break;
|
|
case "Box" : _shpI = 101; break;
|
|
case "Box Frame" : _shpI = 102; break;
|
|
case "Box Round" : _shpI = 103; break;
|
|
|
|
case "Sphere" : _shpI = 200; break;
|
|
case "Ellipse" : _shpI = 201; break;
|
|
case "Cut Sphere" : _shpI = 202; break;
|
|
case "Cut Hollow Sphere" : _shpI = 203; _crop = _crop / pi * 2.15; break;
|
|
case "Torus" : _shpI = 204; break;
|
|
case "Capped Torus" : _shpI = 205; break;
|
|
|
|
case "Cylinder" : _shpI = 300; break;
|
|
case "Capsule" : _shpI = 301; break;
|
|
case "Cone" : _shpI = 302; break;
|
|
case "Capped Cone" : _shpI = 303; break;
|
|
case "Round Cone" : _shpI = 304; break;
|
|
case "3D Arc" : _shpI = 305; break;
|
|
case "Prism" : _shpI = 306; break;
|
|
case "Pie" : _shpI = 307; break;
|
|
|
|
case "Octahedron" : _shpI = 400; break;
|
|
case "Pyramid" : _shpI = 401; break;
|
|
}
|
|
|
|
object.operations = -1;
|
|
object.shapeAmount = 1;
|
|
|
|
object.shape = _shpI;
|
|
object.size = _size;
|
|
object.radius = _rad ;
|
|
object.thickness = _thk ;
|
|
object.crop = _crop;
|
|
object.angle = degtorad(_angl);
|
|
object.height = _heig;
|
|
object.radRange = _radR;
|
|
object.sizeUni = _sizz;
|
|
object.elongate = _elon;
|
|
object.rounded = _rond;
|
|
object.corner = _corn;
|
|
object.size2D = _sz2d;
|
|
object.sides = _side;
|
|
|
|
object.waveAmp = _wavA;
|
|
object.waveInt = _wavI;
|
|
object.waveShift = _wavS;
|
|
|
|
object.twistAxis = _twsX;
|
|
object.twistAmount = _twsA;
|
|
|
|
object.position = _pos;
|
|
object.rotation = _rot;
|
|
object.objectScale = _sca;
|
|
|
|
object.tileActive = _tileActive;
|
|
object.tileAmount = _tileAmount;
|
|
object.tileSpace = _tileSpace;
|
|
object.tilePos = _tilePos;
|
|
object.tileRot = _tileRot;
|
|
object.tileSca = _tileSca;
|
|
|
|
object.diffuseColor = colorToArray(_amb, true);
|
|
object.reflective = _refl;
|
|
|
|
object.volumetric = _vol;
|
|
object.volumeDensity = _vden;
|
|
|
|
object.texture = [ _text ];
|
|
object.textureFilter = [ _textFilter ];
|
|
object.useTexture = is_surface(_text);
|
|
object.textureScale = _texs;
|
|
object.triplanar = _triS;
|
|
|
|
object.setTexture(temp_surface[1]);
|
|
|
|
environ.surface = temp_surface[0];
|
|
environ.bgEnv = bgEnv;
|
|
environ.envFilter = _eint;
|
|
|
|
environ.projection = _ort;
|
|
environ.fov = _fov;
|
|
environ.orthoScale = _ortS;
|
|
environ.viewRange = _rng;
|
|
environ.depthInt = _dpi;
|
|
|
|
environ.bgColor = _bgc;
|
|
environ.bgDraw = _bgd;
|
|
environ.ambInten = _ambI;
|
|
environ.light = _lPos;
|
|
|
|
if(_ren) {
|
|
gpu_set_texfilter(true);
|
|
surface_set_shader(_outSurf, sh_rm_primitive);
|
|
|
|
shader_set_f("camRotation", _crt);
|
|
shader_set_f("camScale", _csa);
|
|
shader_set_f("camRatio", _dim[0] / _dim[1]);
|
|
|
|
environ.apply();
|
|
object.apply();
|
|
|
|
draw_sprite_stretched(s_fx_pixel, 0, 0, 0, _dim[0], _dim[1]);
|
|
surface_reset_shader();
|
|
gpu_set_texfilter(false);
|
|
}
|
|
|
|
return [ _outSurf, object ];
|
|
}
|
|
|
|
}
|